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/skills/_common.test.js

@@ -0,0 +1,67 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { approachBlock, _internal } from "./_common.js";
+
+test("blockPos floors a position; blockCenter offsets to centre", () => {
+	assert.deepEqual(_internal.blockPos({ x: 10.9, y: 64.2, z: -3.7 }), { x: 10, y: 64, z: -4 });
+	assert.deepEqual(_internal.blockCenter({ position: { x: 10, y: 64, z: -4 } }), { x: 10.5, y: 64.5, z: -3.5 });
+});
+
+test("withinReach respects the radius", () => {
+	assert.equal(_internal.withinReach({ x: 0.5, y: 64.5, z: 0.5 }, { x: 0, y: 64, z: 0 }, 4), true);
+	assert.equal(_internal.withinReach({ x: 20, y: 64, z: 0 }, { x: 0, y: 64, z: 0 }, 4), false);
+});
+
+test("approachBlock returns no_target without a target", async () => {
+	const r = await approachBlock({ bot: { entity: { position: { x: 0, y: 64, z: 0 } } } }, null);
+	assert.equal(r.ok, false);
+	assert.equal(r.code, "no_target");
+});
+
+test("approachBlock looks at the block when already in reach (no path needed)", async () => {
+	let looked = false;
+	let gotoCalled = false;
+	const ctx = {
+		bot: {
+			entity: { position: { x: 0.5, y: 64, z: 0.5 } },
+			async lookAt() { looked = true; },
+		},
+		motion: { gotoSafe: async () => { gotoCalled = true; return { ok: true, code: "reached" }; } },
+	};
+	const r = await approachBlock(ctx, { x: 0, y: 64, z: 0 }, { reachCheck: 4 });
+	assert.equal(r.ok, true);
+	assert.equal(looked, true);
+	assert.equal(gotoCalled, false, "should not path when already in reach");
+});
+
+test("approachBlock uses motion.gotoSafe to close distance, then looks", async () => {
+	let looked = false;
+	const ctx = {
+		bot: {
+			// starts far, motion 'moves' it into reach by mutating position
+			entity: { position: { x: 30, y: 64, z: 0 } },
+			async lookAt() { looked = true; },
+		},
+		motion: {
+			gotoSafe: async () => { ctx.bot.entity.position = { x: 0.6, y: 64, z: 0.6 }; return { ok: true, code: "reached" }; },
+		},
+	};
+	const r = await approachBlock(ctx, { x: 0, y: 64, z: 0 });
+	assert.equal(r.ok, true);
+	assert.equal(looked, true);
+	assert.ok(r.distance <= 4);
+});
+
+test("approachBlock fails when motion can't get into reach", async () => {
+	const ctx = {
+		bot: {
+			entity: { position: { x: 30, y: 64, z: 0 } }, // never moves
+			async lookAt() {},
+		},
+		motion: { gotoSafe: async () => ({ ok: false, code: "stuck" }) },
+	};
+	const r = await approachBlock(ctx, { x: 0, y: 64, z: 0 });
+	assert.equal(r.ok, false);
+	assert.equal(r.code, "stuck");
+});