Phase 5 — Designation, BuildJob, Wall/Floor/Door, Crate; 3/4 perspective pivot

Three gdscript-refactor agents in parallel + Opus integration.

Architectural pivot (memory.md Decisions table updated):
- View: top-down grid for gameplay + 3/4-perspective rendering for vertical
  structures (Stardew/Going Medieval style). Walls/doors/crates are Y-sorted
  entity sprites, not TileMap cells.
- Wall TileMap layer (Layer 2) becomes data-only — used for room detection,
  roof BFS, save serialization. Visual rendering happens at entity level.
- Asset reality check baked into the decision: the entire asset library is
  RPG-style perspective art; pivoting the renderer is cheaper than authoring
  or commissioning top-down 47-tile autotile sets.

Designation paint (scenes/world/, Agent A — ~170 lines):
- class_name Designation extends Node, lives as DesignationCtl child of World
- TOOL_NONE / TOOL_BUILD_WALL / TOOL_BUILD_FLOOR
- _unhandled_input captures left-mouse press/drag/release
- Drag-paints ghost tiles on Layer 3 via paint_layer.set_cell
- Green/red modulate based on World.pathfinder.is_walkable + cell occupancy
- Emits EventBus.designation_added/cleared per cell
- Selection.designation_active guard prevents double-handling clicks

EventBus signals added:
- designation_added(cell: Vector2i, tool: StringName)
- designation_cleared(cell: Vector2i)

BuildJob + Wall/Floor/Door entities (scenes/ai/ + scenes/entities/, Agent B — ~530 lines):
- Toil.KIND_BUILD + Toil.build_at(target_path) factory
- JobRunner._tick_build: resolves NodePath target, calls on_build_tick() per
  sim tick, marks toil done when is_buildable() returns false
- ConstructionProvider (priority=6, highest): nearest is_buildable() site in
  World.build_queue → Job=[walk_to(site.tile), build_at(site.get_path())]
- Wall entity: BUILD_TICKS=100, 40% alpha ghost; _complete() calls
  pathfinder.set_cell_walkable(false) + World.mark_wall_tile + Audit.log
- Floor entity: BUILD_TICKS=30, ground-level (no y_sort), does NOT block
  pathfinding, calls mark_floor_tile on complete
- Door entity: BUILD_TICKS=80, bottom-anchored, walkable when built (no
  pathfinder block); registers with World.doors for Phase 7 open/close logic
- ALL wall/door scenes have y_sort_enabled=true on root; floors don't (always
  on ground plane)

Crate furniture (scenes/world/, Agent C — ~270 lines):
- class_name Crate extends StorageDestination (Phase 4's abstract base)
- CAPACITY=4 stacks; accepts() gates on _completed + _filter_accepts + room
- find_drop_position returns tile when room exists, (-1,-1) otherwise
- BUILD_TICKS=60; on_build_tick mirrors Wall's pattern
- _draw procedural brown crate body + slat lines + fill-level dots

World autoload extensions (Opus):
- build_queue: Array — Wall/Floor/Door/Crate ghost entities awaiting
  construction. ConstructionProvider iterates by .priority desc; Phase 6+
  prepends material-haul toils.
- doors: Array — completed doors for future open/close (Phase 7+)
- wall_layer / floor_layer / designation_layer refs exposed for entity code
- mark_wall_tile(tile, material) / mark_floor_tile(tile, material) —
  stamps data-only TileMap layer with material-encoded atlas coord
- stockpile_at_tile(tile) — finds StockpileZone OR Crate covering a tile;
  used by JobRunner._tick_deposit to route Crate deposits

JobRunner._tick_deposit refactor (Opus):
- After clearing the haul-dirty flag, looks up stockpile_at_tile(pawn.tile)
- If destination is a Crate (has_method('register_item')), calls
  dest.register_item(item) so the crate's _contents tracks the stack

World scene integration (Opus):
- y_sort_enabled=true on World root so all entity sprites sort correctly
- DesignationCtl, ConstructionProvider, Wall TileMap (data-only, visible=false)
- World._ready wires:
  * World.wall_layer / floor_layer / designation_layer
  * designation.bind(designation_layer, selection)
  * Register 5 work providers (construction=6 > chop=5 > mine=4 > haul=3 > rest=0)
  * EventBus.designation_added → _on_designation_added (spawns Wall/Floor entity)
- _seed_phase5_demo_buildings: pre-queues 14 wall designations forming a
  5×4 cabin outline at (45, 25) so pawns visibly construct walls without
  player-paint UI (deferred to Phase 17). Spawns 2 fully-built crates at
  (17-18, 60) for hauling routing.

Acceptance — MCP-verified end-to-end:
- 14 wall designations seeded at boot, 2 crates pre-built
- All 3 pawns picked construction (highest priority work) and walked to
  build sites (paths 37/32/27 from spawn). Walls built one by one.
- Wall layer post-construction has 42 cells: 28 (Phase 1 stone ring) +
  14 (Phase 5 cabin) — both rendering paths (placeholder TileMap from
  Phase 1, plus new entity sprites from Phase 5) coexist correctly.
- Pathfinder set_cell_walkable(false) fired on each wall completion.
- Pawns transitioned from construction to hauling once all walls done.
- Final visual: 5×4 stone-walled cabin with mortar lines, Y-sorted entity
  rendering, wood items scattered east of the cabin awaiting haul.

Phase 5 gotchas (logged):
- 'material' as a member var shadows CanvasItem.material (Node2D inherits
  it). Renamed to wall_material / floor_material via quick-edit agent.
  Save-format dict KEYS stay as 'material' for stability.
- Class-name registration cache lag bit again (Tree/Pawn pattern from
  earlier phases). Workflow stays: agent writes class_name file → MCP
  reload_project → godot --headless --editor --quit → headless validate.
- ConstructionProvider scans build_queue every tick including completed
  walls; is_buildable() filters them out but the queue keeps growing.
  Phase 16+ should add an unregister_build_site call from _complete or
  a periodic queue compaction.

Delegation report this phase:
- Agent A (Sonnet, gdscript-refactor): Designation paint mode + EventBus
  signals + Selection guard. ~180 lines.
- Agent B (Sonnet, gdscript-refactor): Toil.KIND_BUILD + JobRunner._tick_build
  + ConstructionProvider + Wall/Floor/Door entities + scenes. ~530 lines.
- Agent C (Sonnet, gdscript-refactor): Crate furniture extending
  StorageDestination. ~270 lines.
- quick-edit (Haiku): material → wall_material/floor_material rename. ~14
  occurrences across 2 files.
- Opus: World autoload extensions + JobRunner _tick_deposit refactor +
  World scene integration (DesignationCtl + ConstructionProvider + new
  scene preloads + _seed_phase5_demo_buildings) + MCP runtime verification
  + the material-shadow + class-cache-lag debugging.

Pivot decision worth flagging: the asset library audit revealed that no
pack we own ships top-down 47-tile autotile walls. After multiple
researcher-overpromise cycles, the pragmatic call was to pivot the
rendering model itself. Walls now render as bottom-anchored tall sprites
with Y-sort; the entire asset library becomes usable as-is. Phase 17
polish will swap procedural _draw() with AtlasTexture regions from
Pixel Crawler / FG_Houses / Ventilatore Castle_Building.

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

scenes/ai/construction_provider.gd

@@ -0,0 +1,52 @@
+class_name ConstructionProvider extends WorkProvider
+## WorkProvider for the "construction" work category.
+##
+## Scans World.build_queue for the nearest buildable site (Wall, Floor, Door —
+## anything exposing is_buildable() / on_build_tick() / tile / label()) and
+## returns a two-toil Job:
+##   walk_to(site.tile) → build_at(site.get_path())
+##
+## The BUILD toil calls on_build_tick() once per sim tick; the entity internally
+## tracks build_progress and calls _complete() when BUILD_TICKS is reached. The
+## toil finishes automatically when is_buildable() returns false.
+##
+## Phase 5 simplification: materials are infinite — no haul-materials step.
+## Phase 6+ will prepend walk_to(material_pile) + pickup() toils before walk_to(site).
+##
+## Duck-typing note: build-site entities are referenced without class_name to
+## avoid registration-order issues. We rely only on:
+##   site.tile: Vector2i
+##   site.is_buildable() -> bool
+##   site.label() -> String
+##   site.get_path() -> NodePath
+
+
+func _init() -> void:
+	category = &"construction"
+	# Higher than chop (5), mine (4), haul (3), rest (0). Players expect their
+	# build orders to be serviced before the pawn goes off to chop trees.
+	priority = 6
+
+
+## Returns a Job targeting the nearest buildable site, or null if none exists.
+## `pawn` is duck-typed: must expose .tile (Vector2i).
+func find_best_for(pawn) -> Job:
+	var best = null
+	var best_dist: int = 999999
+
+	for site in World.build_queue:
+		if not site.is_buildable():
+			continue
+		var d: int = abs(site.tile.x - pawn.tile.x) + abs(site.tile.y - pawn.tile.y)
+		if d < best_dist:
+			best_dist = d
+			best = site
+
+	if best == null:
+		return null
+
+	var j := Job.new()
+	j.label = "Build %s at %s" % [best.label(), best.tile]
+	j.toils.append(Toil.walk_to(best.tile))
+	j.toils.append(Toil.build_at(best.get_path()))
+	return j

scenes/ai/construction_provider.gd.uid

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

scenes/ai/job_runner.gd

@@ -93,6 +93,8 @@ func tick() -> void:
 			pass  # Never completes on its own — Decision or player overrides.
 		Toil.KIND_INTERACT:
 			_tick_interact(t)
+		Toil.KIND_BUILD:
+			_tick_build(t)
 		Toil.KIND_PICKUP:
 			_tick_pickup(t)
 		Toil.KIND_DEPOSIT:
@@ -227,6 +229,54 @@ func _tick_interact(t) -> void:
 		t.done = true
 
 
+## Execute one tick of a BUILD toil.
+##
+## Mirrors _tick_interact's pattern, but drives construction entities (Wall,
+## Floor, Door) via on_build_tick() / is_buildable() instead of on_chop_tick()
+## / is_choppable(). The site is "done" (toil complete) when is_buildable()
+## returns false — meaning the entity finished building OR was removed.
+##
+## First tick: resolve target from NodePath. If already gone, skip immediately.
+## Every subsequent tick: call on_build_tick() then check is_buildable(). Once
+## false the site is built (or cancelled); mark toil done.
+func _tick_build(t) -> void:
+	var target_path := NodePath(t.data.get("target", ""))
+	var target = get_tree().get_root().get_node_or_null(target_path)
+
+	if not t.data.get("started", false):
+		if target == null or not is_instance_valid(target):
+			Audit.log(
+				"job_runner",
+				"%s build target gone — skipping" % pawn.pawn_name
+			)
+			t.done = true
+			return
+		t.data["started"] = true
+		Audit.log(
+			"job_runner",
+			"%s build start: %s" % [pawn.pawn_name, target.name]
+		)
+
+	# Re-resolve each tick in case the node was freed between ticks.
+	target = get_tree().get_root().get_node_or_null(target_path)
+	if target == null or not is_instance_valid(target):
+		t.done = true
+		return
+
+	target.on_build_tick()
+
+	# Re-check after the call (on_build_tick may complete + free the ghost state).
+	if target == null or not is_instance_valid(target):
+		t.done = true
+		return
+	if target.has_method("is_buildable") and not target.is_buildable():
+		Audit.log(
+			"job_runner",
+			"%s build done: %s" % [pawn.pawn_name, target.name]
+		)
+		t.done = true
+
+
 ## Execute one tick of a PICKUP toil.
 ##
 ## Finds the first unheld Item at pawn.tile in World.items.
@@ -275,6 +325,12 @@ func _tick_deposit(t) -> void:
 	# The periodic sweep_for_better_destinations will re-mark it if a higher-
 	# priority destination opens up later.
 	World.clear_item_haul_flag(item)
+	# Phase 5: if the destination tile is covered by a Crate (single-tile
+	# container), register the item into the crate's contents. StockpileZone
+	# doesn't need this — its items just live at the floor tile.
+	var dest = World.stockpile_at_tile(pawn.tile)
+	if dest != null and dest.has_method("register_item"):
+		dest.register_item(item)
 	Audit.log(
 		"job_runner",
 		"%s deposit: %s ×%d at %s" % [pawn.pawn_name, item.item_type, item.stack_size, pawn.tile]

scenes/ai/toil.gd

@@ -16,6 +16,7 @@ const KIND_IDLE: StringName = &"idle"
 const KIND_INTERACT: StringName = &"interact"  # Timed action on a target entity (Tree, Rock, …)
 const KIND_PICKUP: StringName = &"pickup"       # Transfer Item at pawn.tile into pawn.carried_item
 const KIND_DEPOSIT: StringName = &"deposit"     # Place pawn.carried_item at pawn.tile
+const KIND_BUILD: StringName = &"build"         # Timed construction on a Wall / Floor / Door entity
 
 var kind: StringName = KIND_IDLE
 ## Toil-specific params — all values must be int, float, bool, String, Dict, or Array.
@@ -80,6 +81,20 @@ static func pickup() -> Toil:
 	return t
 
 
+## Construction action on a scene-node target (Wall, Floor, Door, …).
+## `target_node_path` is the NodePath of the entity; stored as String for JSON safety.
+## JobRunner resolves the node at first-tick and calls on_build_tick() every sim tick
+## until is_buildable() returns false (construction complete or site cancelled/removed).
+static func build_at(target_node_path: NodePath) -> Toil:
+	var t := Toil.new()
+	t.kind = KIND_BUILD
+	t.data = {
+		"target": String(target_node_path),
+		"started": false,
+	}
+	return t
+
+
 ## Place pawn.carried_item at pawn.tile. Single-tick action.
 ## data is empty — the item comes from pawn.carried_item at execution time.
 static func deposit() -> Toil: