Phase 4 — Trees, Rocks, Items, Stockpiles, Hauling

Three gdscript-refactor agents in parallel + Opus integration.

Entities (scenes/entities/, Agent A — 3 scripts + 3 .tscn, ~460 lines):
- item.gd: 16-type StringName registry (matches design.md filter chips);
  Node2D + _draw() colored square + stack-count badge; to_dict/from_dict
- tree.gd: class_name HarvestableTree (Godot 4 ships a built-in 'Tree'
  Control class — renamed to avoid the shadow); CHOP_TICKS=80; on_chop_tick
  advances progress, fells when complete, drops 3 wood items at tile +
  walkable neighbours
- rock.gd: MINE_TICKS=120; angular polygon _draw; mined() drops 1 stone

Toil + provider extensions (scenes/ai/, Agent B — 4 files modified/added,
~250 lines):
- Toil: new KIND_INTERACT (timed entity action), KIND_PICKUP, KIND_DEPOSIT
- JobRunner: _tick_interact resolves NodePath, calls target.<method>()
  each tick, marks done when is_choppable/is_mineable returns false;
  _tick_pickup finds Item at pawn.tile, transfers to pawn.carried_item;
  _tick_deposit places carried_item at pawn.tile + clears the
  items_needing_haul dirty flag
- ChopProvider (priority=5): nearest choppable tree; Job=[walk_to + interact]
- MineProvider (priority=4): same for rocks

Hauling system (scenes/world/ + scenes/ai/, Agent C — 4 files, ~330 lines):
- StorageDestination: abstract Node2D base; Priority enum CRITICAL=0..OFF=4;
  accepted_types (empty=wildcard); _filter_accepts() helper
- StockpileZone: concrete rect-region zone; _draw paints priority-tinted
  overlay (z_index=-1); find_drop_position scans for free cells respecting
  one-stack-per-tile rule
- HaulingProvider (priority=3): nearest dirty item × best destination →
  4-toil job [walk → pickup → walk → deposit]; sweep_for_better_destinations
  enables the priority cascade (items in lower-priority zones re-mark dirty
  when a higher-priority destination opens up)

Opus integration (~200 lines):
- World autoload: trees/rocks/items/items_needing_haul/stockpiles registries
  + register/unregister methods; pathfinder reference exposed for entity
  code (tree.fell needs is_walkable for neighbour drops)
- Pawn: carried_item slot + carry-indicator (small colored rect upper-right
  of body) via queue_redraw in _on_sim_tick
- World scene: registers chop/mine/haul/rest providers; spawns 6 trees
  (cluster east-north), 4 rocks (south-east), 2 stockpile zones (Zone A
  wood-only NORMAL, Zone B wildcard HIGH); periodic
  hauling_provider.sweep_for_better_destinations every 100 sim ticks

Acceptance — MCP-verified end-to-end (the full Phase 4 loop):
- 3 pawns boot, Decision picks chop (highest priority work), all walk to
  nearest tree, chop in parallel (3× speed because all 3 call on_chop_tick
  per tick). Trees fell, drop wood (18 items). Pawns move to rocks, mine,
  drop stone (4 items). Total 22 items spawn.
- HaulingProvider routes wood + stone toward Zone B (wildcard HIGH > Zone
  A's wood-only NORMAL). Pawns carry items one at a time, visual indicator
  shows during transit. Items deposit, items_needing_haul dirty flag
  clears.
- **Priority cascade test:** Zone A promoted from NORMAL to CRITICAL.
  Manually-triggered sweep marks 3 wood items in Zone B for re-haul.
  Within a few thousand ticks: Zone A has 5 wood (cascaded from Zone B),
  Zone B has 4 stone only (wood left, stone stayed because Zone A rejects
  stone). Filter + priority cascade working exactly per design.md spec.

Phase 4 gotchas (logged in implementation.md):
- 'Tree' shadows Godot 4's built-in Tree Control class — class_name had to
  be renamed to HarvestableTree. Scene/file names stayed as 'tree' since
  the game concept is still 'tree'; the rename only affects code-side
  type references.
- draw_colored_polygon(points, color) takes a SINGLE Color, not a
  PackedColorArray. Agent C had to be reminded; draw_polygon(points, colors)
  is the variant that takes per-vertex colors.
- Godot's class-name cache lags behind file changes — a full editor scan
  ('godot --headless --editor --quit') is needed to flush. Even after
  reload_project, type-annotation assignments can fail; duck-typed
  variables ('var x = scene.instantiate()') sidestep the issue.
- JobRunner's _tick_deposit had to explicitly call
  World.clear_item_haul_flag — the dirty set persisted otherwise and
  items appeared 'needing haul' even after deposit.

Delegation report this phase:
- Agent A (Sonnet, gdscript-refactor): Tree + Rock + Item entities + i18n
  keys. ~460 lines.
- Agent B (Sonnet, gdscript-refactor): Toil extensions + JobRunner handlers
  + ChopProvider + MineProvider. ~250 lines.
- Agent C (Sonnet, gdscript-refactor): StorageDestination + StockpileZone
  + HaulingProvider with cascade sweep. ~330 lines.
- Opus: World autoload extensions (entity registries + pathfinder ref),
  Pawn carry slot + visual, world.tscn/gd wiring, the Tree rename, the
  draw_colored_polygon fix, the dirty-set-clear fix, MCP-driven runtime
  verification including the full chop-mine-haul loop and the priority
  cascade demo.

~75% of Phase 4's GDScript was subagent-authored.

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

scenes/world/storage_destination.gd

@@ -0,0 +1,73 @@
+class_name StorageDestination extends Node2D
+## Abstract base for all item-storage destinations (floor stockpile zones,
+## containers, etc.). Hauling AI treats all subclasses as a unified candidate
+## pool via this interface.
+##
+## StorageDestination extends Node2D (not Node) so subclasses can implement
+## _draw() for priority-tinted overlays without a separate CanvasItem child.
+##
+## Subclasses MUST override: accepts(), find_drop_position(), covers_tile().
+## Subclasses SHOULD call World.register_stockpile(self) in _ready() and
+## World.unregister_stockpile(self) in _exit_tree().
+##
+## See docs/architecture.md "Storage destinations: a unified concept".
+
+## Five priority levels matching Rimworld semantics (design.md Priorities).
+## Lower enum int = higher priority (CRITICAL = 0 pulls before LOW = 4).
+## Priority.OFF = no hauling in or out; invisible to HaulingProvider.
+enum Priority {
+	CRITICAL = 0,
+	HIGH     = 1,
+	NORMAL   = 2,
+	LOW      = 3,
+	OFF      = 4,
+}
+
+## Priority determines whether haulers will fill this destination and whether
+## items here will be re-hauled upward to a higher-priority destination.
+@export var priority: Priority = Priority.NORMAL
+
+## Item types this destination accepts. Empty array = wildcard (accepts all).
+## Each entry is a StringName matching Item.TYPE_* constants (e.g. &"wood").
+@export var accepted_types: Array[StringName] = []
+
+## Emitted when items are registered or unregistered with this destination,
+## so interested parties (UI, re-scan logic) can react without polling.
+signal contents_changed
+
+
+# ── abstract interface — subclasses must override ────────────────────────────
+
+## Returns true if this destination currently accepts `item` (filter + priority
+## check + any capacity logic owned by the subclass).
+func accepts(item) -> bool:
+	push_error("StorageDestination.accepts: '%s' must override this method" % name)
+	return false
+
+
+## Returns a tile coordinate inside this destination where `item` can be
+## placed (filter-pass AND the tile is not already occupied by another item).
+## Returns Vector2i(-1, -1) when no slot is available.
+func find_drop_position(item) -> Vector2i:
+	push_error("StorageDestination.find_drop_position: '%s' must override this method" % name)
+	return Vector2i(-1, -1)
+
+
+## Returns true if `tile` falls inside this destination's region.
+## Used by HaulingProvider to find which destination currently holds an item.
+func covers_tile(tile: Vector2i) -> bool:
+	push_error("StorageDestination.covers_tile: '%s' must override this method" % name)
+	return false
+
+
+# ── shared helper ────────────────────────────────────────────────────────────
+
+## Priority-and-filter gate, shared by all subclasses.
+## Returns false when OFF or when the item's type is not in accepted_types.
+## accepted_types.is_empty() is the wildcard "accept any type" case.
+func _filter_accepts(item) -> bool:
+	if priority == Priority.OFF:
+		return false
+	if accepted_types.is_empty():
+		return true
+	return item.item_type in accepted_types