v0.4.0 vNext — closed-loop world model + settlement contract (#29)

* feat(v0.4.0): vNext — closed-loop world model + settlement contract

Implements the vNext architecture from the research doc: demote the noisy
multi-rail planner in favour of a closed loop (world truth → invariant check)
plus a single utility-driven goal authority.

L1 services (fix no_drop / silent pathfinder hang first):
- InventoryLedger: diff-based "did I actually get it" verifier; acquire-food
  now confirms via ledger.gainedSince instead of the unreliable count/event.
- MotionService.gotoSafe: wall-clock timeout + progress watchdog +
  path_update(noPath/timeout) → structured {reached|stuck|timeout|nopath}.

L3 plan — unify the three competing rails (curriculum/manifesto/storyline):
- Settlement Contract: ordered M0–M9 milestones, each invariant-checked
  against an authoritative world view (early steps delegate to the proven
  curriculum; late game adds farming).
- InvariantChecker + predicate library; GoalManager selects the lowest unmet
  milestone via utility argmax (food-urgency preempts, DEPS-style).
- Wired into the scheduler: bot.js precomputes snapshot.contract; reflex.js
  consumes it in place of the storyline rail. Manifesto L0 still preempts.

Eval + robustness:
- Village Score (single 0..1 metric) on the snapshot + TUI "build" line.
- survive.dig-in skill + dusk_dig_in mode (exposed at night, no bed → cover).
- approach_block helper (GoalNear + lookAt, avoids GoalLookAtBlock #341).

+28 new tests (450 total green). LLM remains entirely off the tick path.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* feat(v0.4.0): finish vNext plan — anti-loop, skill-graph, worldDelta diff, flee→motion

Completes the remaining v0.4.0 plan items and one fix motivated by a live
in-game observation (flee hanging 30s against a persistent zombie).

- flee → MotionService.gotoSafe: structured {stuck|timeout|nopath} in ~4s with
  a blind-retreat fallback, instead of the observed 30s pathfinder hang + 3
  watchdog replans. Movements setup guarded so it is unit-testable.
- QW5 anti-loop (runtime/anti-loop.js): same skill failing >=3x in 5min →
  30min blacklist (reflex shouldSkip) + one-shot improvement_request
  (bot.js drainFired -> writeProposal).
- 4.1 closed-loop worldDelta: runSkill snapshots inventory before execute and
  attaches the real delta (_invObserved) to every successful result; opt-in
  skill.expectGain asserts the claimed gain or returns world_unchanged.
- 3.6 skill-graph (Plan4MC): declarative requires/produces for ~20 skills;
  prerequisitesMet/canRun/runnableFrontier; GoalManager annotates suggestions
  with blockedBy when prereqs are unmet.

+22 tests (472 total green). Live smoke confirmed dig-in works and no new
errors; flee loop is what this commit's flee migration addresses.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

---------

Co-authored-by: Yuriy Mayatnikov <mayatnikov@me.com>
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

runtime/goal/goal-manager.js

@@ -0,0 +1,93 @@
+// GoalManager (L3) — the single progression authority.
+//
+// Walks the Settlement Contract, evaluates each milestone's invariants against
+// the world, and selects which milestone to pursue now. Selection is a utility
+// argmax over the UNMET milestones:
+//
+//     score(m) = -index(m) + urgency(m, world)
+//
+// With no urgency this is just "lowest unmet milestone wins" (strict ordered
+// progression). urgency lets a survival-critical milestone (food when starving)
+// preempt a lower-indexed one — the DEPS-style "consider how easy/urgent a
+// sub-goal is" idea, expressed as a hand-tuned utility (research §C, DEPS).
+//
+// The GoalManager does NOT dispatch and never calls the LLM. It returns a
+// suggestion the scheduler consumes; the survival/emergency layer (modes,
+// manifesto L0) still preempts above it.
+
+import { SETTLEMENT_CONTRACT } from "./contract.js";
+import { checkInvariants, worldFromSnapshot } from "./invariants.js";
+import { prerequisitesMet } from "./skill-graph.js";
+
+export function createGoalManager({ contract = SETTLEMENT_CONTRACT } = {}) {
+	// Evaluate every milestone; returns the per-milestone invariant status plus
+	// the selected current milestone and its suggested skill.
+	function evaluate(world) {
+		const evaluated = contract.map((m, index) => {
+			const check = checkInvariants(m, world);
+			return {
+				index,
+				id: m.id,
+				title: m.title,
+				met: check.met,
+				unmet: check.unmet,
+				evidence: check.evidence,
+				urgency: typeof m.urgency === "function" ? (m.urgency(world) || 0) : 0,
+				_m: m,
+			};
+		});
+
+		const completed = evaluated.filter((e) => e.met).length;
+		const total = evaluated.length;
+		const unmet = evaluated.filter((e) => !e.met);
+
+		if (unmet.length === 0) {
+			return { done: true, completed, total, milestone: null, suggestedSkill: null, ranked: [], evaluated };
+		}
+
+		// Utility argmax. Tie-break by lower index (more foundational first).
+		const ranked = unmet
+			.map((e) => ({ ...e, score: -e.index + e.urgency }))
+			.sort((a, b) => b.score - a.score || a.index - b.index);
+
+		const current = ranked[0];
+		let suggestedSkill = null;
+		try {
+			suggestedSkill = current._m.suggest(world) ?? null;
+		} catch {
+			suggestedSkill = null;
+		}
+
+		// Annotate the suggestion with skill-graph prerequisite status (Plan4MC).
+		// Observability + a guard surface: if prereqs are unmet the curriculum
+		// chain should already be steering toward them, but we expose the gap.
+		if (suggestedSkill?.skillId) {
+			const pre = prerequisitesMet(suggestedSkill.skillId, world);
+			if (!pre.ok) suggestedSkill = { ...suggestedSkill, blockedBy: pre.missing };
+		}
+
+		const reason = current.urgency > 0 && current.index > unmet[0].index
+			? `urgent:${current.id}(${current.urgency}) preempts ${unmet[0].id}`
+			: `lowest unmet: ${current.id}`;
+
+		return {
+			done: false,
+			completed,
+			total,
+			milestone: { id: current.id, title: current.title, unmet: current.unmet },
+			suggestedSkill,
+			reason,
+			ranked: ranked.map((r) => ({ id: r.id, score: r.score, urgency: r.urgency })),
+			evaluated,
+		};
+	}
+
+	// Convenience: build the world from a runtime snapshot (+optional ledger)
+	// and evaluate. This is what the scheduler calls each tick.
+	function next(snapshot, extra = {}) {
+		const world = worldFromSnapshot(snapshot, extra);
+		return evaluate(world);
+	}
+
+	return { evaluate, next };
+}