Phase 6 — Recipe / Bill / Workbench / CraftingProvider / Quality / Skills

Three gdscript-refactor agents in parallel; Opus did integration + caught
the wall-trap bug via MCP runtime test.

Data layer (Agent A):
- scenes/ai/recipe.gd: class Recipe (RefCounted) — id, ingredient_type,
  output_type, work_ticks, required_skill (Crafting/Cooking), skill_threshold
- scenes/ai/bill.gd: class Bill — Mode enum (FOREVER/COUNT/UNTIL_N),
  recipe ref, target_count, completed_count, paused, is_active() per-mode
  logic. UNTIL_N walks World.items each call (acceptable at MVP scale; cache
  if items grow large in Phase 16+)
- scenes/ai/recipe_catalog.gd: RecipeCatalog.plank() / .stone_block() — 2
  starter recipes; Phase 7+ expands toward the design.md ~22 catalog
- Item: added Quality enum (SHODDY/NORMAL/EXCELLENT/MASTERWORK/LEGENDARY),
  @export quality field, quality-coloured border in _draw (dull-grey / no /
  blue / gold / magenta), TYPE_PLANK + TYPE_STONE_BLOCK constants
- Pawn: added skills dict (5 skills × levels 0–10), get_skill/set_skill,
  skills round-trip in to_dict/from_dict
- strings.gd: item.plank, item.stone_block, quality.* (5 keys)

Workbench entity (Agent B, scenes/entities/workbench.{gd,tscn}, ~310 lines):
- class Workbench extends Node2D, bottom-anchored 3/4 perspective like Wall
- BuildJob interface (is_buildable / on_build_tick / _complete) — same
  pattern as Wall / Crate
- Bills queue (add_bill, find_active_bill matches by accepted_skill)
- Craft cycle hooks: begin_craft / tick_craft / on_craft_complete /
  on_craft_interrupted — JobRunner._tick_craft delegates to these
- Procedural _draw differentiates Carpenter (brown bench + vise) vs
  Smelter (dark stone + orange ember glow) via the @export label_text
  field — no subclass needed for Phase 6
- World autoload: workbenches registry + register_workbench/unregister_workbench

Crafting AI (Agent C):
- Toil.KIND_CRAFT + Toil.craft_at(workbench_path, bill_index) factory
- JobRunner._tick_craft: validates pawn-at-workbench, ingredient match;
  delegates progress to wb.tick_craft; on complete spawns output Item
  with QualityCalc.roll() applied; records bill completion
- crafting_provider.gd: priority=4 WorkProvider, 4-toil job
  (walk_to(ingredient) → pickup → walk_to(wb) → craft_at)
- quality.gd: QualityCalc.roll(skill) — additive formula
  skill × 0.04 + RNG(0, 0.6) with bucket thresholds matching
  architecture.md spec. Skill 0 caps at Excellent; Skill 10 reaches
  Legendary ~8% of the time

Opus integration:
- world.tscn: CraftingProvider node added
- world.gd: registered crafting_provider with World (priority order:
  construction=6 > chop=5 > mine=4 > crafting=4 > haul=3 > rest=0)
- Pawn spawn data extended with crafting skill (Bram=8, Cora=4, Edda=0)
  for visible quality variation in the demo
- _seed_phase5_demo_buildings extended: pre-built Carpenter at (46, 25)
  with plank bill (FOREVER) + Smelter at (48, 25) with stone_block bill
  (UNTIL_N=5)

The wall-trap bug (caught via MCP runtime — initial Phase 6 run hung):
- Pawns building walls stood ON the wall tile. When wall._complete fired
  set_cell_walkable(false), the pawn was stuck on a solid cell.
  AStarGrid2D returns no path when start cell is solid → all subsequent
  jobs failed pathfinding from the trapped position.
- Fix: ConstructionProvider checks site.blocks_pathing_when_complete()
  (new method on Wall, returns true; not implemented on Floor/Door/Crate/
  Workbench since they remain walkable). Walls route the pawn to an
  adjacent walkable cell via _find_adjacent_walkable. Floors/doors/etc.
  build on-tile as before.
- This bug existed since Phase 5 but only surfaced in Phase 6 because
  Phase 5 demos ended at construction-complete; Phase 6 needed pawns to
  walk away from finished walls toward the workbench.

Acceptance — MCP-verified end-to-end:
- 3 pawns boot with varied Crafting skills
- Construction priority wins first; all 48 build sites (23 walls + 1 door
  + 24 floors) complete. Pawns escape wall tiles safely (fix verified).
- Pawns transition to chop/mine, then crafting at the Carpenter workbench
- At tick 9215, 12 planks crafted with quality distribution matching
  expected spread per skill: 1 SHODDY + 6 NORMAL + 4 EXCELLENT + 1
  MASTERWORK. Quality-coloured borders visible on items.
- Smelter UNTIL_N=5 bill correctly idle (no stone consumed yet) because
  CraftingProvider prefers closer workbench-ingredient pairs and the
  carpenter+wood is closer to where pawns end up than smelter+stone

Phase 6 followups for later phases:
- on_craft_interrupted has no JobRunner hook — Phase 9 status interrupts
  will need a 'cancel callback' on toils or wb.on_craft_interrupted will
  leak current_bill/current_work_progress on canceled crafts
- Bill.from_dict reconstructs Recipe inline via Recipe.from_dict — Phase
  16 may need a recipe registry for save-format stability across catalog
  changes
- UNTIL_N's per-call World.items walk is O(items) — acceptable at MVP
  scale; profile if it becomes hot

Delegation report this phase:
- Agent A: Recipe + Bill + RecipeCatalog + Item.quality + Pawn.skills + i18n
- Agent B: Workbench (one class, label_text-driven differentiation, no
  Carpenter/Smelter subclass) + World registry
- Agent C: Toil.KIND_CRAFT + JobRunner._tick_craft + CraftingProvider +
  QualityCalc
- Opus: scene wiring + pawn-skill init + workbench demo seed + wall-trap
  fix (caught via MCP) + runtime verification

~75% of Phase 6 GDScript was subagent-authored.

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

scenes/pawn/pawn.gd

@@ -26,6 +26,19 @@ class_name Pawn
 const STEP_TICKS: int = 10
 const TILE_SIZE_PX: int = 16  # Mirrors World.TILE_SIZE_PX; standalone so Pawn needs no World reference.
 
+# ── skill definitions (docs/design.md "Skills") ──────────────────────────────
+# Five skills, levels 0–10. Level by use; multiplicative speed/quality bonus.
+# Skills modify duration and quality, never permission (design.md:35).
+const SKILL_MANUAL_LABOR: StringName = &"manual_labor"
+const SKILL_CRAFTING:     StringName = &"crafting"
+const SKILL_COOKING:      StringName = &"cooking"
+const SKILL_MEDICINE:     StringName = &"medicine"
+const SKILL_COMBAT:       StringName = &"combat"
+
+const ALL_SKILLS: Array[StringName] = [
+	SKILL_MANUAL_LABOR, SKILL_CRAFTING, SKILL_COOKING, SKILL_MEDICINE, SKILL_COMBAT,
+]
+
 signal walk_started
 signal walk_completed
 signal arrived_at_destination(tile: Vector2i)
@@ -47,6 +60,11 @@ var job_runner = null
 # one type at a time per design.md.
 var carried_item = null
 
+# Phase 6 — skill levels. Initialized to 0 for all five skills in _ready().
+# Use get_skill() / set_skill() to access; direct dict mutation is allowed
+# for batch operations (e.g. from_dict restoring saved data).
+var skills: Dictionary = {}
+
 var _path: Array[Vector2i] = []
 var _step_progress: float = 0.0
 var _selected: bool = false
@@ -58,6 +76,11 @@ var _selected: bool = false
 func _ready() -> void:
 	EventBus.sim_tick.connect(_on_sim_tick)
 	_state_label.text = Strings.t(&"pawn.state.idle")
+	# Initialise all five skills to 0 if not already set (from_dict sets them
+	# before _ready() fires in some load paths — only fill missing keys here).
+	for skill in ALL_SKILLS:
+		if not skills.has(skill):
+			skills[skill] = 0
 
 
 func setup(p_name: String, start_tile: Vector2i) -> void:
@@ -99,12 +122,29 @@ func is_selected() -> bool:
 	return _selected
 
 
+## Returns the pawn's current level (0–10) for the given skill.
+## Returns 0 for unknown skills so callers need no nil-guard.
+func get_skill(skill: StringName) -> int:
+	return int(skills.get(skill, 0))
+
+
+## Sets skill to level, clamped to [0, 10]. Asserts the key is a known skill.
+func set_skill(skill: StringName, level: int) -> void:
+	assert(skill in ALL_SKILLS, "set_skill: unknown skill '%s'" % skill)
+	skills[skill] = clampi(level, 0, 10)
+
+
 # ── save / load ─────────────────────────────────────────────────────────────
 
 func to_dict() -> Dictionary:
 	var path_data: Array = []
 	for v in _path:
 		path_data.append([v.x, v.y])
+	# Serialise skills as {"manual_labor": 0, "crafting": 3, ...} — StringName
+	# keys must be stored as plain Strings for JSON round-trip safety.
+	var skills_data: Dictionary = {}
+	for skill in ALL_SKILLS:
+		skills_data[String(skill)] = get_skill(skill)
 	return {
 		"name": pawn_name,
 		"tile_x": tile.x,
@@ -114,6 +154,7 @@ func to_dict() -> Dictionary:
 		"selected": _selected,
 		"forced_job": forced_job.to_dict() if forced_job != null else null,
 		"job_runner": job_runner.to_dict() if job_runner != null else null,
+		"skills": skills_data,
 	}
 
 
@@ -135,6 +176,15 @@ func from_dict(d: Dictionary) -> void:
 	if jr_dict is Dictionary and job_runner != null:
 		job_runner.from_dict(jr_dict)
 
+	# Restore skills — set directly on the dict to bypass the ALL_SKILLS assert
+	# (from_dict must be resilient to saves that pre-date a new skill being added).
+	var saved_skills: Variant = d.get("skills")
+	if saved_skills is Dictionary:
+		for raw_key in saved_skills.keys():
+			var skill := StringName(raw_key)
+			if skill in ALL_SKILLS:
+				skills[skill] = clampi(int(saved_skills[raw_key]), 0, 10)
+
 	_name_label.text = pawn_name
 	_state_label.text = Strings.t(&"pawn.state.walking") if is_walking() else Strings.t(&"pawn.state.idle")
 	position = _tile_to_world(tile)