@polycode-projects/the-mechanical-code-talker 2.7.23 → 2.7.25

package/src/services/spider-fly-turn.mjs

@@ -22,6 +22,7 @@ import { foldSpiderFlyState, runSpiderFlyTick, startSpiderFlyGame } from "./spid
 import { worldProvenanceTag } from "../domain/worlds-pack.mjs";
 import { getWorldsPackProvider } from "../adapters/corpus/worlds-pack.mjs";
 import { appendFacts, appendRule, loadMemory, readFactRows } from "../adapters/memory/core.mjs";
+import { DEFAULT_GAME_CONFIG } from "../domain/game-config.mjs";
 
 // ---- recognizers: the closed opening/stop/tick/address set -------------------
 
@@ -70,7 +71,7 @@ const WORLD_OPENING_FALLBACK =
 
 // ---- the opening turn: load the shipped board through the worlds pack -------
 
-async function openSpiderFlyGame({ planHolder, memoryDir, env, cache }) {
+async function openSpiderFlyGame({ planHolder, memoryDir, env, cache, gameConfig = DEFAULT_GAME_CONFIG }) {
   if (!memoryDir) {
     return {
       text: "the spider-and-fly game needs a session with a memory store to hold the board — start tmct inside a repo first.",
@@ -99,7 +100,7 @@ async function openSpiderFlyGame({ planHolder, memoryDir, env, cache }) {
   }
   if (cache) cache.rows = null; // the fact-rows cache predates these writes
 
-  const { started } = await startSpiderFlyGame(memoryDir, { flyCount: 1 });
+  const { started } = await startSpiderFlyGame(memoryDir, { flyCount: 1, config: gameConfig?.spiderFly });
   planHolder.state = { spiderFly: { turn: 0 } };
   const opener = started
     ? (payload.meta?.opening || WORLD_OPENING_FALLBACK)
@@ -212,8 +213,8 @@ function describeEcologyNote(eco) {
   return bits.length ? `; ${bits.join(", ")}` : "";
 }
 
-async function runTickAndRender({ planHolder, memoryDir, cache, toldFacts = [], addressedNote = null }) {
-  const tick = await runSpiderFlyTick(memoryDir, { toldFacts });
+async function runTickAndRender({ planHolder, memoryDir, cache, toldFacts = [], addressedNote = null, gameConfig = DEFAULT_GAME_CONFIG }) {
+  const tick = await runSpiderFlyTick(memoryDir, { toldFacts, config: gameConfig?.spiderFly });
   if (cache) cache.rows = null;
   planHolder.state = { spiderFly: { turn: tick.turn } };
   return {
@@ -232,7 +233,7 @@ async function runTickAndRender({ planHolder, memoryDir, cache, toldFacts = [],
  *  current turn's told-facts"). This also matches how runSpiderFlyTick
  *  itself already works: it holds no standing plan or belief between calls,
  *  recomputing everything fresh from the folded fact rows every tick. */
-async function runToldFactTurn(match, { planHolder, memoryDir, cache }) {
+async function runToldFactTurn(match, { planHolder, memoryDir, cache, gameConfig = DEFAULT_GAME_CONFIG }) {
   const [, addrKindRaw, addrNum, subjKindRaw, subjNum, direction, cellLiteral] = match;
   const addrKind = addrKindRaw.toLowerCase();
   const subjKind = subjKindRaw.toLowerCase();
@@ -258,7 +259,7 @@ async function runToldFactTurn(match, { planHolder, memoryDir, cache }) {
   const targetCellId = cellId(targetCell.x, targetCell.y);
   const toldFacts = [{ subject: subjectId, toAgent: addresseeId, cell: targetCellId, turn: state.turnCount + 1 }];
   return runTickAndRender({
-    planHolder, memoryDir, cache, toldFacts,
+    planHolder, memoryDir, cache, toldFacts, gameConfig,
     addressedNote: `told the ${addresseeId} the ${subjectId} is at ${targetCellId}`,
   });
 }
@@ -275,7 +276,7 @@ async function runToldFactTurn(match, { planHolder, memoryDir, cache }) {
  * ordinary lanes unchanged, board untouched (§6.2 — no special-cased
  * spider-fly code path for plain questions).
  */
-export async function spiderFlyTurn(line, { planHolder, memoryDir, env, cache = null, isPlanFrameLine = () => false }) {
+export async function spiderFlyTurn(line, { planHolder, memoryDir, env, cache = null, isPlanFrameLine = () => false, gameConfig = DEFAULT_GAME_CONFIG }) {
   const slot = planHolder?.state ?? null;
   const spiderFly = slot?.spiderFly ?? null;
   const opening = SPIDER_FLY_OPEN_RE.test(line);
@@ -305,7 +306,7 @@ export async function spiderFlyTurn(line, { planHolder, memoryDir, env, cache =
         note: "SPIDER-FLY — an opening arrived while a plan frame is active; the slot holds one thing at a time",
       };
     }
-    return openSpiderFlyGame({ planHolder, memoryDir, env, cache });
+    return openSpiderFlyGame({ planHolder, memoryDir, env, cache, gameConfig });
   }
 
   // A game is live.
@@ -343,11 +344,11 @@ export async function spiderFlyTurn(line, { planHolder, memoryDir, env, cache =
         miss: true,
       };
     }
-    return runToldFactTurn(told, { planHolder, memoryDir, cache });
+    return runToldFactTurn(told, { planHolder, memoryDir, cache, gameConfig });
   }
 
   if (SPIDER_FLY_TICK_RE.test(line)) {
-    return runTickAndRender({ planHolder, memoryDir, cache, toldFacts: [] });
+    return runTickAndRender({ planHolder, memoryDir, cache, toldFacts: [], gameConfig });
   }
 
   return null; // an unaddressed aside — the ordinary lanes answer, board untouched

package/src/services/spider-fly-viz.mjs

@@ -96,13 +96,18 @@ export function threadCellsForSpiderPlan(agents, geometry) {
 }
 
 /** The self-contained spider-and-fly page. Pure — the same output for the
- *  same `title` every time; every other piece of state this page shows is
- *  computed live in the browser once the sibling bundle loads. `?preview=1`
- *  on the page's own URL switches it into the small, auto-playing,
- *  non-interactive mode the home page's hero iframe embeds (§11) — one file
- *  serves both the hero and the "open full-screen" link, matching how
- *  ledger.html/plan.html are each one file embedded two ways. */
-export function renderSpiderFlyHtml({ title = DEFAULT_TITLE } = {}) {
+ *  same `title`/`spriteTemplates` every time; every other piece of state
+ *  this page shows is computed live in the browser once the sibling bundle
+ *  loads. `spriteTemplates` is the build step's own read of
+ *  data/sprites/*.toml (sprite-template-files.mjs), embedded as page data
+ *  the same reason adventure-viz.mjs's own worldPayload is — the browser
+ *  bundle stays fs-free. Defaults to `[]` (every agent falls back to the
+ *  flat SPRITE_REGISTRY, unchanged from before this module existed).
+ *  `?preview=1` on the page's own URL switches it into the small, auto-
+ *  playing, non-interactive mode the home page's hero iframe embeds (§11) —
+ *  one file serves both the hero and the "open full-screen" link, matching
+ *  how ledger.html/plan.html are each one file embedded two ways. */
+export function renderSpiderFlyHtml({ title = DEFAULT_TITLE, spriteTemplates = [] } = {}) {
   const gridData = embedJson({
     gridSize: GRID_SIZE,
     webCells: webCellIds(),
@@ -114,6 +119,7 @@ export function renderSpiderFlyHtml({ title = DEFAULT_TITLE } = {}) {
     tickWaitMs: TICK_WAIT_MS,
     maxFlyMass: FLY_INITIAL_MASS,
     maxSpiderMass: SPIDER_INITIAL_MASS,
+    spriteTemplates,
   });
 
   return `<!doctype html>
@@ -171,6 +177,11 @@ ${THEME_TOKENS_CSS}
   .chatask .prompt { color: var(--taught); font-size: .78rem; font-family: ${MONO_STACK}; }
   .chatask input { flex: 1; font-family: ${MONO_STACK}; font-size: .78rem; background: var(--bg); color: var(--ink); border: 1px solid var(--line); padding: .32rem .55rem; min-width: 0; }
   .chatask input:disabled { opacity: .5; }
+  .chatpills { display: flex; flex-wrap: wrap; gap: .3rem; margin-top: .5rem; }
+  .pill { font-family: ${MONO_STACK}; font-size: .68rem; padding: .2rem .6rem; border: 1px solid var(--line); border-radius: 99px; background: var(--bg); color: var(--ink); white-space: nowrap; }
+  .pill:hover:not(:disabled) { border-color: var(--taught); }
+  .pill:disabled { opacity: .45; cursor: default; }
+  .pill[data-role="addr"].active { border-color: var(--taught); color: var(--taught); }
   .controls-row { display: flex; align-items: center; gap: .6rem; margin-top: 1rem; flex-wrap: wrap; }
   .controls-row button { font-family: ${MONO_STACK}; font-size: .78rem; padding: .3rem .7rem; border: 1px solid var(--line); background: var(--card); color: var(--ink); }
   .controls-row button:hover:not(:disabled) { border-color: var(--taught); }
@@ -206,6 +217,14 @@ ${THEME_TOKENS_CSS}
           <span class="prompt mono">tmct&gt;</span>
           <input id="chatq" type="text" placeholder="@spider the fly is east" aria-label="Address the spider or the fly" disabled>
         </form>
+        <div class="chatpills" id="chatpills" role="group" aria-label="quick phrases to fill the chat input">
+          <button type="button" class="pill" data-role="addr" data-addressee="spider" disabled>@spider</button>
+          <button type="button" class="pill" data-role="addr" data-addressee="fly" disabled>@fly</button>
+          <button type="button" class="pill" data-role="dir" data-direction="north" disabled>the fly is north</button>
+          <button type="button" class="pill" data-role="dir" data-direction="south" disabled>the fly is south</button>
+          <button type="button" class="pill" data-role="dir" data-direction="east" disabled>the fly is east</button>
+          <button type="button" class="pill" data-role="dir" data-direction="west" disabled>the fly is west</button>
+        </div>
       </div>
     </aside>
   </div>
@@ -238,6 +257,9 @@ const SPIDERFLY = ${gridData};
   const chatlogEl = el("chatlog");
   const chatformEl = el("chatform");
   const chatqEl = el("chatq");
+  const chatpillsEl = el("chatpills");
+  const addressPillEls = [...chatpillsEl.querySelectorAll('[data-role="addr"]')];
+  const directionPillEls = [...chatpillsEl.querySelectorAll('[data-role="dir"]')];
   const statusEl = el("status");
   const turnLabelEl = el("turnLabel");
   const resetBtn = el("resetBtn");
@@ -298,8 +320,14 @@ const SPIDERFLY = ${gridData};
     node = document.createElement("div");
     node.className = "sprite";
     node.dataset.cls = cls;
+    // Property-aware resolution (sprite-templates.mjs's resolveSpriteAsset):
+    // no agent here carries an mgx:hasProperty fact today, so propertyFacts
+    // stays empty and every agent resolves through its plain class template
+    // (or the flat SPRITE_REGISTRY, for a class with none) — the same output
+    // as before this module existed, just wired for the day an agent does
+    // carry one.
     const sprite = window.tmctSpiderFly
-      ? tmctSpiderFly.resolveSpriteForClass(cls, (session && session.taxonomyRows) || [], tmctSpiderFly.SPRITE_REGISTRY)
+      ? tmctSpiderFly.resolveSpriteAsset(cls, (session && session.taxonomyRows) || [], [], SPIDERFLY.spriteTemplates, tmctSpiderFly.SPRITE_REGISTRY)
       : "";
     node.innerHTML = sprite;
     if (!preview) {
@@ -465,6 +493,42 @@ const SPIDERFLY = ${gridData};
     });
   });
 
+  // ---- chat pills: click-to-fill shortcuts over the SAME #chatq input, never
+  // a second path into the engine — a pill only ever sets/appends text and
+  // focuses the field, exactly what typing the same characters would do, so
+  // free typing keeps working unchanged and every resulting phrase is one the
+  // addressed teach-frame grammar (SPIDER_FLY_TOLD_RE in spider-fly-turn.mjs)
+  // genuinely accepts.
+  function addresseeKindOf(value) {
+    const m = /^@(spider|fly)(?:-\\d+)?\\b/i.exec(String(value).trim());
+    return m ? m[1].toLowerCase() : null;
+  }
+  function refreshPills() {
+    const explicitKind = addresseeKindOf(chatqEl.value);
+    const subject = (explicitKind || "spider") === "spider" ? "fly" : "spider";
+    for (const btn of directionPillEls) btn.textContent = "the " + subject + " is " + btn.dataset.direction;
+    for (const btn of addressPillEls) btn.classList.toggle("active", btn.dataset.addressee === explicitKind);
+  }
+  for (const btn of addressPillEls) {
+    btn.addEventListener("click", () => {
+      chatqEl.value = "@" + btn.dataset.addressee + " ";
+      refreshPills();
+      chatqEl.focus();
+    });
+  }
+  for (const btn of directionPillEls) {
+    btn.addEventListener("click", () => {
+      const kind = addresseeKindOf(chatqEl.value) || "spider";
+      let value = chatqEl.value;
+      if (!addresseeKindOf(value)) value = "@" + kind + " " + value.trimStart();
+      chatqEl.value = value.replace(/\\s+$/, "") + " " + btn.textContent;
+      refreshPills();
+      chatqEl.focus();
+    });
+  }
+  chatqEl.addEventListener("input", refreshPills);
+  refreshPills();
+
   // ---- serialize every engine-touching call: the ticker and the chat dock
   // share one in-memory store, and an overlapping tick()/turn() pair could
   // race against the same @turnN write.
@@ -481,6 +545,7 @@ const SPIDERFLY = ${gridData};
     statusEl.textContent = session.opening;
     chatqEl.disabled = false;
     resetBtn.disabled = false; playBtn.disabled = false; stepBtn.disabled = false;
+    for (const btn of [...addressPillEls, ...directionPillEls]) btn.disabled = false;
   }
 
   let loopScheduled = false;

package/src/services/spider-fly.mjs

@@ -19,6 +19,7 @@ import { appendFacts, loadMemory, readFactRows } from "../adapters/memory/core.m
 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) -------------
@@ -187,18 +188,20 @@ export function gridApplyActions(factRows) {
 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 + WEB_DURATION_TURNS >
+ *  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. */
-export function hasActiveWebAt(x, y, state, turn) {
+ *  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 + WEB_DURATION_TURNS > turn) return true;
+    if (cell === target && builtAtTurn + webDurationTurns > turn) return true;
   }
   return false;
 }
@@ -210,11 +213,12 @@ export function hasActiveWebAt(x, y, state, turn) {
  *  only on the fixed target), so this returns null — an honest "no path to
  *  an eat" rather than a path toward a cell that would never satisfy the eat
  *  condition. Null also covers "no believed target at all." `state`/`turn`
- *  are optional, defaulting to "static web zone only" (see hasActiveWebAt). */
-export function planSpiderPath(spiderCell, believedFlyCell, applyActions, state, turn) {
+ *  are optional, defaulting to "static web zone only" (see hasActiveWebAt).
+ *  `webDurationTurns` forwards to hasActiveWebAt unchanged. */
+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 && hasActiveWebAt(s.x, s.y, state, turn);
+    s.x === believedFlyCell.x && s.y === believedFlyCell.y && hasActiveWebAt(s.x, s.y, state, turn, webDurationTurns);
   return findActionPath(spiderCell, isGoal, applyActions, { stateKey: spiderPathStateKey });
 }
 
@@ -362,10 +366,17 @@ function mostRecentEaterSpider(state, eatenDeltaBySpider) {
  * 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 eggs, prior eaten turns, live webs).
+ * `config` (default DEFAULT_GAME_CONFIG.spiderFly) supplies every tunable
+ * this pass reads: the initial masses a fallback/hatch/spawn mints, the
+ * eggs-eaten lay threshold, the hatch delay, 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 }) {
+export function runEcologyPass({
+  state, postMovePlacements, postMoveMassByFly, postMoveMassBySpider = new Map(), turn,
+  config = DEFAULT_GAME_CONFIG.spiderFly,
+}) {
   const k = turn;
   const writes = [];
   const events = { eaten: [], starved: [], laid: null, hatched: [], spawned: null, spawnedCell: null, massAfterEating: new Map() };
@@ -381,7 +392,7 @@ export function runEcologyPass({ state, postMovePlacements, postMoveMassByFly, p
   const eatenMassBySpider = new Map();
   for (const spiderId of spiders) {
     const sCell = postMovePlacements.get(spiderId);
-    if (!hasActiveWebAt(sCell.x, sCell.y, state, k)) continue;
+    if (!hasActiveWebAt(sCell.x, sCell.y, state, k, config.webDurationTurns)) continue;
     for (const flyId of flies) {
       if (claimedFlies.has(flyId)) continue;
       const fCell = postMovePlacements.get(flyId);
@@ -396,7 +407,7 @@ export function runEcologyPass({ state, postMovePlacements, postMoveMassByFly, p
   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 ?? SPIDER_INITIAL_MASS);
+    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);
@@ -427,7 +438,7 @@ export function runEcologyPass({ state, postMovePlacements, postMoveMassByFly, p
   const liveEggId = [...state.laidAtTurn.keys()].find((id) => !state.removed.has(id));
   if (!liveEggId) {
     const sinceTurn = mostRecentEggLaidTurn(state);
-    const threshold = sinceTurn === -1 ? 1 : EGGS_EATEN_THRESHOLD;
+    const threshold = sinceTurn === -1 ? 1 : config.eggsEatenThreshold;
     let eatsSince = events.eaten.length;
     for (const { turn: eatenTurn } of state.eatenBy.values()) if (eatenTurn > sinceTurn) eatsSince += 1;
     if (eatsSince >= threshold) {
@@ -442,18 +453,18 @@ export function runEcologyPass({ state, postMovePlacements, postMoveMassByFly, p
     }
   }
 
-  // 4. Hatch — any live egg laid exactly EGG_HATCH_DELAY_TURNS turns ago.
+  // 4. Hatch — any live egg laid exactly config.eggHatchDelayTurns turns ago.
   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 + EGG_HATCH_DELAY_TURNS !== k) continue;
+    if (laidTurn + config.eggHatchDelayTurns !== k) continue;
     const eggCell = state.placements.get(eggId)?.cell;
     if (!eggCell) continue;
     const newSpiderId = `spider-${nextSpiderNum}`;
     nextSpiderNum += 1;
     writes.push({ subject: `${newSpiderId}@turn${k}`, predicate: "mgx:currently-in", object: eggCell });
-    writes.push({ subject: `${newSpiderId}@turn${k}`, predicate: "mgx:mass", object: String(SPIDER_INITIAL_MASS) });
+    writes.push({ subject: `${newSpiderId}@turn${k}`, predicate: "mgx:mass", object: String(config.spiderInitialMass) });
     writes.push({ subject: `${eggId}@turn${k}`, predicate: "mgx:hatched-into", object: newSpiderId });
     events.hatched.push({ egg: eggId, spider: newSpiderId, cell: eggCell });
   }
@@ -461,7 +472,7 @@ export function runEcologyPass({ state, postMovePlacements, postMoveMassByFly, p
   // 5. 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 % FLY_SPAWN_INTERVAL_TURNS === 0) {
+  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) {
@@ -479,7 +490,7 @@ export function runEcologyPass({ state, postMovePlacements, postMoveMassByFly, p
       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(FLY_INITIAL_MASS) });
+      writes.push({ subject: `${newFlyId}@turn${k}`, predicate: "mgx:mass", object: String(config.flyInitialMass) });
       events.spawned = newFlyId;
       events.spawnedCell = cell;
     }
@@ -494,15 +505,16 @@ export function runEcologyPass({ state, postMovePlacements, postMoveMassByFly, p
  *  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). */
-export async function startSpiderFlyGame(memoryDir, { flyCount = 1 } = {}) {
+ *  the game has already started). `config` (default
+ *  DEFAULT_GAME_CONFIG.spiderFly) supplies the starting masses. */
+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(SPIDER_INITIAL_MASS) },
+    { subject: "spider-1", predicate: "mgx:mass", object: String(config.spiderInitialMass) },
   ];
   const occupied = new Set([cellId(WEB_HOME.x, WEB_HOME.y)]);
   for (let i = 0; i < flyCount; i += 1) {
@@ -511,7 +523,7 @@ export async function startSpiderFlyGame(memoryDir, { flyCount = 1 } = {}) {
     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(FLY_INITIAL_MASS) });
+    facts.push({ subject: flyId, predicate: "mgx:mass", object: String(config.flyInitialMass) });
   }
   await appendFacts(memoryDir, facts.map((f) => ({ ...f, provenance: worldProvenanceTag(WORLD_NAME) })));
   return { started: true, facts };
@@ -534,11 +546,13 @@ function goalLineFor(subject, believed, arrived, kind) {
  *  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. */
-export function liveWebs(websMap, turn) {
+ *  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 + WEB_DURATION_TURNS > turn) out.push({ id, cell, builtAtTurn, expiresAtTurn: builtAtTurn + WEB_DURATION_TURNS });
+    if (builtAtTurn + webDurationTurns > turn) out.push({ id, cell, builtAtTurn, expiresAtTurn: builtAtTurn + webDurationTurns });
   }
   return out;
 }
@@ -560,9 +574,15 @@ export function liveWebs(websMap, turn) {
  * 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: the vision radius, both agents' starting/decrement
+ * masses, and the web duration, and is forwarded unchanged into
+ * runEcologyPass.
  */
 export async function runSpiderFlyTick(memoryDir, opts = {}) {
-  const { visionRadius = DEFAULT_VISION_RADIUS, toldFacts = [] } = opts;
+  const { toldFacts = [], config = DEFAULT_GAME_CONFIG.spiderFly } = opts;
+  const visionRadius = config.visionRadius;
   const rows = readFactRows(await loadMemory(memoryDir));
   const state = foldSpiderFlyState(rows);
   const k = state.turnCount + 1;
@@ -581,8 +601,8 @@ export async function runSpiderFlyTick(memoryDir, opts = {}) {
 
   for (const spiderId of spiders) {
     const spiderCell = parseCellId(state.placements.get(spiderId).cell);
-    const priorMass = state.mass.get(spiderId)?.value ?? SPIDER_INITIAL_MASS;
-    const newMass = Math.max(0, priorMass - SPIDER_MASS_DECREMENT_PER_TURN);
+    const priorMass = state.mass.get(spiderId)?.value ?? config.spiderInitialMass;
+    const newMass = Math.max(0, priorMass - config.spiderMassDecrementPerTurn);
     postMoveMassBySpider.set(spiderId, newMass);
 
     // Priority 1: avoid any OTHER live spider believed visible.
@@ -599,7 +619,7 @@ export async function runSpiderFlyTick(memoryDir, opts = {}) {
       const target = nearestBelievedTarget(spiderId, spiderCell, flies, state, { visionRadius, toldFacts });
       if (target) {
         nextCell = spiderCell;
-        const path = planSpiderPath(spiderCell, target.cell, applyActions, state, k);
+        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 {
@@ -611,14 +631,14 @@ export async function runSpiderFlyTick(memoryDir, opts = {}) {
         // 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 && hasActiveWebAt(nextCell.x, nextCell.y, state, k);
+        const arrived = nextCell.x === target.cell.x && nextCell.y === target.cell.y && hasActiveWebAt(nextCell.x, nextCell.y, state, k, config.webDurationTurns);
         goal = goalLineFor(spiderId, target, arrived, "spider");
       } else {
         // Priority 3: hold position, and build/refresh a web there unless an
         // unexpired web already covers this exact cell.
         nextCell = spiderCell;
         const heldCellId = cellId(spiderCell.x, spiderCell.y);
-        if (!hasActiveWebAt(spiderCell.x, spiderCell.y, state, k)) {
+        if (!hasActiveWebAt(spiderCell.x, spiderCell.y, state, k, config.webDurationTurns)) {
           const webId = `web-${nextWebNum}`;
           nextWebNum += 1;
           tickWebs.set(webId, { cell: heldCellId, builtAtTurn: k });
@@ -640,19 +660,19 @@ export async function runSpiderFlyTick(memoryDir, opts = {}) {
   for (const flyId of flies) {
     const flyCell = parseCellId(state.placements.get(flyId).cell);
     const believedSpider = nearestBelievedTarget(flyId, flyCell, spiders, state, { visionRadius, toldFacts });
-    const webbed = hasActiveWebAt(flyCell.x, flyCell.y, state, k);
+    const webbed = hasActiveWebAt(flyCell.x, flyCell.y, state, k, config.webDurationTurns);
     const nextCell = webbed ? flyCell : greedyFlyMove(flyCell, believedSpider?.cell ?? null, applyActions, k, flyId);
     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 ?? FLY_INITIAL_MASS;
-    const newMass = Math.max(0, priorMass - FLY_MASS_DECREMENT_PER_TURN);
+    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) });
     const goal = webbed ? "trapped in an active web — can't move." : goalLineFor(flyId, believedSpider, true, "fly");
     agents[flyId] = { cell: cellId(nextCell.x, nextCell.y), goal, mass: newMass };
   }
 
-  const ecology = runEcologyPass({ state, postMovePlacements, postMoveMassByFly, postMoveMassBySpider, turn: k });
+  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
@@ -705,14 +725,14 @@ export async function runSpiderFlyTick(memoryDir, opts = {}) {
   // though the very same tick's event text already announces it, only
   // catching up the following tick once the fold picks it up naturally.
   for (const h of ecology.events.hatched) {
-    agents[h.spider] = { cell: h.cell, goal: "just hatched — no goal yet.", plan: null, mass: SPIDER_INITIAL_MASS };
+    agents[h.spider] = { cell: h.cell, goal: "just hatched — no goal yet.", plan: null, mass: config.spiderInitialMass };
   }
   if (ecology.events.spawned && ecology.events.spawnedCell) {
-    agents[ecology.events.spawned] = { cell: ecology.events.spawnedCell, goal: "just arrived — no goal yet.", mass: FLY_INITIAL_MASS };
+    agents[ecology.events.spawned] = { cell: ecology.events.spawnedCell, goal: "just arrived — no goal yet.", mass: config.flyInitialMass };
   }
   const writes = [...movementWrites, ...ecology.writes];
   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) };
+  return { turn: k, writes, agents, ecology: ecology.events, activeWebs: liveWebs(tickWebs, k, config.webDurationTurns) };
 }

package/src/surfaces/web/adventure-browser-entry.mjs

@@ -13,30 +13,40 @@
 // rationale) — the bootstrap below then just appends it, exactly the shape
 // openAdventure() itself writes for a real chat session.
 //
-// This session exposes ONLY a raw autoplay tick and a read-only snapshot —
-// no chat dock. Every state-changing command adventure.mjs's own
-// runWorldCommand issues (go/take/open/...) already re-narrates itself
-// through the extractive completions digest on every turn (the
-// "auto-relook"), so this bundle carries the same wink-nlp/completions
-// dependency chain chat.mjs's own runTurn does; a second, lighter path was
-// not available to duck under it. Nothing here calls runTurn, though — the
-// one entry point exercised is adventureTurn itself, via
-// adventure-autoplay.mjs, which is the "auto-play is a caller of the
-// existing interpreter, never a second one" contract this whole feature
-// rests on.
+// This session exposes a raw autoplay tick, a read-only snapshot, AND
+// (mirroring createSpiderFlySession's own `turn(line)`) a full chat-dock
+// entry point: `turn(line)` runs the exact same runTurn the CLI and every
+// other viz page's chat dock run, over this session's own memoryDir/graph/
+// lexicon, threading `focus`/`last`/`planState` across calls the same way a
+// real chat session does. `planState` and `autoplayTick`'s own `planHolder`
+// share ONE mutable holder here, so a manual chat command and an auto-play
+// tick can never disagree about whether the adventure is still open, mid a
+// number game, etc. — whichever ran last leaves the holder as the other's
+// starting point. `planHolder.state` starts as adventureTurn's own opened-
+// world shape, so BOTH entry points treat every call as a live, already-open
+// world rather than a fresh opening line: ordinary in-game commands (look/
+// go/take/open/talk/examine/...) dispatch through adventure.mjs's own
+// adventureTurn exactly as autoplayTick's calls already do, and anything not
+// game-shaped falls through to the ordinary conversational layer, exactly
+// like a real CLI session.
+import { runTurn } from "../../services/chat.mjs";
 import {
   createInMemoryStore, appendFacts, appendRule, loadMemory, readFactRows,
 } from "../../adapters/memory/core.mjs";
-import { foldWorldState, worldDigestRows } from "../../services/adventure.mjs";
+import { parseEntities } from "../../domain/codegraph.mjs";
+import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
+import { foldWorldState, worldDigestRows, roomAffordances } from "../../services/adventure.mjs";
 import { runAdventureAutoplayTick } from "../../services/adventure-autoplay.mjs";
 import { resolveSpriteForClass, SPRITE_REGISTRY } from "../../domain/sprite-map.mjs";
+import { resolveSpriteAsset } from "../../domain/sprite-templates.mjs";
 
-/** A live in-memory adventure this page's ticker drives one auto-play tick
- *  at a time. Returns `{ memoryDir, autoplayTick, snapshot }`.
+/** A live in-memory adventure this page's ticker AND chat dock can both
+ *  drive. Returns `{ memoryDir, autoplayTick, turn, snapshot }`.
  *  `worldPayload.facts`/`.rules` seed the store exactly the way
  *  openAdventure() itself does for a real session; `planHolder.state` is set
- *  the same way, so adventureTurn treats every subsequent call as a live,
- *  already-open world rather than a fresh opening line. */
+ *  the same way, so adventureTurn treats every subsequent call — auto-play's
+ *  own or a visitor's typed one — as a live, already-open world rather than
+ *  a fresh opening line. */
 export async function createAdventureSession(worldPayload) {
   const memoryDir = createInMemoryStore();
   const tag = `world:${worldPayload.name}`;
@@ -54,6 +64,11 @@ export async function createAdventureSession(worldPayload) {
   const openingHere = foldWorldState(openingRows).placements.get("player")?.object ?? null;
   if (openingHere) exposedRoomIds = new Set([openingHere]);
 
+  const graph = parseEntities({ individuals: [], objectProperties: [] });
+  const lexicon = loadLexicon();
+  let focus = null;
+  let last = null;
+
   return {
     memoryDir,
 
@@ -69,8 +84,30 @@ export async function createAdventureSession(worldPayload) {
       return result;
     },
 
+    /** One dispatched chat turn — the SAME runTurn the CLI and every other
+     *  viz page's own chat dock run, over this session's own memoryDir. A
+     *  throwing runTurn must never kill the session — the page has no other
+     *  chance to show this turn's answer. */
+    async turn(line) {
+      let result;
+      try {
+        result = await runTurn(line, {
+          config: null, source: null, graph, focus, last, memoryDir, sessionId,
+          env: {}, lexicon, vocabHint: "", planState: planHolder.state,
+        });
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return { answer: `Something went wrong answering that (${message}). Try rephrasing, or /help.`, end: false, record: null, plan: null };
+      }
+      focus = result.focus;
+      last = result.last;
+      if ("planState" in result) planHolder.state = result.planState;
+      return { answer: result.answer, end: Boolean(result.end), record: result.record ?? null, plan: result.plan ?? null };
+    },
+
     /** A read-only fold of the current room — no engine advance — for the
-     *  page's own redraw after boot and after every tick. */
+     *  page's own redraw after boot, after every tick, and after every
+     *  manual chat turn. */
     async snapshot() {
       const rows = readFactRows(await loadMemory(memoryDir));
       const state = foldWorldState(rows);
@@ -81,8 +118,9 @@ export async function createAdventureSession(worldPayload) {
 }
 
 // Re-exported so the page's own rendering script (adventure-viz.mjs) never
-// has to duplicate sprite resolution or the digest reader — the same posture
+// has to duplicate sprite resolution, the digest reader, or the room
+// affordances the chat dock's own pills read from — the same posture
 // spider-fly-browser-entry.mjs's own globalThis.tmctSpiderFly re-export takes.
 globalThis.tmctAdventure = {
-  createAdventureSession, resolveSpriteForClass, SPRITE_REGISTRY, worldDigestRows,
+  createAdventureSession, resolveSpriteForClass, SPRITE_REGISTRY, resolveSpriteAsset, worldDigestRows, roomAffordances,
 };