Phase 17: Touch UX (PawnDetail+BuildDrawer+WorkMatrix+AlertsLog+Settings)

Three-agent fan-out shipping the major touch UI surfaces. Opus pre-wrote
6 EventBus signals (pawn_selected/deselected, pawn_priority_changed,
alert_added, request_wolf_spawn, day_ended) + Pawn.work_priorities
Dictionary stub before dispatch. Pattern proven across Phases 12-17.

Pawn detail + Settings (Agent A):
- scenes/ui/pawn_detail_panel.gd — right-side CanvasLayer (layer 18),
  ~360px wide, opens on EventBus.pawn_selected. Renders portrait,
  HP/Hunger/Sleep bars with threshold colors, current job, mood +
  sulking, statuses, top 5 mood thoughts, full skill table,
  read-only work-priorities row. Live-refreshes each sim tick.
- scenes/ui/settings_menu.gd — modal CanvasLayer (layer 26), opened
  via Settings button. Auto-pause toggles (Threat/Wanderer/Pawn-Down/
  Modal), audio sliders (stubs for Phase 18), accessibility checkboxes.
  Persists via GameState.apply_settings.
- scenes/world/selection.gd — extended to emit pawn_selected/deselected
  through EventBus on tap.

Build drawer + 12 new Designation tools (Agent B):
- scenes/ui/build_drawer.gd — bottom-sheet CanvasLayer (layer 16) with
  4 tabs (Designate/Build/Stockpile/Cancel) + FAB ⊕ open button.
  Each tab has HFlowContainer of 80×80 buttons with procedural colored
  icons + label. Tap → Designation.set_active_tool + alert + auto-close.
- Designation: added TOOL_CHOP, TOOL_MINE, TOOL_BUILD_CRATE,
  TOOL_BUILD_BED, TOOL_BUILD_TORCH, 5× TOOL_BUILD_WORKBENCH_* variants,
  TOOL_PAINT_STOCKPILE. Plus tool_material override for wall/floor.
- World._on_designation_added: extended dispatch for all 12 new tools;
  added _spawn_workbench() helper for the 5 bench kinds.

Work matrix + Alerts log + Decision refactor + Wolf signal (Agent C):
- scenes/ai/decision.gd: Layer 4 now filters by pawn.work_priorities
  (0=OFF skip, sort by level ascending with provider.priority tiebreak).
  NEEDS_CATEGORIES (rest/eat/sleep) bypass the filter — a pawn can
  never starve from misconfiguration. Audit log prefixes work decisions
  with (pri=N).
- scenes/ui/work_priority_matrix.gd — CanvasLayer (layer 17) bottom-sheet
  grid: rows=pawns × cols=8 work categories. Each cell tap-cycles
  1→2→3→4→0→1, color-coded (red/orange/yellow/blue/gray). Writes back
  to pawn.work_priorities + emits pawn_priority_changed.
- scenes/ui/alerts_log.gd — CanvasLayer (layer 19) ring buffer 50
  entries. Newest first, severity icon (info/warn/danger), Day HH:MM
  timestamp, Go-there camera pan. Listens to alert_added +
  storyteller_event_fired + day_ended.
- EventBus.request_wolf_spawn wired end-to-end: EventCatalog
  _spawn_wolves emits; WolfSpawner._on_request_wolf_spawn force-spawns
  bypassing the darkness/cooldown gates.
- Clock emits EventBus.day_ended(summary) at dusk→night transition.

Top bar buttons added in order: ‖ / 1× / 5× / 12× / Save / Load /
Settings / Build / Work / Log[N]. Plus the ⊕ FAB at bottom-right.

MCP runtime verified all 4 surfaces via screenshot:
- PawnDetailPanel: Bram shows Crafting=8 / Cooking=2 / Manual=0
  matching seed; bars green; Mood: 50; work-priorities readout
- BuildDrawer: 4 tabs visible, Designate tab shows Chop/Mine/Dig grave/
  No roof buttons with procedural icons
- WorkPriorityMatrix: 3 pawns × 8 categories, all '3' (NORMAL default)
  cells in yellow, tap-to-cycle ready
- AlertsLog: 4 entries — red 'Wolf pack approaching!' danger, blue
  'Bram is at the cabin' info, yellow 'Test alert' warn, blue 'Spring
  Awakens' from boot storyteller roll. Go-there button per entry.

Mouse drag-paint works as-is (user noted). Existing
Selection/Designation _unhandled_input handles drag.

Deferred to Phase 17.5 polish:
- Per-pawn/per-job view layers on the matrix
- Stockpile 4×4 chip filter UI (paint creates 1×1 zones today)
- Bill UI for workbenches (programmatic only today)
- 'No stockpile accepts X' / 'Bill blocked' alert emit wiring
- DaySummaryCard visual (signal emits today, no card UI)
- Wanderer recruit UI, resource buff system

Delegation: 3× gdscript-refactor (Sonnet) agents in parallel;
integration + MCP verify on Opus.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

scenes/ai/decision.gd

@@ -40,14 +40,58 @@ static func pick_next_job(pawn, work_providers: Array) -> Job:
 	# Phase 9: status interrupt (Bleeding → seek bed/doctor) lands here.
 
 	# ── Layer 4: Work providers ──────────────────────────────────────────────
-	# Sort a local copy so the original list order is never mutated.
-	var sorted: Array = work_providers.duplicate()
-	sorted.sort_custom(func(a, b): return a.priority > b.priority)
+	# Needs-driven categories are handled entirely by Layer-3 status interrupts
+	# and need-threshold providers (rest/eat/sleep/doctor fire when hunger/sleep
+	# thresholds trigger, not via player priority). We skip the priority filter
+	# for them so a pawn can never accidentally starve because the player set
+	# &"eat" to OFF. The player-configurable list is the 7 work categories:
+	#   construction / chop / plant / mine / crafting / haul / clean
+	# Doctor IS in the matrix (player can opt a pawn out of doctor duty) but
+	# the needs-driven "go heal yourself" path bypasses this filter at Layer 3.
+	const NEEDS_CATEGORIES: Array = [&"rest", &"eat", &"sleep"]
 
-	for wp in sorted:
+	# Pawn's work_priorities dict — empty dict if the field is absent (pre-Phase-17
+	# pawns loaded from old saves). Missing category key defaults to 3 (NORMAL) so
+	# legacy behaviour is preserved exactly.
+	var priorities: Dictionary = {}
+	if pawn.get("work_priorities") != null:
+		priorities = pawn.work_priorities
+
+	# Partition providers: needs bypass the matrix; work providers are filtered.
+	var eligible: Array = []
+	var needs: Array = []
+	for wp in work_providers:
+		if wp.category in NEEDS_CATEGORIES:
+			needs.append(wp)
+		else:
+			# OFF (0) means pawn refuses this category entirely.
+			var lvl: int = int(priorities.get(wp.category, 3))
+			if lvl > 0:
+				eligible.append(wp)
+
+	# Sort eligible by pawn priority ascending (Critical=1 first, Low=4 last),
+	# then by provider.priority descending as tiebreaker.
+	eligible.sort_custom(func(a, b) -> bool:
+		var pa: int = int(priorities.get(a.category, 3))
+		var pb: int = int(priorities.get(b.category, 3))
+		if pa != pb:
+			return pa < pb   # lower pawn-priority-number = higher precedence
+		return a.priority > b.priority  # higher provider.priority = first within tier
+	)
+
+	# Needs providers retain their natural order (sorted by provider.priority only).
+	needs.sort_custom(func(a, b): return a.priority > b.priority)
+
+	# Try needs first (hunger/sleep/rest fire before elective work), then eligible.
+	var to_try: Array = needs + eligible
+
+	for wp in to_try:
 		var j: Job = wp.find_best_for(pawn)
 		if j != null:
-			Audit.log("decision", "%s: %s → '%s'" % [pawn.pawn_name, String(wp.category), j.label])
+			var lvl_str: String = ""
+			if not (wp.category in NEEDS_CATEGORIES):
+				lvl_str = "(pri=%d)" % int(priorities.get(wp.category, 3))
+			Audit.log("decision", "%s: %s%s → '%s'" % [pawn.pawn_name, String(wp.category), lvl_str, j.label])
 			return j
 
 	# ── Layer 5: Idle ────────────────────────────────────────────────────────

scenes/ai/wolf_spawner.gd

@@ -32,6 +32,10 @@ var _last_raid_tick: int = -RAID_COOLDOWN_TICKS
 
 func _ready() -> void:
 	EventBus.sim_tick.connect(_on_sim_tick)
+	# Phase 17 — EventCatalog threat events bypass darkness/cooldown gates and
+	# force-spawn wolves immediately via this signal.
+	if EventBus.has_signal("request_wolf_spawn"):
+		EventBus.request_wolf_spawn.connect(_on_request_wolf_spawn)
 
 
 func _on_sim_tick(n: int) -> void:
@@ -57,6 +61,20 @@ func _trigger_raid(current_tick: int) -> void:
 	Audit.log("wolf", "RAID: %d wolf(ves) spawned at %s" % [pack_size, spawn_tiles])
 
 
+## Phase 17 — force-spawn `count` wolves immediately, bypassing darkness and
+## cooldown gates.  Used by EventCatalog threat events (wolves_at_the_edge,
+## lone_wolf, pack_hunt) which fire at narrative moments regardless of time.
+## _last_raid_tick is NOT updated here — a forced narrative raid does not reset
+## the night-attack cooldown, so organic raids can still follow.
+func _on_request_wolf_spawn(count: int) -> void:
+	var spawn_tiles := _pick_spawn_tiles(count)
+	for spawn_tile in spawn_tiles:
+		var w: Wolf = WOLF_SCENE.instantiate()
+		get_parent().add_child(w)
+		w.setup(spawn_tile)
+	Audit.log("wolf", "FORCED RAID (event): %d wolf(ves) spawned at %s" % [count, spawn_tiles])
+
+
 func _pick_spawn_tiles(count: int) -> Array[Vector2i]:
 	## Choose a random map edge, then return `count` tiles clustered near a
 	## random anchor on that edge. All tiles are inside MAP_EDGE_BLEED to avoid