@polycode-projects/the-mechanical-code-talker 5.0.2 → 5.0.4

package/src/services/spider-fly.mjs

@@ -1,943 +0,0 @@
-// spider-fly.mjs — the headless spider-and-fly turn engine: state fold,
-// single-agent pathfinding, belief/visibility, greedy fly evasion, and the
-// egg/hatch/spawn/starve ecology pass, all reading and writing plain fact
-// rows through the shared memory store. No chat, no rendering — a later
-// piece of work wraps runSpiderFlyTick's return shape for a chat turn.
-//
-// Grid geometry (cellId, parseCellId, chebyshevDistance, isInWebBlock,
-// perimeterCells, DIRECTION_DELTA) is never redefined here — it all comes
-// from spider-fly-world.mjs, the one source of truth both the shipped world
-// pack and this engine read from. Vision-gated belief is the same deal: it
-// lives in the board-size-agnostic domain/agent-belief.mjs and is re-exported
-// below, so this file's public surface is unchanged by where it sits.
-
-import {
-  WORLD_NAME, WEB_HOME, WEB_DURATION_TURNS, SPIDER_INITIAL_MASS, SPIDER_MASS_DECREMENT_PER_TURN,
-  cellId, parseCellId, chebyshevDistance, isInWebBlock, perimeterCells,
-  DIRECTION_DELTA, oneStepDirectionBetween,
-} from "../domain/spider-fly-world.mjs";
-import {
-  DEFAULT_VISION_RADIUS, believedCellOf, nearestBelievedTarget, beliefSnapshotFor,
-} from "../domain/agent-belief.mjs";
-import { findActionPath, findReachableSet } from "../domain/planning.mjs";
-import { appendFacts, loadMemory, readFactRows } from "../adapters/memory/core.mjs";
-import { worldProvenanceTag } from "../domain/worlds-pack.mjs";
-import { mulberry32 } from "../domain/seeded-random.mjs";
-import { fnv1a32 } from "../domain/hash.mjs";
-import { DEFAULT_GAME_CONFIG } from "../domain/game-config.mjs";
-
-// ---- tunable constants (starting values, not fixed — the vision radius and
-// mass economy all want checking against a real playable board) -------------
-
-export const FLY_INITIAL_MASS = 10;
-export const FLY_MASS_DECREMENT_PER_TURN = 1;
-export const EGG_HATCH_DELAY_TURNS = 3;
-export const FLY_SPAWN_INTERVAL_TURNS = 3;
-export const EGG_LAY_MASS_THRESHOLD = 25;
-export const EGG_HATCH_COUNT = 2;
-export const MIN_HATCHLING_MASS = 3;
-export { SPIDER_INITIAL_MASS, SPIDER_MASS_DECREMENT_PER_TURN, WEB_DURATION_TURNS };
-export { DEFAULT_VISION_RADIUS, believedCellOf, nearestBelievedTarget, beliefSnapshotFor };
-
-// ---- seeded "randomness" (never Math.random) ---------------------------------
-// Every "random" decision (fly wander, fly/spawn placement) is a mulberry32
-// draw seeded by an fnv1a32 hash of a context string built from data already
-// in the facts (world name, turn number, the subject's own id, a purpose
-// tag) — the same hash-seeds-a-PRNG idiom answer-variants.mjs's phrase
-// selection already uses. Two runs from the same starting facts produce the
-// byte-identical sequence of "random" choices, never wall-clock driven.
-
-/** Deterministically pick one of `options` (must be non-empty), keyed on
- *  `contextString`. */
-function seededPick(options, contextString) {
-  const rng = mulberry32(fnv1a32(contextString));
-  return options[Math.floor(rng() * options.length)];
-}
-
-// ---- the state fold ----------------------------------------------------------
-
-const SNAPSHOT_RE = /^(.+)@turn(\d+)$/;
-
-function splitSnapshot(subject) {
-  const m = SNAPSHOT_RE.exec(subject);
-  return m ? { base: m[1], turn: Number(m[2]) } : { base: subject, turn: 0 };
-}
-
-const WEB_ID_RE = /^web-\d+$/;
-
-/** Fold fact rows into the current spider-fly world state: per-subject
- *  newest placement (mgx:currently-in), newest fly mass, spider's newest
- *  flies-eaten count, each spider's newest carrying status (mgx:carrying —
- *  a fly id, or "none"), each egg's laid-at-turn, each dynamic web's cell +
- *  built-at turn, and the terminal eaten-by/starved/hatched-into markers that
- *  make a subject no longer live. The turn counter is derived, never stored —
- *  the largest @turnN suffix seen, exactly foldWorldState's own convention.
- *  Pure. */
-export function foldSpiderFlyState(factRows) {
-  const placements = new Map();  // subject -> { cell, turn }
-  const mass = new Map();        // fly/spider subject -> { value, turn }
-  const fliesEaten = new Map();  // spider subject -> { value, turn }
-  const carrying = new Map();    // spider subject -> { flyId, turn } (flyId "none" omitted)
-  const laidAtTurn = new Map();  // egg subject -> { value, turn }
-  const webCell = new Map();     // web subject -> { cell, turn }
-  const webBuiltAt = new Map();  // web subject -> { value, turn }
-  const eatenBy = new Map();     // fly subject -> { spider, turn }
-  const starved = new Set();     // fly/spider subject
-  const hatchedInto = new Map(); // egg subject -> { spider, turn }
-  let turnCount = 0;
-
-  for (const row of factRows || []) {
-    const { base, turn } = splitSnapshot(row.subject);
-    if (turn) turnCount = Math.max(turnCount, turn);
-
-    if (row.predicate === "mgx:currently-in") {
-      const prior = placements.get(base);
-      if (!prior || turn >= prior.turn) placements.set(base, { cell: row.object, turn });
-      if (WEB_ID_RE.test(base)) {
-        const priorWeb = webCell.get(base);
-        if (!priorWeb || turn >= priorWeb.turn) webCell.set(base, { cell: row.object, turn });
-      }
-      continue;
-    }
-    if (row.predicate === "mgx:mass") {
-      const prior = mass.get(base);
-      if (!prior || turn >= prior.turn) mass.set(base, { value: Number(row.object), turn });
-      continue;
-    }
-    if (row.predicate === "mgx:flies-eaten") {
-      const prior = fliesEaten.get(base);
-      if (!prior || turn >= prior.turn) fliesEaten.set(base, { value: Number(row.object), turn });
-      continue;
-    }
-    if (row.predicate === "mgx:carrying") {
-      const prior = carrying.get(base);
-      if (!prior || turn >= prior.turn) {
-        if (row.object === "none") carrying.delete(base);
-        else carrying.set(base, { flyId: row.object, turn });
-      }
-      continue;
-    }
-    if (row.predicate === "mgx:laid-at-turn") {
-      const prior = laidAtTurn.get(base);
-      if (!prior || turn >= prior.turn) laidAtTurn.set(base, { value: Number(row.object), turn });
-      continue;
-    }
-    if (row.predicate === "mgx:web-built-at-turn") {
-      const prior = webBuiltAt.get(base);
-      if (!prior || turn >= prior.turn) webBuiltAt.set(base, { value: Number(row.object), turn });
-      continue;
-    }
-    if (row.predicate === "mgx:eaten-by") {
-      const prior = eatenBy.get(base);
-      if (!prior || turn >= prior.turn) eatenBy.set(base, { spider: row.object, turn });
-      continue;
-    }
-    if (row.predicate === "mgx:starved") { starved.add(base); continue; }
-    if (row.predicate === "mgx:hatched-into") {
-      const prior = hatchedInto.get(base);
-      if (!prior || turn >= prior.turn) hatchedInto.set(base, { spider: row.object, turn });
-      continue;
-    }
-  }
-
-  const webs = new Map(); // web subject -> { cell, builtAtTurn }
-  for (const [id, { cell }] of webCell) {
-    const builtAtTurn = webBuiltAt.get(id)?.value;
-    if (builtAtTurn !== undefined) webs.set(id, { cell, builtAtTurn });
-  }
-
-  const removed = new Set([...eatenBy.keys(), ...starved, ...hatchedInto.keys()]);
-  return { placements, mass, fliesEaten, carrying, laidAtTurn, webs, eatenBy, starved, hatchedInto, removed, turnCount };
-}
-
-const sortedLiveSubjects = (state, re) =>
-  [...state.placements.keys()].filter((id) => re.test(id) && !state.removed.has(id)).sort();
-
-function maxIdSuffix(ids, re) {
-  let max = 0;
-  for (const id of ids) {
-    const m = re.exec(id);
-    if (m) max = Math.max(max, Number(m[1]));
-  }
-  return max;
-}
-
-// ---- single-agent pathfinding (§5): hand-written applyActions over the
-// world pack's own has-exit-<direction> facts, NOT the taught action-rule
-// DSL, whose no-incoming/comparator precondition shapes cannot express grid
-// adjacency (the same limitation Ashcombe's own runWorldCommand worked
-// around). State is the plain {x, y} coordinate the search kernel treats as
-// opaque. ---------------------------------------------------------------------
-
-const EXIT_PREDICATE_RE = /^mgx:has-exit-([a-z]+)$/;
-
-/** The spider/fly movement applyActions closure findActionPath/
- *  findReachableSet need: one hop per has-exit-<direction> fact reachable
- *  from a cell, in the fixed direction order both agents' search shares for
- *  deterministic tie-breaking. Built once per tick from the world's own
- *  static exit facts (grid topology is common knowledge to both agents). */
-export function gridApplyActions(factRows) {
-  const exits = new Map();
-  for (const row of factRows || []) {
-    const m = EXIT_PREDICATE_RE.exec(row.predicate);
-    if (!m) continue;
-    if (!exits.has(row.subject)) exits.set(row.subject, new Map());
-    exits.get(row.subject).set(m[1], row.object);
-  }
-  return (state) => {
-    const out = [];
-    const dirs = exits.get(cellId(state.x, state.y));
-    if (!dirs) return out;
-    for (const direction of Object.keys(DIRECTION_DELTA)) {
-      const target = dirs.get(direction);
-      if (!target) continue;
-      const parsed = parseCellId(target);
-      if (!parsed) continue;
-      out.push({ action: direction, nextState: { x: parsed.x, y: parsed.y } });
-    }
-    return out;
-  };
-}
-
-/** Canonicalizes a grid-position search state onto its cell alone — the
- *  only field that matters for movement dedup (mass/eaten-count ride
- *  elsewhere on the folded state, never on the path-search state itself). */
-export const spiderPathStateKey = (state) => cellId(state.x, state.y);
-
-/** Whether (x, y) is currently webbed — the static home zone (always active)
- *  OR a live spider-built web (mgx:web-built-at-turn + webDurationTurns >
- *  turn). The one predicate every eat precondition and the fly's movement
- *  gate consult, so the static zone and dynamic webs are ONE concept. `state`
- *  may be omitted (or carry no `webs` map) — the static-zone check alone
- *  still answers correctly, just blind to dynamic webs; every real caller
- *  threads the folded state through. `webDurationTurns` defaults to the
- *  shipped WEB_DURATION_TURNS; a caller holding a resolved game config passes
- *  its own webDurationTurns instead. */
-export function hasActiveWebAt(x, y, state, turn, webDurationTurns = WEB_DURATION_TURNS) {
-  if (isInWebBlock(x, y)) return true;
-  if (!state?.webs?.size) return false;
-  const target = cellId(x, y);
-  for (const { cell, builtAtTurn } of state.webs.values()) {
-    if (cell === target && builtAtTurn + webDurationTurns > turn) return true;
-  }
-  return false;
-}
-
-/** The spider's multi-step path: findActionPath wired with isGoal =
- *  "co-located with the believed fly cell" — mere co-location, not
- *  co-location-in-a-web. Catching a fly (the ecology pass's own catch step)
- *  never needs a web; only the SEPARATE eat step does, once a caught fly is
- *  actually carried into one (planSpiderPathToWeb's own job, run by the
- *  movement priority a carrying spider takes over next tick). Null when no
- *  believed target exists at all. `state`/`turn`/`webDurationTurns` are
- *  accepted for signature symmetry with planSpiderPathToWeb and every other
- *  caller in this file, but this function's own isGoal no longer reads
- *  them. */
-export function planSpiderPath(spiderCell, believedFlyCell, applyActions, state, turn, webDurationTurns = WEB_DURATION_TURNS) {
-  if (!believedFlyCell) return null;
-  const isGoal = (s) => s.x === believedFlyCell.x && s.y === believedFlyCell.y;
-  return findActionPath(spiderCell, isGoal, applyActions, { stateKey: spiderPathStateKey });
-}
-
-/** A carrying spider's own multi-step path home: findActionPath wired with
- *  isGoal = "any actively-webbed cell" (hasActiveWebAt, reused directly,
- *  unlike planSpiderPath there is no specific target cell — any live web
- *  will do). Used by the movement priority (below) for a spider already
- *  holding a fly: it races the fly to the nearest web rather than
- *  continuing to chase. Returns null when no active web is reachable at all
- *  (the caller falls back to greedySpiderApproach toward the static web's
- *  home cell). */
-export function planSpiderPathToWeb(spiderCell, applyActions, state, turn, webDurationTurns = WEB_DURATION_TURNS) {
-  const isGoal = (s) => hasActiveWebAt(s.x, s.y, state, turn, webDurationTurns);
-  return findActionPath(spiderCell, isGoal, applyActions, { stateKey: spiderPathStateKey });
-}
-
-// ---- one-ply greedy scoring, shared by the fly's evasion and the spider's
-// fallback chase (§5 confirmed decision: greedy distance-scoring over
-// findReachableSet's one-ply output, plus staying put — no lookahead, no
-// simulation of the other agent's plan). -------------------------------------
-
-function bestOneStepBy(fromCell, applyActions, scoreOf, isBetter) {
-  const options = [fromCell, ...findReachableSet(fromCell, applyActions, { maxDepth: 1 }).map((r) => r.node)];
-  let best = options[0];
-  let bestScore = scoreOf(best);
-  for (let i = 1; i < options.length; i += 1) {
-    const score = scoreOf(options[i]);
-    if (isBetter(score, bestScore)) { bestScore = score; best = options[i]; }
-  }
-  return best;
-}
-
-/** A fly with no believed spider position wanders instead of holding still:
- *  a seeded, uniform pick among staying put or any one-ply reachable cell,
- *  keyed on this turn + the fly's own id (purpose "wander") — deterministic
- *  and replayable, never Math.random. Looks random to a human watching. The
- *  caller is responsible for skipping this entirely when the fly sits in an
- *  active web this tick (a webbed fly can't move at all, wander or not). */
-export function randomFlyWander(flyCell, applyActions, turn, flyId) {
-  const options = [flyCell, ...findReachableSet(flyCell, applyActions, { maxDepth: 1 }).map((r) => r.node)];
-  return seededPick(options, `${WORLD_NAME}:${turn}:${flyId}:wander`);
-}
-
-/** The fly's one move this turn: score every one-ply reachable cell (plus
- *  staying put) by Chebyshev distance from the fly's believed spider
- *  position, move to the highest-scoring cell. A fly with no believed
- *  spider position wanders instead (randomFlyWander) — `turn`/`flyId` key
- *  that seeded draw. */
-export function greedyFlyMove(flyCell, believedSpiderCell, applyActions, turn, flyId) {
-  if (!believedSpiderCell) return randomFlyWander(flyCell, applyActions, turn, flyId);
-  return bestOneStepBy(
-    flyCell, applyActions,
-    (cell) => chebyshevDistance(cell.x, cell.y, believedSpiderCell.x, believedSpiderCell.y),
-    (score, bestScore) => score > bestScore,
-  );
-}
-
-/** The spider's fallback move when no in-web path exists yet (the fly's
- *  believed cell is outside the web, or currently unreachable): the same
- *  one-ply kernel as the fly's evasion, scored the opposite way — close
- *  distance instead of open it. */
-export function greedySpiderApproach(spiderCell, believedFlyCell, applyActions) {
-  if (!believedFlyCell) return spiderCell;
-  return bestOneStepBy(
-    spiderCell, applyActions,
-    (cell) => chebyshevDistance(cell.x, cell.y, believedFlyCell.x, believedFlyCell.y),
-    (score, bestScore) => score < bestScore,
-  );
-}
-
-/** A spider's move when another live spider is believed visible: the mirror
- *  image of greedyFlyMove's evasion — score every one-ply reachable cell
- *  (plus staying put) by Chebyshev distance from the other spider's believed
- *  position, move to the highest-scoring (furthest) cell. Priority branch 1
- *  of §5's avoid-spiders > chase-flies > hold-and-web ordering. */
-export function greedySpiderAvoid(spiderCell, believedOtherSpiderCell, applyActions) {
-  if (!believedOtherSpiderCell) return spiderCell;
-  return bestOneStepBy(
-    spiderCell, applyActions,
-    (cell) => chebyshevDistance(cell.x, cell.y, believedOtherSpiderCell.x, believedOtherSpiderCell.y),
-    (score, bestScore) => score > bestScore,
-  );
-}
-
-// ---- visibility and belief (§4): static grid topology is common knowledge
-// to both agents; only dynamic entity positions are gated by vision, in
-// domain/agent-belief.mjs (imported and re-exported above). A told fact —
-// shaped { subject, toAgent, cell, turn } — is the chat-integration channel
-// into it, defaulting to empty so belief with no chat is exactly "what's
-// currently visible." --------------------------------------------------------
-
-// ---- the ecology pass (§10): catch, eat, lay, hatch, spawn, starve, all as
-// ordinary turn-gated checks in one fixed-order pass. Order matters and is
-// fixed deliberately: catch first (a spider not yet carrying claims an
-// uncarried live fly it now shares a cell with, web or not), then eat (only
-// a carrying spider standing in an active web actually consumes its catch —
-// predation resolves on the turn's fresh positions), then starve (a fly
-// already claimed by an eat this turn cannot also starve), then lay (reads
-// the egg slot as it stood BEFORE this tick's own hatch, so a hatch and a
-// fresh lay never land the same turn), then hatch, then spawn (reads the
-// board as every earlier step in this same pass left it, so a fly never
-// spawns on a cell an eat/hatch just vacated or occupied). ------------------
-
-/**
- * One ecology pass over the tick's post-movement state: `postMovePlacements`
- * is a Map(subject -> {x,y}) for every currently-live spider and fly after
- * this turn's movement writes; `postMoveMassByFly`/`postMoveMassBySpider` are
- * Map(subject -> number), the mass after this turn's decrement, pre-removal
- * (`postMoveMassBySpider` is optional — a spider absent from it is simply
- * never starve-checked, so callers that don't track spider mass, e.g. older
- * tests, see no behavior change). `state` is the PRE-move fold (for history:
- * prior flies-eaten counts, prior carrying status, prior eggs, live webs).
- * `config` (default DEFAULT_GAME_CONFIG.spiderFly) supplies every tunable
- * this pass reads: the initial masses a fallback/hatch/spawn mints, the
- * egg-lay mass threshold, the hatch delay/count, the minimum hatchling mass,
- * the spawn interval, and the web duration the eat precondition checks
- * against.
- * Returns `{ writes, events }` — writes to append alongside the turn's
- * movement facts, events for the tick's own return payload. Pure.
- */
-export function runEcologyPass({
-  state, postMovePlacements, postMoveMassByFly, postMoveMassBySpider = new Map(), turn,
-  config = DEFAULT_GAME_CONFIG.spiderFly,
-}) {
-  const k = turn;
-  const writes = [];
-  const events = {
-    caught: [], eaten: [], starved: [], laid: null, hatched: [], spawned: null, spawnedCell: null,
-    massAfterEating: new Map(),
-  };
-
-  const spiders = [...postMovePlacements.keys()].filter((id) => /^spider-\d+$/.test(id)).sort();
-  const flies = [...postMovePlacements.keys()].filter((id) => /^fly-\d+$/.test(id)).sort();
-
-  // 1. Catch — a spider not already carrying a live fly claims the first
-  // uncarried live fly it shares a cell with this tick (web or not — the web
-  // only matters for the EAT step below). At most one catch per spider per
-  // tick. Starts from whatever every live spider was already carrying
-  // BEFORE this tick (state.carrying, filtered to a still-live captor and a
-  // still-live fly — a captor that died drops its stale carrying claim,
-  // freeing the fly to move independently again from the next tick on).
-  const carryingBySpider = new Map(); // spiderId -> flyId, this tick's working belief
-  for (const [spiderId, { flyId }] of state.carrying) {
-    if (postMovePlacements.has(spiderId) && postMovePlacements.has(flyId)) carryingBySpider.set(spiderId, flyId);
-  }
-  const carriedFlyIds = new Set(carryingBySpider.values());
-  for (const spiderId of spiders) {
-    if (carryingBySpider.has(spiderId)) continue;
-    const sCell = postMovePlacements.get(spiderId);
-    for (const flyId of flies) {
-      if (carriedFlyIds.has(flyId)) continue;
-      const fCell = postMovePlacements.get(flyId);
-      if (sCell.x !== fCell.x || sCell.y !== fCell.y) continue;
-      carryingBySpider.set(spiderId, flyId);
-      carriedFlyIds.add(flyId);
-      events.caught.push({ spider: spiderId, fly: flyId, cell: cellId(sCell.x, sCell.y) });
-      break;
-    }
-  }
-
-  // 2. Eat — a spider carrying a fly AND standing in an actively-webbed cell
-  // (static home zone or a live dynamic web) consumes it. The eating spider
-  // gains exactly the fly's post-decrement remaining mass, not a flat bonus.
-  const claimedFlies = new Set();
-  const eatenDeltaBySpider = new Map();
-  const eatenMassBySpider = new Map();
-  for (const spiderId of spiders) {
-    const flyId = carryingBySpider.get(spiderId);
-    if (!flyId) continue;
-    const sCell = postMovePlacements.get(spiderId);
-    if (!hasActiveWebAt(sCell.x, sCell.y, state, k, config.webDurationTurns)) continue;
-    carryingBySpider.delete(spiderId);
-    claimedFlies.add(flyId);
-    eatenDeltaBySpider.set(spiderId, (eatenDeltaBySpider.get(spiderId) ?? 0) + 1);
-    eatenMassBySpider.set(spiderId, (eatenMassBySpider.get(spiderId) ?? 0) + (postMoveMassByFly.get(flyId) ?? 0));
-    writes.push({ subject: `${flyId}@turn${k}`, predicate: "mgx:eaten-by", object: spiderId });
-    events.eaten.push({ fly: flyId, spider: spiderId, cell: cellId(sCell.x, sCell.y) });
-  }
-  for (const [spiderId, delta] of eatenDeltaBySpider) {
-    const newCount = (state.fliesEaten.get(spiderId)?.value ?? 0) + delta;
-    writes.push({ subject: `${spiderId}@turn${k}`, predicate: "mgx:flies-eaten", object: String(newCount) });
-    const priorSpiderMass = postMoveMassBySpider.get(spiderId) ?? (state.mass.get(spiderId)?.value ?? config.spiderInitialMass);
-    const newSpiderMass = priorSpiderMass + (eatenMassBySpider.get(spiderId) ?? 0);
-    writes.push({ subject: `${spiderId}@turn${k}`, predicate: "mgx:mass", object: String(newSpiderMass) });
-    events.massAfterEating.set(spiderId, newSpiderMass);
-  }
-
-  // 3. Starve — mass reached zero, and not already claimed by this turn's
-  // eat. Spiders waste away the same as flies; a spider that just ate
-  // survives regardless (eat resolves first). A carried-but-not-yet-eaten
-  // fly starves exactly like a free one — its captor's carrying claim is
-  // dropped below so the spider doesn't keep "holding" a dead fly.
-  for (const flyId of flies) {
-    if (claimedFlies.has(flyId)) continue;
-    if ((postMoveMassByFly.get(flyId) ?? 0) <= 0) {
-      writes.push({ subject: `${flyId}@turn${k}`, predicate: "mgx:starved", object: "true" });
-      events.starved.push(flyId);
-    }
-  }
-  const deadFliesThisTick = new Set([...claimedFlies, ...events.starved]);
-  for (const [spiderId, flyId] of carryingBySpider) {
-    if (events.starved.includes(flyId)) carryingBySpider.delete(spiderId);
-  }
-  for (const spiderId of spiders) {
-    if (eatenDeltaBySpider.has(spiderId)) continue;
-    if (!postMoveMassBySpider.has(spiderId)) continue;
-    if (postMoveMassBySpider.get(spiderId) <= 0) {
-      writes.push({ subject: `${spiderId}@turn${k}`, predicate: "mgx:starved", object: "true" });
-      events.starved.push(spiderId);
-    }
-  }
-
-  // Every live spider re-asserts its own mgx:carrying fact every tick (the
-  // same always-rewritten idiom mgx:currently-in/mgx:mass already use) — a
-  // merely-stopped write would leave a stale "carrying" row standing forever
-  // for the fold to keep honoring long after this tick's catch/eat actually
-  // changed it.
-  for (const spiderId of spiders) {
-    writes.push({ subject: `${spiderId}@turn${k}`, predicate: "mgx:carrying", object: carryingBySpider.get(spiderId) ?? "none" });
-  }
-
-  // 4. Lay — a spider's mass has reached the lay threshold AND it is
-  // standing in an active web, with no live egg outstanding right now. The
-  // laying spider resets to exactly its own initial mass; the surplus
-  // becomes the egg's own starting mass (an egg is never laid below the
-  // initial-mass reset, so the surplus is always >= 0).
-  const liveEggId = [...state.laidAtTurn.keys()].find((id) => !state.removed.has(id));
-  if (!liveEggId) {
-    for (const spiderId of spiders) {
-      const sCell = postMovePlacements.get(spiderId);
-      if (!hasActiveWebAt(sCell.x, sCell.y, state, k, config.webDurationTurns)) continue;
-      const spiderMass = eatenDeltaBySpider.has(spiderId)
-        ? events.massAfterEating.get(spiderId)
-        : (postMoveMassBySpider.get(spiderId) ?? state.mass.get(spiderId)?.value ?? config.spiderInitialMass);
-      if (spiderMass < config.eggLayMassThreshold) continue;
-      const eggMass = spiderMass - config.spiderInitialMass;
-      writes.push({ subject: `${spiderId}@turn${k}`, predicate: "mgx:mass", object: String(config.spiderInitialMass) });
-      const eggId = `egg-${1 + maxIdSuffix(state.placements.keys(), /^egg-(\d+)$/)}`;
-      const eggCellId = cellId(sCell.x, sCell.y);
-      writes.push({ subject: `${eggId}@turn${k}`, predicate: "mgx:currently-in", object: eggCellId });
-      writes.push({ subject: `${eggId}@turn${k}`, predicate: "mgx:laid-at-turn", object: String(k) });
-      writes.push({ subject: `${eggId}@turn${k}`, predicate: "mgx:mass", object: String(eggMass) });
-      events.laid = eggId;
-      break; // one-egg-at-a-time cap — the first qualifying spider lays it
-    }
-  }
-
-  // 5. Hatch — any live egg laid exactly config.eggHatchDelayTurns turns ago
-  // hatches into config.eggHatchCount spiders, capped by a floor on COUNT
-  // (never on hatch mass): actualHatchCount = max(1, min(eggHatchCount,
-  // floor(eggMass / minHatchlingMass))) — a too-small egg produces fewer,
-  // still-viable hatchlings rather than emaciated ones. The egg's mass
-  // splits evenly, remainder to the lowest-numbered hatchling.
-  const liveEggIds = [...state.laidAtTurn.keys()].filter((id) => !state.removed.has(id)).sort();
-  let nextSpiderNum = 1 + maxIdSuffix(state.placements.keys(), /^spider-(\d+)$/);
-  for (const eggId of liveEggIds) {
-    const laidTurn = state.laidAtTurn.get(eggId).value;
-    if (laidTurn + config.eggHatchDelayTurns !== k) continue;
-    const eggCell = state.placements.get(eggId)?.cell;
-    if (!eggCell) continue;
-    const eggMass = state.mass.get(eggId)?.value ?? config.spiderInitialMass;
-    const hatchCount = Math.max(1, Math.min(config.eggHatchCount, Math.floor(eggMass / config.minHatchlingMass)));
-    const share = Math.floor(eggMass / hatchCount);
-    const remainder = eggMass - share * hatchCount;
-    const hatchlings = [];
-    for (let i = 0; i < hatchCount; i += 1) {
-      const newSpiderId = `spider-${nextSpiderNum}`;
-      nextSpiderNum += 1;
-      const hatchlingMass = share + (i === 0 ? remainder : 0);
-      writes.push({ subject: `${newSpiderId}@turn${k}`, predicate: "mgx:currently-in", object: eggCell });
-      writes.push({ subject: `${newSpiderId}@turn${k}`, predicate: "mgx:mass", object: String(hatchlingMass) });
-      hatchlings.push({ spider: newSpiderId, mass: hatchlingMass });
-    }
-    writes.push({ subject: `${eggId}@turn${k}`, predicate: "mgx:hatched-into", object: hatchlings[0].spider });
-    events.hatched.push({ egg: eggId, cell: eggCell, spiders: hatchlings });
-  }
-
-  // 6. Spawn — every third turn, a new fly at a seeded pick among the
-  // currently-uncontested perimeter cells (never Math.random — see
-  // seededPick's own header comment).
-  if (k % config.flySpawnIntervalTurns === 0) {
-    const occupied = new Set();
-    for (const spiderId of spiders) { const c = postMovePlacements.get(spiderId); occupied.add(cellId(c.x, c.y)); }
-    for (const flyId of flies) {
-      if (deadFliesThisTick.has(flyId)) continue;
-      const c = postMovePlacements.get(flyId);
-      occupied.add(cellId(c.x, c.y));
-    }
-    for (const eggId of liveEggIds) {
-      if (events.hatched.some((h) => h.egg === eggId)) continue;
-      occupied.add(state.placements.get(eggId)?.cell);
-    }
-    for (const h of events.hatched) occupied.add(h.cell);
-    const uncontested = perimeterCells().filter((c) => !occupied.has(c));
-    if (uncontested.length) {
-      const newFlyId = `fly-${1 + maxIdSuffix(state.placements.keys(), /^fly-(\d+)$/)}`;
-      const cell = seededPick(uncontested, `${WORLD_NAME}:${k}:${newFlyId}:spawn`);
-      writes.push({ subject: `${newFlyId}@turn${k}`, predicate: "mgx:currently-in", object: cell });
-      writes.push({ subject: `${newFlyId}@turn${k}`, predicate: "mgx:mass", object: String(config.flyInitialMass) });
-      events.spawned = newFlyId;
-      events.spawnedCell = cell;
-    }
-  }
-
-  return { writes, events };
-}
-
-// ---- bootstrap and the per-tick orchestration --------------------------------
-
-/** Mints spider-1 at the web's home cell and a spread of flies onto the
- *  board perimeter — a fresh session's own starting state, never part of
- *  the shipped (reusable, static) world pack itself. A no-op when spider-1
- *  already exists (idempotent — safe to call from a caller unsure whether
- *  the game has already started). `config` (default
- *  DEFAULT_GAME_CONFIG.spiderFly) supplies the starting masses. Every minted
- *  agent also gets a starting mgx:feels mood (`calm` — nothing has a goal
- *  yet), so a mood fact exists for an individual from the moment the
- *  individual does. */
-export async function startSpiderFlyGame(memoryDir, { flyCount = 1, config = DEFAULT_GAME_CONFIG.spiderFly } = {}) {
-  const state = foldSpiderFlyState(readFactRows(await loadMemory(memoryDir)));
-  if (state.placements.has("spider-1")) return { started: false, facts: [] };
-
-  const perimeter = perimeterCells();
-  const facts = [
-    { subject: "spider-1", predicate: "mgx:currently-in", object: cellId(WEB_HOME.x, WEB_HOME.y) },
-    { subject: "spider-1", predicate: "mgx:mass", object: String(config.spiderInitialMass) },
-    { subject: "spider-1", predicate: "mgx:feels", object: "calm" },
-  ];
-  const occupied = new Set([cellId(WEB_HOME.x, WEB_HOME.y)]);
-  for (let i = 0; i < flyCount; i += 1) {
-    const flyId = `fly-${i + 1}`;
-    const uncontested = perimeter.filter((c) => !occupied.has(c));
-    const cell = seededPick(uncontested.length ? uncontested : perimeter, `${WORLD_NAME}:0:${flyId}:spawn`);
-    occupied.add(cell);
-    facts.push({ subject: flyId, predicate: "mgx:currently-in", object: cell });
-    facts.push({ subject: flyId, predicate: "mgx:mass", object: String(config.flyInitialMass) });
-    facts.push({ subject: flyId, predicate: "mgx:feels", object: "calm" });
-  }
-  await appendFacts(memoryDir, facts.map((f) => ({ ...f, provenance: worldProvenanceTag(WORLD_NAME) })));
-  return { started: true, facts };
-}
-
-// ---- the goal line and the mood word -----------------------------------------
-// Every branch of the tick's own priority chain assigns a `mood` word beside
-// the `goal` sentence it renders, and that word is appended as a real
-// mgx:feels fact for the turn (runSpiderFlyTick's moodWrites), the same
-// per-agent-per-turn treatment mgx:currently-in and mgx:mass already get.
-// Two reasons it is a fact rather than something a renderer re-derives. A
-// question about "a happy spider" has to bind against the store. And this
-// branch is the one that knows the mood, so recovering it downstream means
-// re-reading the prose this file already wrote.
-//
-// The words are a subset of sprite-expressions.mjs's own six-word
-// EXPRESSION_PALETTE (`sad` and `surprised` have no state in this game's goal
-// chain). Operator-confirmed mapping: a spider that just ate is happy; a
-// spider carrying a fly or mid-chase is angry (predatory focus); a spider
-// avoiding another spider is scared; a spider holding position or building a
-// web is calm. A fly evading a believed-visible spider is scared, and so is
-// the sharper form of the same fear — just caught, being carried, or trapped
-// in a web; a fly with nothing in sight is calm. `calm` is also the
-// no-strong-emotion baseline for an agent with no goal yet: freshly hatched,
-// freshly spawned, or re-evaluating because the agent its goal named died
-// this tick.
-
-function goalLineFor(subject, believed, arrived, kind) {
-  if (kind === "spider-carrying") return `carrying ${believed.subject} toward the web.`;
-  if (kind === "spider-carrying-delivered") return `carrying ${believed.subject} — already in the web, delivering it now.`;
-  if (kind === "spider-avoid") return `avoiding ${believed.subject}, last seen at ${cellId(believed.cell.x, believed.cell.y)}.`;
-  if (!believed) return kind === "spider" ? "no fly in sight — holding position in the web." : "no spider in sight — wandering.";
-  const seenAt = cellId(believed.cell.x, believed.cell.y);
-  if (kind === "spider") {
-    return arrived
-      ? `co-located with ${believed.subject} — catching it.`
-      : `chasing ${believed.subject}, last seen at ${seenAt}.`;
-  }
-  return `evading — last saw ${believed.subject} at ${seenAt}.`;
-}
-
-/** A one-step "plan" for a greedy or held move — the direction from
- *  `fromCell` to `toCell` as a length-1 array, or `[]` when the agent held
- *  still. Every agent's `plan` field is populated this way when its move
- *  came from one-ply greedy scoring or holding; a genuine multi-step search
- *  result (planSpiderPath/planSpiderPathToWeb) supplies its own full
- *  direction list instead — either way, `plan[0]` is always the direction
- *  actually taken this tick — the facing driver a renderer keys sprite
- *  orientation on. */
-function stepPlan(fromCell, toCell) {
-  const direction = oneStepDirectionBetween(fromCell, toCell);
-  return direction ? [direction] : [];
-}
-
-/** Live (unexpired, by `turn`) dynamic webs from a `Map(webId -> {cell,
- *  builtAtTurn})` (either a folded state's own `.webs`, or that widened with
- *  web(s) minted THIS tick before they've been written/read back), as a
- *  plain array of { id, cell, builtAtTurn, expiresAtTurn }. Excludes the
- *  always-on static home zone (that's WEB_HOME/WEB_RADIUS, drawn separately —
- *  this is only the spider-built kind), for a renderer to draw distinctly.
- *  `webDurationTurns` defaults to the shipped WEB_DURATION_TURNS; a caller
- *  holding a resolved game config passes its own webDurationTurns instead. */
-export function liveWebs(websMap, turn, webDurationTurns = WEB_DURATION_TURNS) {
-  const out = [];
-  for (const [id, { cell, builtAtTurn }] of websMap) {
-    if (builtAtTurn + webDurationTurns > turn) out.push({ id, cell, builtAtTurn, expiresAtTurn: builtAtTurn + webDurationTurns });
-  }
-  return out;
-}
-
-/**
- * One full tick: fold state, compute each live spider's and fly's belief,
- * replan/re-score, execute one movement step per agent (spiders: carrying-
- * not-yet-delivered > avoid other spiders > chase flies > hold-and-web;
- * flies: carried (inert) > evade > wander, unless trapped in an active web),
- * run the ecology pass, and append everything as this turn's @turnN facts in
- * one write. `opts.toldFacts` is the belief layer's chat-integration
- * extension point (§4) — an array of `{ subject, toAgent, cell, turn }`
- * rows, empty until a later piece of work wires chat-told positions through
- * it.
- *
- * Returns `{ turn, writes, agents, ecology, activeWebs }`: `agents` is keyed
- * by every live spider/fly subject after this tick, each `{ cell, goal, mood,
- * plan, mass, belief }` — `mood` is the branch's own mood word (see the goal
- * line and mood word section above), also appended as this turn's mgx:feels
- * fact, so a renderer reads the structured word rather than parsing `goal`
- * back apart; `plan` is the direction sequence that produced
- * THIS tick's move (a full multi-step search result when one was found,
- * else a length-1 array for a single greedy step, else `[]` when the agent
- * held still — `plan[0]` is always the direction actually taken, the facing
- * driver a renderer keys sprite orientation on); `belief` is
- * `{ [otherAgentId]: cellId | null }`,
- * this agent's own believed position for every other live agent (never
- * ground truth — see beliefSnapshotFor). `ecology` is the tick's own
- * caught/eaten/starved/laid/hatched/spawned event summary; `activeWebs` is
- * every currently-live dynamic web (static home zone excluded — that's
- * fixed grid geometry, not runtime state), for a renderer to draw
- * distinctly.
- *
- * `opts.config` (default DEFAULT_GAME_CONFIG.spiderFly) supplies every
- * tunable this tick reads: each class's own vision radius, both agents'
- * starting/decrement masses, and the web duration, and is forwarded
- * unchanged into runEcologyPass.
- */
-export async function runSpiderFlyTick(memoryDir, opts = {}) {
-  const { toldFacts = [], config = DEFAULT_GAME_CONFIG.spiderFly } = opts;
-  const rows = readFactRows(await loadMemory(memoryDir));
-  const state = foldSpiderFlyState(rows);
-  const k = state.turnCount + 1;
-  const applyActions = gridApplyActions(rows);
-
-  const spiders = sortedLiveSubjects(state, /^spider-\d+$/);
-  const flies = sortedLiveSubjects(state, /^fly-\d+$/);
-
-  const movementWrites = [];
-  const postMovePlacements = new Map();
-  const postMoveMassByFly = new Map();
-  const postMoveMassBySpider = new Map();
-  const agents = {};
-  const tickWebs = new Map(state.webs); // widened in place as spiders build/refresh this tick
-  let nextWebNum = 1 + maxIdSuffix(state.webs.keys(), /^web-(\d+)$/);
-
-  for (const spiderId of spiders) {
-    const spiderCell = parseCellId(state.placements.get(spiderId).cell);
-    const priorMass = state.mass.get(spiderId)?.value ?? config.spiderInitialMass;
-    const newMass = Math.max(0, priorMass - config.spiderMassDecrementPerTurn);
-    postMoveMassBySpider.set(spiderId, newMass);
-
-    const otherSpiders = spiders.filter((id) => id !== spiderId);
-    const belief = beliefSnapshotFor(spiderId, spiderCell, [...otherSpiders, ...flies], state, { visionRadius: config.spiderVisionRadius, toldFacts });
-
-    // Priority 0: carrying a fly, above everything else — a
-    // carrying spider never drops its catch to avoid another spider or
-    // chase a second one (no spider-eats-spider mechanic exists anywhere in
-    // this engine, so "avoid" is resource contention, not survival, and
-    // dropping/abandoning the catch would undermine the whole mass-economy
-    // goal chain). Not yet delivered: race the shortest path to any active
-    // web (planSpiderPathToWeb), falling back to a greedy approach toward
-    // the static web's home cell when no path is found. Already delivered
-    // (already standing in an active web): hold still rather than run the
-    // ordinary priority chain, so the ecology pass's own eat gate (which
-    // reads this SAME post-move position) reliably resolves the delivery
-    // this exact tick instead of risking the spider wandering back out
-    // first.
-    const carriedFlyId = state.carrying.get(spiderId)?.flyId;
-    const isCarrying = Boolean(carriedFlyId) && !state.removed.has(carriedFlyId);
-    const alreadyDelivered = isCarrying && hasActiveWebAt(spiderCell.x, spiderCell.y, state, k, config.webDurationTurns);
-
-    let nextCell;
-    let plan;
-    let goal;
-    let mood;
-    if (isCarrying && alreadyDelivered) {
-      nextCell = spiderCell;
-      plan = [];
-      goal = goalLineFor(spiderId, { subject: carriedFlyId }, false, "spider-carrying-delivered");
-      mood = "angry";
-    } else if (isCarrying) {
-      const path = planSpiderPathToWeb(spiderCell, applyActions, state, k, config.webDurationTurns);
-      if (path && path.actions.length) { nextCell = path.states[1]; plan = path.actions; }
-      else { nextCell = greedySpiderApproach(spiderCell, WEB_HOME, applyActions); plan = stepPlan(spiderCell, nextCell); }
-      goal = goalLineFor(spiderId, { subject: carriedFlyId }, false, "spider-carrying");
-      mood = "angry";
-    } else {
-      // Priority 1: avoid any OTHER live spider believed visible.
-      const avoidTarget = nearestBelievedTarget(spiderId, spiderCell, otherSpiders, state, { visionRadius: config.spiderVisionRadius, toldFacts });
-      if (avoidTarget) {
-        nextCell = greedySpiderAvoid(spiderCell, avoidTarget.cell, applyActions);
-        plan = stepPlan(spiderCell, nextCell);
-        goal = goalLineFor(spiderId, avoidTarget, false, "spider-avoid");
-        mood = "scared";
-      } else {
-        // Priority 2: chase a believed-visible fly, exactly as before.
-        const target = nearestBelievedTarget(spiderId, spiderCell, flies, state, { visionRadius: config.spiderVisionRadius, toldFacts });
-        if (target) {
-          nextCell = spiderCell;
-          const path = planSpiderPath(spiderCell, target.cell, applyActions, state, k, config.webDurationTurns);
-          if (path) {
-            if (path.actions.length) { nextCell = path.states[1]; plan = path.actions; }
-            else plan = [];
-          } else {
-            nextCell = greedySpiderApproach(spiderCell, target.cell, applyActions);
-            plan = stepPlan(spiderCell, nextCell);
-          }
-          // "Arrived" is the real catch precondition (co-located with the
-          // believed target — a catch never needs a web, only the SEPARATE
-          // eat step that follows once it's carried into one) — NOT merely
-          // "didn't move this turn", which a greedy-approach spider also
-          // does whenever it's already at its closest reachable cell but
-          // still a step away (Chebyshev-adjacent isn't co-located;
-          // has-exit-* edges have no diagonal hop).
-          const arrived = nextCell.x === target.cell.x && nextCell.y === target.cell.y;
-          goal = goalLineFor(spiderId, target, arrived, "spider");
-          mood = "angry";
-        } else {
-          // Priority 3: hold position, and build/refresh a web there unless an
-          // unexpired web already covers this exact cell.
-          nextCell = spiderCell;
-          plan = [];
-          mood = "calm";
-          const heldCellId = cellId(spiderCell.x, spiderCell.y);
-          if (!hasActiveWebAt(spiderCell.x, spiderCell.y, state, k, config.webDurationTurns)) {
-            const webId = `web-${nextWebNum}`;
-            nextWebNum += 1;
-            tickWebs.set(webId, { cell: heldCellId, builtAtTurn: k });
-            movementWrites.push({ subject: `${webId}@turn${k}`, predicate: "mgx:currently-in", object: heldCellId });
-            movementWrites.push({ subject: `${webId}@turn${k}`, predicate: "mgx:web-built-at-turn", object: String(k) });
-            goal = "no fly in sight — building a web here.";
-          } else {
-            goal = goalLineFor(spiderId, null, false, "spider");
-          }
-        }
-      }
-    }
-
-    postMovePlacements.set(spiderId, nextCell);
-    movementWrites.push({ subject: `${spiderId}@turn${k}`, predicate: "mgx:currently-in", object: cellId(nextCell.x, nextCell.y) });
-    movementWrites.push({ subject: `${spiderId}@turn${k}`, predicate: "mgx:mass", object: String(newMass) });
-    agents[spiderId] = { cell: cellId(nextCell.x, nextCell.y), goal, mood, plan, mass: newMass, belief };
-  }
-
-  // A fly currently carried by a still-live spider (state.carrying, keyed by
-  // captor) rides that captor's own just-chosen cell instead of scoring its
-  // own move — fully inert, but its mass still decrements and it can still
-  // starve mid-transit below (an intended emergent failure mode). A captor
-  // that died since being folded self-heals the fly to independent movement
-  // for free: it's simply absent from this map (state.removed.has(spiderId)
-  // was never true for a captor still in `spiders`, so only a captor gone
-  // BEFORE this tick's fold — already excluded from `spiders` — is missing).
-  const captorOfFly = new Map();
-  for (const [spiderId, { flyId }] of state.carrying) {
-    if (spiders.includes(spiderId) && flies.includes(flyId)) captorOfFly.set(flyId, spiderId);
-  }
-
-  for (const flyId of flies) {
-    const flyCell = parseCellId(state.placements.get(flyId).cell);
-    const captorId = captorOfFly.get(flyId);
-    let nextCell;
-    let plan;
-    let goal;
-    let mood;
-    if (captorId) {
-      nextCell = postMovePlacements.get(captorId);
-      plan = [];
-      goal = `being carried by ${captorId}.`;
-      mood = "scared";
-    } else {
-      const believedSpider = nearestBelievedTarget(flyId, flyCell, spiders, state, { visionRadius: config.flyVisionRadius, toldFacts });
-      const webbed = hasActiveWebAt(flyCell.x, flyCell.y, state, k, config.webDurationTurns);
-      if (webbed) {
-        nextCell = flyCell;
-        plan = [];
-        goal = "trapped in an active web — can't move.";
-        mood = "scared";
-      } else {
-        nextCell = greedyFlyMove(flyCell, believedSpider?.cell ?? null, applyActions, k, flyId);
-        plan = stepPlan(flyCell, nextCell);
-        goal = goalLineFor(flyId, believedSpider, true, "fly");
-        mood = believedSpider ? "scared" : "calm";
-      }
-    }
-    const belief = beliefSnapshotFor(flyId, captorId ? nextCell : flyCell, [...spiders, ...flies.filter((id) => id !== flyId)], state, { visionRadius: config.flyVisionRadius, toldFacts });
-
-    postMovePlacements.set(flyId, nextCell);
-    movementWrites.push({ subject: `${flyId}@turn${k}`, predicate: "mgx:currently-in", object: cellId(nextCell.x, nextCell.y) });
-    const priorMass = state.mass.get(flyId)?.value ?? config.flyInitialMass;
-    const newMass = Math.max(0, priorMass - config.flyMassDecrementPerTurn);
-    postMoveMassByFly.set(flyId, newMass);
-    movementWrites.push({ subject: `${flyId}@turn${k}`, predicate: "mgx:mass", object: String(newMass) });
-    agents[flyId] = { cell: cellId(nextCell.x, nextCell.y), goal, mood, plan, mass: newMass, belief };
-  }
-
-  const ecology = runEcologyPass({ state, postMovePlacements, postMoveMassByFly, postMoveMassBySpider, turn: k, config });
-  // Every agent's goal was assigned during movement, before this same tick's
-  // ecology pass resolves eating/starving — so a THIRD agent's goal can name
-  // a subject that dies in this exact tick just as easily as the dying
-  // subject's own goal can (a fly's "evading — last saw spider-1 ..." is
-  // just as stale as spider-1's own entry once spider-1 starves this tick).
-  // Scrub every remaining agent's goal of a died-this-tick reference BEFORE
-  // the specific eaten-pair handling below, so that handling's own nicer
-  // "just ate X" message (set second) always wins for the eating spider,
-  // whose pre-scrub goal also names its prey. `(?!\d)` keeps "fly-1" from
-  // false-matching inside "fly-10".
-  const diedThisTick = [...ecology.events.eaten.map((e) => e.fly), ...ecology.events.starved];
-  for (const id of Object.keys(agents)) {
-    for (const deadId of diedThisTick) {
-      if (new RegExp(`${deadId}(?!\\d)`).test(agents[id].goal)) {
-        agents[id].goal = `${deadId} is gone — re-evaluating.`;
-        agents[id].mood = "calm";
-        break;
-      }
-    }
-  }
-  // A fly eaten or starved THIS tick was already assigned a pre-ecology
-  // goal/position above (movement runs before the ecology pass resolves
-  // eating) — left as-is, the same response would both announce "fly-5 was
-  // eaten" and still list fly-5's stale "trapped, can't move" goal one clause
-  // later, as if it were still on the board. Drop it from `agents` (its own
-  // goal is moot) and let the eating spider's line say what actually
-  // happened instead of the now-false "co-located with fly-5 — catching it".
-  // A spider can eat more than one fly in the same tick (several flies
-  // co-located with it on the same cell) — group by spider first, rather
-  // than overwriting the goal once per eaten fly, which silently credited
-  // only the LAST one and dropped every earlier fly from the summary line
-  // (the "Turn N — ..." event text already lists every eaten fly correctly;
-  // only this goal-line summary was collapsing them).
-  const eatenBySpider = new Map();
-  for (const { fly, spider } of ecology.events.eaten) {
-    delete agents[fly];
-    if (!eatenBySpider.has(spider)) eatenBySpider.set(spider, []);
-    eatenBySpider.get(spider).push(fly);
-  }
-  for (const [spider, flyIds] of eatenBySpider) {
-    if (agents[spider]) {
-      agents[spider].goal = `just ate ${flyIds.join(" and ")} in the web.`;
-      agents[spider].mood = "happy";
-      agents[spider].mass = ecology.events.massAfterEating.get(spider) ?? agents[spider].mass;
-    }
-  }
-  for (const flyId of ecology.events.starved) delete agents[flyId];
-  // A fresh catch that wasn't ALSO delivered+eaten this same tick (the
-  // "just ate" override above already wins for that case) leaves both the
-  // spider's and the fly's pre-ecology goal stale (assigned during movement,
-  // before the catch resolved) — the spider's own chase/hold text and the
-  // fly's own evade/wander text neither one mentions the catch.
-  for (const { spider, fly } of ecology.events.caught) {
-    if (eatenBySpider.has(spider)) continue;
-    if (agents[spider]) {
-      agents[spider].goal = goalLineFor(spider, { subject: fly }, false, "spider-carrying");
-      agents[spider].mood = "angry";
-    }
-    if (agents[fly]) {
-      agents[fly].goal = `just caught by ${spider} — being carried.`;
-      agents[fly].mood = "scared";
-    }
-  }
-  // A hatched spider or a spawned fly is minted by the ecology pass, which
-  // runs AFTER the movement loops above already built `agents` from the
-  // pre-tick roster — so without this, a brand-new individual is absent from
-  // this tick's own returned agents (and so invisible on the board/HUD) even
-  // though the very same tick's event text already announces it, only
-  // catching up the following tick once the fold picks it up naturally. One
-  // egg can hatch into more than one spider — every hatchling gets its own
-  // agents[] entry, sharing the egg's own cell.
-  for (const h of ecology.events.hatched) {
-    for (const { spider, mass } of h.spiders) {
-      agents[spider] = { cell: h.cell, goal: "just hatched — no goal yet.", mood: "calm", plan: [], mass, belief: {} };
-    }
-  }
-  if (ecology.events.spawned && ecology.events.spawnedCell) {
-    agents[ecology.events.spawned] = { cell: ecology.events.spawnedCell, goal: "just arrived — no goal yet.", mood: "calm", plan: [], mass: config.flyInitialMass, belief: {} };
-  }
-  // Each remaining agent's mood goes on record as this turn's own mgx:feels
-  // fact, exactly the way its mgx:currently-in placement did. Built here,
-  // after the ecology pass, so the fact carries the mood the tick ENDED on
-  // (a spider that just ate is happy, not still angry mid-chase) and covers
-  // the hatchlings and the spawned fly the ecology pass just minted. An
-  // agent eaten or starved this tick is already out of `agents`, so nothing
-  // records a mood for it.
-  const moodWrites = Object.entries(agents)
-    .filter(([, agent]) => agent.mood)
-    .map(([id, agent]) => ({ subject: `${id}@turn${k}`, predicate: "mgx:feels", object: agent.mood }));
-  const writes = [...movementWrites, ...ecology.writes, ...moodWrites];
-  const provenance = `${worldProvenanceTag(WORLD_NAME)}:turn${k}`;
-  await appendFacts(memoryDir, writes.map((f) => ({ ...f, provenance })));
-
-  return { turn: k, writes, agents, ecology: ecology.events, activeWebs: liveWebs(tickWebs, k, config.webDurationTurns) };
-}