c910457817
* 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>
64 lines
2.4 KiB
JavaScript
64 lines
2.4 KiB
JavaScript
// survive.flee — emergency retreat from the nearest hostile. Unlike
|
|
// explore.far, this skill explicitly moves away from the hostile entity
|
|
// that triggered the mode.
|
|
|
|
import { fleeFrom } from "../actions.js";
|
|
|
|
const HOSTILE = new Set([
|
|
"zombie", "skeleton", "creeper", "spider", "witch", "pillager",
|
|
"vindicator", "husk", "stray", "drowned", "phantom", "enderman",
|
|
"slime", "magma_cube", "hoglin", "piglin_brute", "ravager", "warden",
|
|
"breeze", "bogged",
|
|
]);
|
|
|
|
function nearestHostile(bot, { hostileName } = {}) {
|
|
const here = bot?.entity?.position;
|
|
if (!here) return null;
|
|
let best = null;
|
|
for (const e of Object.values(bot.entities ?? {})) {
|
|
if (!e?.position) continue;
|
|
const name = (e.name || "").toLowerCase();
|
|
if (hostileName && name !== String(hostileName).toLowerCase()) continue;
|
|
if (!hostileName && !HOSTILE.has(name)) continue;
|
|
const d = e.position.distanceTo(here);
|
|
if (!best || d < best.distance) best = { entity: e, distance: d };
|
|
}
|
|
return best;
|
|
}
|
|
|
|
export const skill = Object.freeze({
|
|
id: "survive.flee",
|
|
title: "Retreat from the nearest hostile",
|
|
timeoutMs: 40_000,
|
|
preconditions(ctx, args = {}) {
|
|
if (!ctx?.bot) return { ok: false, code: "no_bot", detail: "bot missing" };
|
|
const hit = nearestHostile(ctx.bot, args);
|
|
if (!hit) return { ok: false, code: "no_hostile", detail: "no matching hostile entity" };
|
|
return { ok: true };
|
|
},
|
|
async execute(ctx, args = {}) {
|
|
const hit = nearestHostile(ctx.bot, args);
|
|
if (!hit) return { ok: false, code: "no_hostile", detail: "no matching hostile after precondition", worldDelta: null };
|
|
const res = await fleeFrom(ctx.bot, hit.entity, args.distance ?? 16, { motion: ctx.motion, blindMs: args.blindMs });
|
|
if (res.ok) {
|
|
return {
|
|
ok: true,
|
|
code: "done",
|
|
detail: { ...res.detail, from: hit.entity.name, distance: Math.round(hit.distance * 10) / 10 },
|
|
worldDelta: { fledTo: res.detail?.to ?? null },
|
|
};
|
|
}
|
|
// Prefer the structured code from MotionService (stuck/timeout/nopath);
|
|
// fall back to string-sniffing the legacy path's message.
|
|
const msg = String(res.detail ?? "");
|
|
const code = res.code ?? (msg.includes("timed out") ? "timeout" : "failed");
|
|
return { ok: false, code, detail: res.detail, worldDelta: null };
|
|
},
|
|
recover(ctx, result) {
|
|
if (result.code === "timeout") return { hint: "tunnel-out", reason: "flee path timed out" };
|
|
return null;
|
|
},
|
|
});
|
|
|
|
export const _internal = { nearestHostile };
|