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>

runtime/goal/village-score.test.js

@@ -0,0 +1,52 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { computeVillageScore, _internal } from "./village-score.js";
+
+function snap(extra = {}) {
+	return { connected: true, health: 20, food: 20, hasFood: false, locations: {}, ...extra };
+}
+
+test("empty/fresh world scores low", () => {
+	const r = computeVillageScore(snap({ health: 20, food: 5 }), {
+		contract: { completed: 0, total: 10 },
+		uptimeMs: 0,
+		metrics: {},
+	});
+	assert.ok(r.score < 0.2, `expected low score, got ${r.score}`);
+});
+
+test("a fully established settlement scores high", () => {
+	const metrics = {};
+	for (let i = 0; i < 12; i++) metrics[`skill.${i}`] = { ok: 3, fail: 0 };
+	const r = computeVillageScore(
+		snap({ health: 20, food: 20, hasFood: true, locations: { base: {}, shelter: {}, chest: {} } }),
+		{ contract: { completed: 10, total: 10 }, uptimeMs: 3 * 60 * 60 * 1000, metrics },
+	);
+	assert.ok(r.score > 0.9, `expected high score, got ${r.score}`);
+	assert.equal(r.components.milestones, 1);
+	assert.equal(r.components.base, 1);
+});
+
+test("score is monotonic in milestone completion", () => {
+	const base = { uptimeMs: 0, metrics: {} };
+	const low = computeVillageScore(snap(), { ...base, contract: { completed: 1, total: 10 } });
+	const high = computeVillageScore(snap(), { ...base, contract: { completed: 8, total: 10 } });
+	assert.ok(high.score > low.score);
+});
+
+test("score stays within 0..1", () => {
+	const r = computeVillageScore(snap({ health: 999, food: 999 }), {
+		contract: { completed: 100, total: 10 },
+		uptimeMs: 1e12,
+		metrics: { a: { ok: 999 } },
+	});
+	assert.ok(r.score >= 0 && r.score <= 1);
+});
+
+test("clamp01 helper", () => {
+	assert.equal(_internal.clamp01(-1), 0);
+	assert.equal(_internal.clamp01(2), 1);
+	assert.equal(_internal.clamp01(0.5), 0.5);
+	assert.equal(_internal.clamp01(NaN), 0);
+});