Phase 8 — Beds, sleep need, thoughts, mood, Sulking soft-break

Three gdscript-refactor agents in parallel; Opus integrated and verified
the sleep+wake cycle via MCP runtime.

Bed entity (Agent A, scenes/entities/bed.{gd,tscn} + world.gd, ~280 lines):
- class Bed extends Node2D — bottom-anchored 3/4 perspective like Wall/Workbench
- BuildJob interface (is_buildable / on_build_tick / _complete) — same pattern
  as Wall / Crate / Workbench. blocks_pathing_when_complete=false (walkable).
- Quality-tinted sheet colours by Item.Quality tier (drab grey → blue →
  gold-brown → regal pink); white pillow + dark frame constant across tiers.
- claim(pawn) / release() / is_available() — atomic occupancy; claim re-checks
  is_available() inside to avoid race conditions during pawn walk-to-bed.
- World.beds registry + register_bed / unregister_bed (mirrors workbench pattern)

Sleep need + SleepProvider + KIND_SLEEP toil (Agent B, ~220 lines):
- Pawn.sleep: float 0..100. SLEEP_DECAY_PER_TICK=0.015 (~6667 ticks / 5.5 min
  at 1× / 1 min at Ultra to fully tire). Slower than hunger.
- is_tired() at <30; is_exhausted() at <5 (Phase 9 status interrupt hook)
- SleepProvider priority=8 (highest — sleep beats eat=7 when both urgent)
- Toil.KIND_SLEEP + Toil.sleep_in_bed(NodePath) factory
- JobRunner._tick_sleep: first-tick bed claim (with race-loss → floor fallback),
  per-tick recovery (bed=0.5/tick, floor=0.25/tick), wake-when-full at ≥99,
  emergency ceiling SLEEP_TICKS_MAX=2000 prevents stuck-asleep loops

Thoughts + mood + Sulking (Agent C, ~290 lines):
- scenes/ai/thought.gd: class Thought (RefCounted) with id, modifier, lifetime
  (PERSISTENT/EVENT), stacks, ticks_remaining; MAX_STACKS_PER_THOUGHT=5 locked
- scenes/ai/thought_catalog.gd: ThoughtCatalog with 5 Phase 8 thoughts —
  hungry(-6, PERSISTENT) / tired(-4, PERSISTENT) / well_rested(+5, EVENT 1200t)
  / slept_on_floor(-5, EVENT 1200t) / ate_meal(+3, EVENT 800t, stacks up to 3)
- Pawn extended: thoughts: Array, mood: float (base 50), sulking: bool,
  _sulk_low_ticks. add_thought (stack-merge by id), remove_thought_by_id,
  has_thought, is_sulking. _process_thoughts in sim_tick decays EVENT thoughts,
  syncs PERSISTENT thoughts to state (hungry/tired), recomputes mood, checks
  sulking transition: mood < 25 for MOOD_SULK_SUSTAIN_TICKS=600 ticks → SULKING;
  mood >= 35 → recover.
- Decision Layer 1 extended: pawn.is_sulking() → return null (sulking pawns
  refuse all work; Phase 17 may add Wandering variant)
- EventBus.pawn_mood_changed signal
- JobRunner._tick_eat: fires ate_meal thought when consuming MEAL/BREAD
- JobRunner._tick_sleep: fires well_rested or slept_on_floor on wake

Opus integration:
- world.tscn: SleepProvider node added (9 providers total)
- world.gd registers in priority order:
  sleep=8 > eat=7 > construction=6 > chop=5 ≈ plant=5 > mine=4 ≈ crafting=4 > haul=3 > rest=0
- Demo seed: 3 beds along cabin's north row at (45/47/49, 24), pre-built
  so pawns can sleep immediately when tired

Acceptance — MCP-verified end-to-end:
- Pre-tired Bram at sleep=25 → SleepProvider issued 'Sleep at (45, 24)' job
- Bram walked to bed, claimed, slept 200 ticks, woke at sleep≥99
- Bed released back to available; well_rested thought fired (+5 mood)
- After ~12000 ticks total: all 3 pawns slept (sleep recovered to 67/86/51),
  thoughts active (1-2 per pawn — well_rested + ate_meal from Phase 7 cooked
  bread consumption), beds all back to available, no claim leaks
- Mood compute working (base 50 + thought modifiers); sulking transition
  ready but didn't fire — would need misery accumulation (Phase 9 Cold +
  Bleeding statuses) to drive mood < 25 sustained

Phase 8 followups for later phases:
- Sulking returns null (stand still); Phase 17 may add Wandering soft-break
  that issues a random-walk job
- Bed ownership (_owner_pawn) reserved but not used in Phase 8 — Phase 17
  may add 'bedrooms' where each pawn claims a specific bed
- _tick_sleep's using_bed local-var reset pattern is correct but fragile;
  cleanup pass when status interrupts (Phase 9) wire into the eat/sleep
  cancellation path

Delegation report this phase:
- Agent A: Bed entity (buildable, quality-tinted, claim/release)
- Agent B: Pawn.sleep + SleepProvider + KIND_SLEEP toil + JobRunner._tick_sleep
- Agent C: Thought + ThoughtCatalog + Pawn mood/sulking + Decision Layer 1
  + JobRunner thought hooks in _tick_eat / _tick_sleep
- Opus: scene wiring + 3 beds in demo seed + MCP runtime verification

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

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

scenes/ai/sleep_provider.gd

@@ -0,0 +1,84 @@
+class_name SleepProvider extends WorkProvider
+## WorkProvider for the Sleep work category. Slots into the 5-layer pawn AI
+## (Decision → WorkProvider → Job + JobRunner) at priority 8 — above eating (7)
+## so a maximally tired AND hungry pawn prioritises rest.
+##
+## When a pawn is tired and not carrying an item, scans World.beds for the
+## nearest available bed and builds a 2-toil sleep job: walk → sleep.
+## If no bed is available, the pawn sleeps on the floor at its current tile
+## (walk toil omitted since it's already there).
+##
+## Bed claim race: the bed is NOT claimed here. Claiming in find_best_for()
+## would leak a held claim if the job is later cancelled by a player override
+## (Layer 5) before execution starts. Instead _tick_sleep in JobRunner claims
+## on first tick, when the pawn has actually arrived and is ready to sleep.
+## If the claim fails at that point (another pawn beat us) the fallback is
+## floor sleep — no deadlock, no leaked claim.
+##
+## Pawn and Bed are intentionally duck-typed to avoid the class_name
+## registration-order trap documented in Phase 2/3.
+##
+## See docs/architecture.md "Pawn AI 5-layer pipeline" and
+##     docs/design.md "Sleep mood" gradient.
+
+
+func _init() -> void:
+	category = &"sleep"
+	# Priority 8 > eat (7) > construction (6) > hauling (3) > rest (0).
+	# Phase 9 status interrupts will preempt from Decision layer 3 once the
+	# Status registry lands — for now sleep rides at the WorkProvider level.
+	priority = 8
+
+
+# ── WorkProvider override ─────────────────────────────────────────────────────
+
+## Returns a sleep Job for `pawn`, or null if the pawn is not tired.
+## The job has 1 or 2 toils:
+##   - walk_to(target_tile)  [omitted when target == pawn.tile]
+##   - sleep_in_bed(bed_path) [bed_path is empty string for floor sleep]
+##
+## `pawn` is duck-typed: must expose .is_tired(), .carried_item, .tile (Vector2i).
+func find_best_for(pawn) -> Job:
+	if not pawn.is_tired():
+		return null
+	# Don't interrupt an ongoing carry — finish the carry before going to sleep.
+	if pawn.carried_item != null:
+		return null
+
+	# Scan World.beds for the nearest available bed (duck-typed — Bed exposes
+	# .is_available() -> bool and .tile -> Vector2i).
+	var best_bed = null
+	var best_dist: int = 999999
+	for bed in World.beds:
+		if not bed.is_available():
+			continue
+		var d: int = abs(bed.tile.x - pawn.tile.x) + abs(bed.tile.y - pawn.tile.y)
+		if d < best_dist:
+			best_dist = d
+			best_bed = bed
+
+	# Resolve target tile and bed NodePath.  An empty NodePath means floor sleep.
+	var target_tile: Vector2i
+	var bed_path: NodePath
+	if best_bed != null:
+		target_tile = best_bed.tile
+		bed_path = best_bed.get_path()
+	else:
+		# Phase 8 fallback — sleep on the floor at the current tile.
+		# The Mood system (Agent C, Phase 8) will fire a "slept_on_floor" thought
+		# via the thought registry; analogous to EatProvider's "ate raw food".
+		target_tile = pawn.tile
+		bed_path = NodePath("")
+
+	var j := Job.new()
+	if best_bed != null:
+		j.label = "Sleep at %s" % target_tile
+	else:
+		j.label = "Sleep on the floor at %s" % target_tile
+
+	# Only prepend a walk if the pawn is not already at the target.
+	if pawn.tile != target_tile:
+		j.toils.append(Toil.walk_to(target_tile))
+
+	j.toils.append(Toil.sleep_in_bed(bed_path))
+	return j