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/services/inventory-ledger.test.js

@@ -0,0 +1,84 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { createInventoryLedger, _internal } from "./inventory-ledger.js";
+
+function items(spec) {
+	return Object.entries(spec).map(([name, count]) => ({ name, count }));
+}
+
+function fakeBot(spec) {
+	return { inventory: { items: () => items(spec) } };
+}
+
+test("count + total reflect the latest snapshot", () => {
+	const led = createInventoryLedger();
+	led.update(fakeBot({ raw_chicken: 2, oak_log: 5, cobblestone: 12 }));
+	assert.equal(led.count("raw_chicken"), 2);
+	assert.equal(led.count("missing"), 0);
+	assert.equal(led.total(/_log$/), 5);
+	assert.equal(led.total((n) => n === "cobblestone" || n === "oak_log"), 17);
+});
+
+test("gainedSince counts only positive deltas of matching items", () => {
+	const led = createInventoryLedger();
+	led.update(fakeBot({ raw_chicken: 0, feather: 1 }));
+	const base = led.mark();
+	led.update(fakeBot({ raw_chicken: 2, feather: 3 }));
+	// food matcher: raw_chicken only
+	assert.equal(led.gainedSince(base, "raw_chicken"), 2);
+	// regex over both
+	assert.equal(led.gainedSince(base, /raw_chicken|feather/), 4);
+	// a drop must not register as a gain
+	led.update(fakeBot({ raw_chicken: 1, feather: 3 }));
+	assert.equal(led.gainedSince(base, "raw_chicken"), 1);
+});
+
+test("acquired baselines to a wall-clock timestamp via history", () => {
+	const led = createInventoryLedger();
+	led.update(fakeBot({ raw_chicken: 0 }), 1000);
+	led.update(fakeBot({ raw_chicken: 1 }), 2000);
+	const t = 2500;
+	led.update(fakeBot({ raw_chicken: 3 }), 3000);
+	// since t=2500 the baseline is the snapshot at ts=2000 (count 1) → gained 2
+	assert.equal(led.acquired("raw_chicken", t), 2);
+	// since the very beginning → gained 3
+	assert.equal(led.acquired("raw_chicken", 0), 3);
+});
+
+test("delta returns the signed diff vs a timestamp", () => {
+	const led = createInventoryLedger();
+	led.update(fakeBot({ oak_log: 5, dirt: 2 }), 1000);
+	led.update(fakeBot({ oak_log: 8, cobblestone: 4 }), 2000);
+	const d = led.delta(1000);
+	assert.equal(d.oak_log, 3);
+	assert.equal(d.cobblestone, 4);
+	assert.equal(d.dirt, -2);
+});
+
+test("history is pruned by age and cap", () => {
+	const led = createInventoryLedger({ historyMs: 1000, maxSnapshots: 100 });
+	led.update(fakeBot({ a: 1 }), 0);
+	led.update(fakeBot({ a: 1 }), 500);
+	led.update(fakeBot({ a: 1 }), 2000); // cutoff = 2000-1000=1000 → drops ts 0 and 500
+	const hist = led._history();
+	assert.equal(hist.length, 1);
+	assert.equal(hist[0].ts, 2000);
+});
+
+test("matchFn supports string, regex, array, set, fn", () => {
+	const { matchFn } = _internal;
+	assert.equal(matchFn("a")("a"), true);
+	assert.equal(matchFn("a")("b"), false);
+	assert.equal(matchFn(/x/)("axb"), true);
+	assert.equal(matchFn(["a", "b"])("b"), true);
+	assert.equal(matchFn(new Set(["c"]))("c"), true);
+	assert.equal(matchFn((n) => n.length === 3)("abc"), true);
+	assert.equal(matchFn(undefined)("anything"), true);
+});
+
+test("update accepts a raw items array (test convenience)", () => {
+	const led = createInventoryLedger();
+	led.update(items({ stick: 4 }));
+	assert.equal(led.count("stick"), 4);
+});