feat(runtime): persistent memory — world-journal + scenario-memory

Closes a structural gap: the bot now actually REMEMBERS what it
discovered and what it tried. Two stores live under state/<host>/ and
are wired in automatically.

runtime/world-journal.js
- Append-only JSONL of discovered points (chopped, placed, base,
  shelter, farm, dead_end). Indexed by 16-block spatial grid; O(neighbors)
  nearest() lookups; 6 h age prune; 10k line ceiling with trim.
- leanestQuadrant({x,z}) reports the quadrant the bot has the FEWEST
  markers in — used by explore.far to circle rather than retread.
- summary() exposed for the stuck-incident proposal body.

runtime/scenario-memory.js
- Sliding window of (skillId, situationHash, code, ok, detail) tuples.
- situationHash() is a coarse fingerprint (16x8x16 cell + day/night +
  food/hp bucket + inv key set + closest hostile). So "same kind of
  place + same kind of state" matches.
- shouldSkip({skillId, situation}) → true after ≥3 failures within 30
  min UNLESS a more-recent success in the same situation un-locks it.
- recentTailFor() exposed for the stuck-incident body.

Wiring (runtime/bot.js):
- dispatchAction captures situationHash BEFORE the action runs and
  records (skillId, situation, code, ok) after — failures are attributed
  to the dispatch-time state, not the partial-effect state.
- worldDelta fields (choppedAt, minedAt, placedAt, baseAt, shelterAt,
  plantedAt, harvestedAt, tilledAt) auto-flow into the journal.
- no_target + silent_dig_failure also write dead_end markers.

Scheduler / skills now consume memory:
- reflex.js curriculum reflex calls memory.shouldSkip — if the same
  (skill, situation) failed 3+ times recently, auto-converts to a
  wander hint so the bot leaves and tries elsewhere.
- explore.far calls journal.leanestQuadrant when multiple cardinal
  directions are walkable and prefers the less-explored one.
- gather.logs walks to the nearest known "chopped" bucket within 96
  blocks before falling through to findBlock — chunks with confirmed
  trees are more likely to yield another.

stuck-incident body now includes journal byKind + last 12 scenario
entries so Pi can write a structural fix, not just a guard clause.

Architecturally: this is the foundation for "bot rewrites itself".
The proposals Pi now receives carry real signal about what was tried
and what's around, instead of a single snapshot in isolation.

10 new tests (world-journal × 5, scenario-memory × 5). npm test 134/134.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

runtime/skills/chop-logs.js

@@ -3,8 +3,27 @@
 // while exposing the survival-skill contract (preconditions, timeout,
 // structured worldDelta, recovery hint).
 
+import pathfinderPkg from "mineflayer-pathfinder";
+const { pathfinder, goals } = pathfinderPkg;
+
 import { chopNearestTree } from "../actions.js";
 import { logs as logBlocks } from "./groups.js";
+import { info } from "../log.js";
+
+let pluginLoaded = new WeakSet();
+function ensurePathfinder(bot) {
+	if (pluginLoaded.has(bot)) return;
+	bot.loadPlugin(pathfinder);
+	pluginLoaded.add(bot);
+}
+
+function withTimeout(promise, ms, label) {
+	let timer;
+	const timeout = new Promise((_, reject) => {
+		timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms / 1000}s`)), ms);
+	});
+	return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
 
 export const skill = Object.freeze({
 	id: "gather.logs",
@@ -19,6 +38,28 @@ export const skill = Object.freeze({
 		return { ok: true };
 	},
 	async execute(ctx) {
+		// Journal-aware approach: if we previously chopped a tree (or saw a
+		// tree marker) within 96 blocks, walk to that bucket first — the
+		// chunk has been confirmed to contain trees, so the next chop is
+		// likely to succeed there even if findBlock at the current position
+		// returned nothing.
+		const bot = ctx.bot;
+		const here = bot.entity?.position;
+		if (here && ctx?.journal?.nearest) {
+			const near = ctx.journal.nearest({ kind: "chopped", x: here.x, z: here.z, radius: 96, limit: 1 });
+			if (near.length && near[0].distance > 8) {
+				ensurePathfinder(bot);
+				const t = near[0].at;
+				info("action", `gather.logs: journal hint → walk to known tree area ${t.x},${t.y},${t.z} (${near[0].distance.toFixed(0)}m)`);
+				try {
+					await withTimeout(
+						bot.pathfinder.goto(new goals.GoalNear(t.x, t.y, t.z, 6)),
+						25_000,
+						"gotoTreeArea",
+					);
+				} catch {} // ignore, fall through to chop attempt
+			}
+		}
 		const res = await chopNearestTree(ctx.bot);
 		if (res.ok) {
 			return {

runtime/skills/explore-far.js

@@ -69,7 +69,23 @@ export const skill = Object.freeze({
 		// gives us a free-direction signal cheaply.
 		const dist = Math.max(24, args.distance ?? 48);
 		const trials = await probeCardinalStep(bot, 800);
-		const best = trials.reduce((b, t) => (t.dist > b.dist ? t : b), { dist: 0, yaw: 0, name: "?" });
+		const movable = trials.filter((t) => t.dist > 0.5);
+
+		// Journal-aware: if more than one direction is walkable, prefer the
+		// one in the LEANEST quadrant (least amount of stuff we've already
+		// catalogued, including dead_end markers — so we don't loop the same
+		// area). Falls back to "best by distance" when only one direction
+		// works or journal is empty.
+		let best = trials.reduce((b, t) => (t.dist > b.dist ? t : b), { dist: 0, yaw: 0, name: "?" });
+		if (movable.length > 1 && ctx?.journal?.leanestQuadrant) {
+			const here = bot.entity.position;
+			const { best: leanest } = ctx.journal.leanestQuadrant({ x: here.x, z: here.z, radius: 96 });
+			const QUAD_TO_CARDINAL = { NE: "N", SE: "E", SW: "S", NW: "W" };
+			const preferredName = QUAD_TO_CARDINAL[leanest];
+			const preferred = movable.find((t) => t.name === preferredName);
+			if (preferred) best = preferred;
+			info("action", `explore.far: journal says leanest quadrant=${leanest} → prefer ${preferredName}`);
+		}
 		info("action", `explore.far: cardinal probe trials=${trials.map((t) => `${t.name}:${t.dist.toFixed(1)}`).join(" ")} best=${best.name}`);
 
 		if (best.dist < 0.5) {