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/entities/item.gd

@@ -33,17 +33,27 @@ const TYPE_WEAPON: StringName     = &"weapon"       # Wp
 const TYPE_ARMOR: StringName      = &"armor"        # Ar
 const TYPE_CORPSE: StringName     = &"corpse"       # Co
 
+# Phase 6 — intermediate crafted goods (carpenter bench + smelter outputs).
+const TYPE_PLANK: StringName      = &"plank"
+const TYPE_STONE_BLOCK: StringName = &"stone_block"
+
 const ALL_TYPES: Array[StringName] = [
 	TYPE_WOOD, TYPE_STONE, TYPE_IRON_ORE, TYPE_COPPER_ORE,
 	TYPE_SILVER, TYPE_GOLD, TYPE_CLOTH, TYPE_VEGETABLE,
 	TYPE_MEAT, TYPE_GRAIN, TYPE_MEAL, TYPE_MEDICINE,
 	TYPE_TOOL, TYPE_WEAPON, TYPE_ARMOR, TYPE_CORPSE,
+	TYPE_PLANK, TYPE_STONE_BLOCK,
 ]
 
+# ── quality system (docs/architecture.md "Quality system") ───────────────────
+# Rolled at craft-completion; stored per item; drives border colour in _draw().
+enum Quality { SHODDY, NORMAL, EXCELLENT, MASTERWORK, LEGENDARY }
+
 # ── state ────────────────────────────────────────────────────────────────────
 
 @export var item_type: StringName = TYPE_WOOD
 @export var stack_size: int = 1
+@export var quality: Quality = Quality.NORMAL
 
 var tile: Vector2i = Vector2i.ZERO
 
@@ -92,6 +102,7 @@ func to_dict() -> Dictionary:
 		"stack_size": stack_size,
 		"tile_x": tile.x,
 		"tile_y": tile.y,
+		"quality": int(quality),
 	}
 
 
@@ -104,6 +115,7 @@ static func from_dict(d: Dictionary) -> Dictionary:
 		"stack_size": int(d.get("stack_size", 1)),
 		"tile_x": int(d.get("tile_x", 0)),
 		"tile_y": int(d.get("tile_y", 0)),
+		"quality": int(d.get("quality", Quality.NORMAL)),
 	}
 
 
@@ -119,6 +131,20 @@ func _draw() -> void:
 	draw_rect(square, fill)
 	draw_rect(square, Color(0.0, 0.0, 0.0, 0.75), false, 1.0)
 
+	# Quality border — drawn over the dark outline, colour per quality tier.
+	# NORMAL has no extra border (base outline is sufficient).
+	match quality:
+		Quality.SHODDY:
+			draw_rect(square, Color(0.40, 0.40, 0.40), false, 1.0)
+		Quality.EXCELLENT:
+			draw_rect(square, Color(0.20, 0.55, 0.95), false, 1.0)
+		Quality.MASTERWORK:
+			draw_rect(square, Color(0.85, 0.55, 0.10), false, 1.0)
+		Quality.LEGENDARY:
+			draw_rect(square, Color(0.85, 0.10, 0.80), false, 2.0)
+		_:
+			pass  # NORMAL — no extra border
+
 	# Stack count badge — bottom-right corner of the square, font_size 7.
 	if stack_size > 1:
 		var label := Strings.t(&"item.stack_count").format({"n": stack_size})

scenes/entities/wall.gd

@@ -71,6 +71,14 @@ func is_buildable() -> bool:
 	return not _completed
 
 
+## Construction-provider hint: walls become impassable when built, so pawns
+## must stand on an adjacent tile while building. Phase 6 fix for the
+## "pawn-trapped-on-wall" bug. Floors / Doors / Crates / Workbenches don't
+## need this since they remain walkable after completion.
+func blocks_pathing_when_complete() -> bool:
+	return true
+
+
 ## Human-readable label for job descriptions and Audit logs.
 func label() -> String:
 	return "%s wall" % wall_material

scenes/entities/workbench.gd

@@ -0,0 +1,302 @@
+class_name Workbench extends Node2D
+## Workbench entity — buildable structure where pawns craft items per bills.
+##
+## Rendered as a bottom-anchored sprite (Y-sorted) matching the 3/4-perspective
+## convention from Wall/Door. Ghost state (40% alpha) while construction is
+## in progress; solid once _completed.
+##
+## Variant appearance is driven by label_text:
+##   "Carpenter" → warm-brown wood bench with a vise detail
+##   "Smelter"   → dark grey stone block with an orange ember glow
+##   Other       → generic warm-grey fallback
+##
+## Bill model (architecture.md "Production: workbenches, recipes, bills"):
+##   bills[]            — ordered queue of Bill objects (untyped; Bill class
+##                        is authored by a sibling agent and may not be
+##                        registered when this file compiles).
+##   current_bill       — the Bill actively being worked; null when idle.
+##   current_work_progress — tick counter within the current craft cycle.
+##                        JobRunner._tick_craft increments this each sim tick.
+##                        Workbench resets it to 0 on cycle completion or
+##                        when the pawn leaves mid-craft.
+##
+## Save/load: to_dict / from_dict capture all persistent fields, including
+## each bill via bill.to_dict(). Mirrors the Crate save pattern.
+##
+## World registration: World.register_workbench / World.unregister_workbench
+## are called from _ready / _exit_tree.
+
+const TILE_SIZE_PX: int = 16
+
+## Sim ticks to build a workbench (90 ticks ≈ 4.5 sim seconds at 1×).
+const BUILD_TICKS: int = 90
+
+# ── exports ───────────────────────────────────────────────────────────────────
+
+## Tile position of this workbench in world-tile coordinates.
+@export var tile: Vector2i = Vector2i.ZERO
+
+## Player-visible label. Also drives the _draw() variant.
+## Recognised values: "Carpenter", "Smelter". Others render generic.
+@export var label_text: String = "Workbench"
+
+## Which skill category this bench accepts.
+## CraftingProvider filters by this before assigning a pawn.
+@export var accepted_skill: StringName = &"crafting"
+
+# ── state ─────────────────────────────────────────────────────────────────────
+
+## Ticks of construction work applied so far. 0..BUILD_TICKS.
+var build_progress: int = 0
+
+## True once build_progress >= BUILD_TICKS.
+var _completed: bool = false
+
+## Ordered queue of Bill objects. Untyped so this file compiles before the
+## Bill class is registered by the sibling agent. CraftingProvider reads this.
+var bills: Array = []
+
+## The Bill being actively worked right now. null when idle.
+## Set by JobRunner when it begins a craft toil; cleared on completion or
+## when the pawn walks away (job cancelled / interrupted).
+var current_bill = null
+
+## Sim-tick progress within the current craft cycle. Incremented by
+## JobRunner._tick_craft once per sim tick. Reset to 0:
+##   - when a craft completes (on_craft_complete)
+##   - when no pawn is actively crafting (JobRunner cancel / pawn interruption)
+## JobRunner reads this to decide whether the recipe's work_ticks are done.
+var current_work_progress: int = 0
+
+
+# ── lifecycle ─────────────────────────────────────────────────────────────────
+
+func _ready() -> void:
+	# Position is bottom-anchored so Y-sort occludes pawns correctly.
+	position = Vector2(
+		tile.x * TILE_SIZE_PX + TILE_SIZE_PX / 2.0,
+		tile.y * TILE_SIZE_PX + TILE_SIZE_PX
+	)
+	World.register_workbench(self)
+	queue_redraw()
+
+
+func _exit_tree() -> void:
+	World.unregister_workbench(self)
+
+
+## One-shot initialiser. Call after add_child() so _ready() has fired.
+func setup(p_tile: Vector2i) -> void:
+	tile = p_tile
+	position = Vector2(
+		tile.x * TILE_SIZE_PX + TILE_SIZE_PX / 2.0,
+		tile.y * TILE_SIZE_PX + TILE_SIZE_PX
+	)
+	queue_redraw()
+
+
+# ── BuildJob interface ────────────────────────────────────────────────────────
+
+## True while the workbench still needs construction work.
+## JobRunner's BUILD toil checks this to decide when the toil is done.
+func is_buildable() -> bool:
+	return not _completed
+
+
+## Human-readable label for job descriptions and Audit logs.
+func label() -> String:
+	return label_text
+
+
+## Called by the BUILD toil in JobRunner once per sim tick.
+## Advances build_progress; completes the workbench at BUILD_TICKS.
+func on_build_tick() -> void:
+	if _completed:
+		return
+	build_progress += 1
+	queue_redraw()
+	if build_progress >= BUILD_TICKS:
+		_complete()
+
+
+## True once the workbench has been fully built.
+func is_completed() -> bool:
+	return _completed
+
+
+# ── Bills ─────────────────────────────────────────────────────────────────────
+
+## Append a bill to the queue.
+func add_bill(b) -> void:
+	bills.append(b)
+	Audit.log("workbench", "%s: bill added — recipe '%s'" % [label_text, b.recipe.id])
+
+
+## Return the first bill that is active and whose required_skill matches
+## this bench's accepted_skill. Returns null when none qualify.
+## CraftingProvider calls this; JobRunner also calls it when the current_bill
+## becomes inactive (UNTIL_N threshold reached, paused, etc.).
+func find_active_bill():
+	for b in bills:
+		if not b.is_active():
+			continue
+		if b.recipe.required_skill != accepted_skill:
+			continue
+		return b
+	return null
+
+
+# ── Craft-cycle hooks (called by JobRunner) ───────────────────────────────────
+
+## JobRunner calls this when it starts working a bill on this bench.
+## Stores the active bill and resets the tick counter.
+func begin_craft(b) -> void:
+	current_bill = b
+	current_work_progress = 0
+
+
+## JobRunner calls this once per sim tick while a pawn is actively crafting.
+## Returns true when the recipe's work_ticks have been reached (craft done).
+func tick_craft() -> bool:
+	if current_bill == null:
+		return false
+	current_work_progress += 1
+	return current_work_progress >= current_bill.recipe.work_ticks
+
+
+## JobRunner calls this on craft completion before spawning the output item.
+## Records the completion on the bill, resets state.
+func on_craft_complete() -> void:
+	if current_bill != null:
+		current_bill.record_completion()
+	current_bill = null
+	current_work_progress = 0
+
+
+## JobRunner calls this when the craft is interrupted (pawn leaves, cancel, etc.).
+## Resets in-progress state so another pawn can start fresh.
+func on_craft_interrupted() -> void:
+	current_bill = null
+	current_work_progress = 0
+
+
+# ── save / load ───────────────────────────────────────────────────────────────
+
+## Serialise workbench state for World save (wired in Phase 16).
+func to_dict() -> Dictionary:
+	var bills_data: Array = []
+	for b in bills:
+		bills_data.append(b.to_dict())
+	return {
+		"tile_x": tile.x,
+		"tile_y": tile.y,
+		"label_text": label_text,
+		"accepted_skill": String(accepted_skill),
+		"build_progress": build_progress,
+		"completed": _completed,
+		"current_work_progress": current_work_progress,
+		"bills": bills_data,
+	}
+
+
+## Restore from a dict produced by to_dict().
+## Bill objects are reconstructed by the caller using Bill.from_dict() once the
+## Bill class is registered. current_bill is left null — JobRunner reconnects
+## from its own saved state on the next sim tick.
+func from_dict(d: Dictionary) -> void:
+	tile = Vector2i(int(d.get("tile_x", 0)), int(d.get("tile_y", 0)))
+	label_text = str(d.get("label_text", "Workbench"))
+	accepted_skill = StringName(d.get("accepted_skill", "crafting"))
+	build_progress = int(d.get("build_progress", 0))
+	_completed = bool(d.get("completed", false))
+	current_work_progress = int(d.get("current_work_progress", 0))
+	# Bills are re-populated by World.load_workbenches() after Bill class loads.
+	# Raw dicts are kept in the dict; the caller handles reconstruction.
+	setup(tile)
+
+
+# ── render ─────────────────────────────────────────────────────────────────────
+
+func _draw() -> void:
+	# 3/4-perspective bench rendering — fits within the tile (16×16 local box).
+	# Origin (0,0) = tile bottom-centre. Tile spans local Y: -16 to 0.
+	# Two-band look (matches Wall): lit top band + shaded front face.
+	# Ghost (not yet built) draws at 0.4 alpha.
+	var alpha: float = 1.0 if _completed else 0.4
+
+	match label_text:
+		"Carpenter":
+			_draw_carpenter(alpha)
+		"Smelter":
+			_draw_smelter(alpha)
+		_:
+			_draw_generic(alpha)
+
+
+func _draw_carpenter(alpha: float) -> void:
+	# Warm-brown wood bench. Top band lit, front face darker.
+	# Vise/saw detail: a small darker square at the top-right corner of the
+	# front face to suggest a mounted tool.
+	var top_face  := Color(0.62, 0.45, 0.25, alpha)
+	var front_face := Color(0.52, 0.36, 0.18, alpha)
+	var plank     := Color(0.34, 0.22, 0.10, alpha)
+	var vise      := Color(0.28, 0.18, 0.08, alpha)
+	var outline   := Color(0.20, 0.12, 0.04, 0.7 * alpha)
+
+	# Top face — lit strip at upper-third of tile.
+	draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 5.0)), top_face)
+	# Front face — lower body.
+	draw_rect(Rect2(Vector2(-8.0, -11.0), Vector2(16.0, 11.0)), front_face)
+	# Horizontal plank seam across the front face.
+	draw_line(Vector2(-8.0, -6.0), Vector2(8.0, -6.0), plank, 1.0)
+	# Vise detail: 4×4 px darker square at top-right of front face.
+	draw_rect(Rect2(Vector2(3.0, -11.0), Vector2(4.0, 4.0)), vise)
+	# Top/front edge horizon line.
+	draw_line(Vector2(-8.0, -11.0), Vector2(8.0, -11.0), plank, 1.0)
+	# Tile outline.
+	draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 16.0)), outline, false, 1.0)
+
+
+func _draw_smelter(alpha: float) -> void:
+	# Dark grey stone block. Top band slightly lighter.
+	# Ember glow: orange rect centred at the bottom of the front face.
+	var top_face   := Color(0.42, 0.42, 0.40, alpha)
+	var front_face := Color(0.32, 0.32, 0.30, alpha)
+	var mortar     := Color(0.20, 0.20, 0.18, alpha)
+	var ember      := Color(0.95, 0.45, 0.10, alpha)
+	var outline    := Color(0.14, 0.14, 0.12, 0.7 * alpha)
+
+	# Top face.
+	draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 5.0)), top_face)
+	# Front face.
+	draw_rect(Rect2(Vector2(-8.0, -11.0), Vector2(16.0, 11.0)), front_face)
+	# Mortar line.
+	draw_line(Vector2(-8.0, -6.0), Vector2(8.0, -6.0), mortar, 1.0)
+	# Ember glow: 6×3 px orange rect, horizontally centred, at bottom of front face.
+	draw_rect(Rect2(Vector2(-3.0, -3.0), Vector2(6.0, 3.0)), ember)
+	# Top/front edge horizon line.
+	draw_line(Vector2(-8.0, -11.0), Vector2(8.0, -11.0), mortar, 1.0)
+	# Tile outline.
+	draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 16.0)), outline, false, 1.0)
+
+
+func _draw_generic(alpha: float) -> void:
+	# Warm-grey fallback bench. Simple two-band block with a single seam.
+	var top_face   := Color(0.58, 0.55, 0.50, alpha)
+	var front_face := Color(0.42, 0.40, 0.36, alpha)
+	var seam       := Color(0.30, 0.28, 0.25, alpha)
+	var outline    := Color(0.20, 0.18, 0.16, 0.7 * alpha)
+
+	draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 5.0)), top_face)
+	draw_rect(Rect2(Vector2(-8.0, -11.0), Vector2(16.0, 11.0)), front_face)
+	draw_line(Vector2(-8.0, -6.0), Vector2(8.0, -6.0), seam, 1.0)
+	draw_line(Vector2(-8.0, -11.0), Vector2(8.0, -11.0), seam, 1.0)
+	draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 16.0)), outline, false, 1.0)
+
+
+# ── internal ──────────────────────────────────────────────────────────────────
+
+func _complete() -> void:
+	_completed = true
+	queue_redraw()
+	Audit.log("workbench", "%s built at %s" % [label_text, tile])

scenes/entities/workbench.gd.uid

@@ -0,0 +1 @@
+uid://db1qm8sn4i55r

scenes/entities/workbench.tscn

@@ -0,0 +1,8 @@
+[gd_scene load_steps=2 format=3 uid="uid://workbench_entity"]
+
+[ext_resource type="Script" path="res://scenes/entities/workbench.gd" id="1_workbench"]
+
+[node name="Workbench" type="Node2D"]
+y_sort_enabled = true
+z_index = 0
+script = ExtResource("1_workbench")