xmatic/pepa-pi-bot
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

v0.4.0 vNext — closed-loop world model + settlement contract (#29)

Browse Source 
* 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>
This commit was merged in pull request #29.
This commit is contained in:
Yuriy Mayatnikov
2026-05-28 11:29:39 +03:00
committed by GitHub
co-authored by Claude Opus 4.7 mayatnikov
parent 15b6c11002
commit c910457817
31 changed files with 2236 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files
runtime/actions.js
+58 -23
View File
@@ -143,7 +143,30 @@ export async function attackNearest(bot, hostileType) {
// ---- flee ------------------------------------------------------------------
export async function fleeFrom(bot, fromEntity, distance = 16) {
async function blindRetreat(bot, dirYaw, blindMs = 7_000) {
const before = bot.entity.position.clone?.() ?? { ...bot.entity.position };
try { bot.pathfinder?.stop?.(); } catch {}
try { await bot.look(dirYaw, 0, true); } catch {}
bot.setControlState("forward", true);
bot.setControlState("jump", true);
try {
await new Promise((r) => setTimeout(r, blindMs));
} finally {
bot.setControlState("forward", false);
bot.setControlState("jump", false);
}
const after = bot.entity.position;
const moved = Math.hypot(after.x - before.x, after.z - before.z);
return { moved, after };
}
// v0.4.0 — when a MotionService is supplied (opts.motion), retreat via
// gotoSafe: a 12s wall-clock with a 4s progress watchdog returns a STRUCTURED
// {stuck|timeout|nopath} fast instead of hanging the full 30s that we observed
// live (zombie pinning the bot, every flee timing out, watchdog burning 3
// replans). On any non-reached result we fall straight through to the blind
// retreat. Callers without a motion service keep the legacy 30s path.
export async function fleeFrom(bot, fromEntity, distance = 16, opts = {}) {
ensurePathfinder(bot);
const from = fromEntity?.position ?? bot.entity.position;
const here = bot.entity.position;
@@ -154,50 +177,62 @@ export async function fleeFrom(bot, fromEntity, distance = 16) {
const tx = Math.round(here.x + (dx / len) * distance);
const tz = Math.round(here.z + (dz / len) * distance);
const ty = Math.round(here.y);
const dirYaw = -Math.atan2(dx / len, dz / len);
const blindMs = opts.blindMs ?? 7_000;
info("action", `flee: from=${fromEntity?.name ?? "?"} → ${tx},${ty},${tz}`);
// canDig:true here is deliberate — without it the bot gets permanently
// stuck in dense tree canopy (observed live: bot perched at Y=85 inside
// dark-oak leaves, every flee timed out for hours). We accept the risk of
// chopping through scenery while panicking; it's how a player would react.
const movements = new Movements(bot);
movements.canDig = true;
movements.allow1by1towers = false;
bot.pathfinder.setMovements(movements);
try {
const movements = new Movements(bot);
movements.canDig = true;
movements.allow1by1towers = false;
bot.pathfinder.setMovements(movements);
} catch {
// fake/registry-less bot (tests) — skip movement tuning
}
const goal = new goals.GoalNear(tx, ty, tz, 1);
if (opts.motion?.gotoSafe) {
const res = await opts.motion.gotoSafe(goal, {
timeoutMs: opts.timeoutMs ?? 12_000,
stuckWindowMs: 4_000,
stuckDelta: 1.5,
label: `flee(${fromEntity?.name})`,
});
if (res.ok) return { ok: true, detail: { to: { x: tx, y: ty, z: tz }, moved: res.movedBlocks } };
warn("action", `flee gotoSafe → ${res.code} (moved ${res.movedBlocks}b); blind retreat`);
const b = await blindRetreat(bot, dirYaw, blindMs);
if (b.moved >= 4) {
return { ok: true, detail: { to: { x: Math.round(b.after.x), y: Math.round(b.after.y), z: Math.round(b.after.z) }, mode: "blind-retreat", moved: b.moved } };
}
return { ok: false, code: res.code, detail: `flee ${res.code} then blind retreat moved ${b.moved.toFixed(2)}b` };
}
try {
await withTimeout(
bot.pathfinder.goto(new goals.GoalNear(tx, ty, tz, 1)),
bot.pathfinder.goto(goal),
30_000,
`fleeFrom(${fromEntity?.name})`,
);
return { ok: true, detail: { to: { x: tx, y: ty, z: tz } } };
} catch (e) {
warn("action", `flee path failed: ${e.message}; trying blind retreat`);
const before = bot.entity.position.clone?.() ?? { ...bot.entity.position };
try { bot.pathfinder?.stop?.(); } catch {}
try { await bot.look(-Math.atan2(dx / len, dz / len), 0, true); } catch {}
bot.setControlState("forward", true);
bot.setControlState("jump", true);
try {
await new Promise((r) => setTimeout(r, 7_000));
} finally {
bot.setControlState("forward", false);
bot.setControlState("jump", false);
}
const after = bot.entity.position;
const moved = Math.hypot(after.x - before.x, after.z - before.z);
if (moved >= 4) {
const b = await blindRetreat(bot, dirYaw, blindMs);
if (b.moved >= 4) {
return {
ok: true,
detail: {
to: { x: Math.round(after.x), y: Math.round(after.y), z: Math.round(after.z) },
to: { x: Math.round(b.after.x), y: Math.round(b.after.y), z: Math.round(b.after.z) },
mode: "blind-retreat",
moved,
moved: b.moved,
},
};
}
warn("action", `flee blind retreat moved only ${moved.toFixed(2)} blocks`);
warn("action", `flee blind retreat moved only ${b.moved.toFixed(2)} blocks`);
return { ok: false, detail: e.message };
}
}