mayatnikovandClaude Opus 4.7
2a6cc0cdb1
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>
85 lines
2.8 KiB
JavaScript
85 lines
2.8 KiB
JavaScript
// 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";
|
|
|
|
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;
|
|
}
|
|
|
|
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 };
|
|
}
|