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

package/src/services/adventure-viz.mjs

@@ -28,15 +28,29 @@
 // import without duplicating adventure.mjs's own closed vocabulary reading)
 // and `roomSceneObjects` (every subject actually visible in a room, mirrored
 // from adventure.mjs's private `visibleRoomOf` the same way
-// adventure-autoplay.mjs's own `roomOfSubject` already has to). `roomCaptionText`
-// is a third pure helper, exported for testing, but NOT spliced — it calls
-// `worldDigestRows` via a real ES import, since Node/test callers have one,
-// while the in-page script instead calls the browser bundle's own exposed
-// copy (mirroring how the inline script calls `tmctSpiderFly.*` rather than
-// re-importing spider-fly-world.mjs).
+// adventure-autoplay.mjs's own `roomOfSubject` already has to). Two further
+// pure helpers are exported for testing but NOT spliced, because each calls
+// an adventure.mjs export the in-page script instead reaches through the
+// browser bundle's own `tmctAdventure` global (mirroring how the inline
+// script calls `tmctSpiderFly.*` rather than re-importing
+// spider-fly-world.mjs): `roomCaptionText` (calls `worldDigestRows`; the
+// in-page `captionFor` mirrors it against `tmctAdventure.worldDigestRows`)
+// and `pillsForRoom` (the room's clickable command suggestions — a thin
+// wrapper over adventure.mjs's own exported `roomAffordances`, whose header
+// explains why its list can never promise an action one of take/open/talk/
+// examine would then refuse; the in-page `pillsFor` mirrors it against
+// `tmctAdventure.roomAffordances`).
+//
+// The chat dock (chatlog/chatform/chatq/pills, below) mirrors
+// spider-fly-viz.mjs's own side panel: every manual exchange (via
+// adventure-browser-entry.mjs's new `session.turn(line)`) and every
+// auto-play tick's own narration append to the SAME scrolling `#chatlog`, so
+// a visitor sees one continuous history rather than a line overwritten every
+// tick. `#caption`/`#goalLine` keep their existing job as the current-state
+// summary; the chat log is the persistent addition.
 import { THEME_TOKENS_CSS, SERIF_STACK, MONO_STACK, escapeHtml, embedJson } from "./viz-theme.mjs";
 import { createTicker } from "./viz-ticker.mjs";
-import { worldDigestRows } from "./adventure.mjs";
+import { worldDigestRows, roomAffordances } from "./adventure.mjs";
 
 const DEFAULT_TITLE = "tmct — the adventure";
 const PREVIEW_MAX_TICKS = 30;
@@ -58,6 +72,31 @@ export function spriteClassForObject(rows, subject) {
   return typeRow ? typeRow.object : "portable";
 }
 
+/** `rows` plus one synthetic rdfs:subClassOf edge from `subject`'s own name
+ *  to its declared sprite class (spriteClassForObject's own result) — never
+ *  written back to the corpus, just handed to sprite-templates.mjs's
+ *  resolver so a NAMED object (`cabinet`, `butler`) can carry its own sprite
+ *  template while an unauthored object of the same declared class still
+ *  falls back through it cleanly. Ashcombe Hall's own objects have no
+ *  rdfs:subClassOf chain of their own (each is directly typed, e.g. `cabinet
+ *  rdf:type furniture`); this is the exact same ancestor-walk mechanism
+ *  spider-fly's real poodle-IsA-dog taxonomy already exercises, just
+ *  synthesized at render time for a world whose taxonomy doesn't reach this
+ *  deep. A no-op when the subject's own name already IS its declared class
+ *  (nothing to synthesize). Pure. */
+export function spriteAncestryRows(rows, subject) {
+  const declaredClass = spriteClassForObject(rows, subject);
+  if (subject === declaredClass) return rows;
+  return [...(rows || []), { subject, predicate: "rdfs:subClassOf", object: declaredClass }];
+}
+
+/** Every fact row belonging to `subject` — the small `{predicate, object}`
+ *  set sprite-templates.mjs's resolver checks a parameterized/match template
+ *  against (e.g. an mgx:hasProperty row). Pure. */
+export function factsForSubject(rows, subject) {
+  return (rows || []).filter((r) => r.subject === subject);
+}
+
 /** Every subject actually visible in `here`, sorted, each with its sprite
  *  class — mirroring adventure.mjs's own private `visibleRoomOf` walk (one
  *  containment hop through an OPEN container) so this can never draw a
@@ -86,6 +125,19 @@ export function roomSceneObjects(rows, state, here) {
   return out;
 }
 
+/** The clickable command suggestions for the room the player is CURRENTLY
+ *  in — a thin, testable wrapper over adventure.mjs's own `roomAffordances`
+ *  (the exact same data take/open/talk/examine already check), so a pill can
+ *  never promise an action one of those verbs would then refuse. Each
+ *  returned string ("go north", "take lamp", "unlock cabinet", ...) is
+ *  already a complete, submittable command in this world's own imperative
+ *  grammar — the page inserts one into the chat input verbatim on click,
+ *  never reformats it. Pure; recomputed fresh on every redraw, so a pill for
+ *  a room the player has left, or an object already taken, never lingers. */
+export function pillsForRoom(rows, state, here) {
+  return roomAffordances(rows, state, here);
+}
+
 /** A short caption for `here`, built ONLY from the rows worldDigestRows
  *  itself already produces (the exact same view the chat reply's own digest
  *  reads) — every row already reads as a plain sentence
@@ -106,14 +158,26 @@ export function roomCaptionText(rows, state, here) {
 /** The self-contained adventure page. Pure given `worldPayload` (the build
  *  step's own read of the real Ashcombe Hall world — `{ facts, rules,
  *  opening }`), the same "byte-identical for identical input" invariant
- *  every other viz page in this project holds. `?preview=1` switches into
- *  the small, auto-playing, non-interactive mode the home page's hero iframe
- *  embeds, matching spider-fly.html's own dual-purpose file. */
-export function renderAdventureHtml({ title = DEFAULT_TITLE, worldPayload = { facts: [], rules: [], opening: "" } } = {}) {
+ *  every other viz page in this project holds. `spriteTemplates` is the
+ *  build step's own read of data/sprites/*.toml (sprite-template-files.mjs's
+ *  readSpriteTemplateFiles), embedded as page data the same way the world
+ *  payload is — the browser cannot read the filesystem, so the parsed
+ *  templates travel as JSON rather than as a bundled fs read. Defaults to
+ *  `[]` (every sprite falls back to the flat SPRITE_REGISTRY, unchanged from
+ *  before this module existed) so existing callers that don't pass one keep
+ *  working. `?preview=1` switches into the small, auto-playing, non-
+ *  interactive mode the home page's hero iframe embeds, matching
+ *  spider-fly.html's own dual-purpose file. */
+export function renderAdventureHtml({
+  title = DEFAULT_TITLE,
+  worldPayload = { facts: [], rules: [], opening: "" },
+  spriteTemplates = [],
+} = {}) {
   const pageData = embedJson({
     world: worldPayload,
     previewMaxTicks: PREVIEW_MAX_TICKS,
     tickWaitMs: TICK_WAIT_MS,
+    spriteTemplates,
   });
 
   return `<!doctype html>
@@ -132,6 +196,8 @@ ${THEME_TOKENS_CSS}
   h1 { font-size: 1.4rem; margin: .3rem 0 .9rem; text-wrap: balance; }
   button { font: inherit; color: inherit; background: none; cursor: pointer; }
   button:focus-visible { outline: 2px solid var(--ink); outline-offset: 2px; }
+  .stage { display: grid; grid-template-columns: minmax(0, 1fr) 260px; gap: 1rem; align-items: start; }
+  @media (max-width: 760px) { .stage { grid-template-columns: 1fr; } }
   .room-frame { position: relative; min-height: 210px; background: var(--taught-soft); border: 1px solid var(--line); padding: 1rem; display: flex; flex-direction: column; gap: .8rem; justify-content: flex-end; }
   .sprite-row { display: flex; flex-wrap: wrap; gap: .6rem; align-items: flex-end; }
   .sprite { width: 44px; height: 44px; }
@@ -143,6 +209,23 @@ ${THEME_TOKENS_CSS}
   .sprite[data-cls="room"] { color: var(--muted); }
   .sprite-label { font-family: ${MONO_STACK}; font-size: .62rem; text-align: center; color: var(--muted); margin-top: .15rem; }
   .caption { background: var(--card); border: 1px solid var(--line); padding: .6rem .75rem; font-size: .9rem; }
+  .side { display: flex; flex-direction: column; gap: .8rem; min-width: 0; }
+  .chat { background: var(--card); border: 1px solid var(--line); padding: .6rem .75rem; }
+  .chat h2 { font-family: ${MONO_STACK}; font-size: .66rem; letter-spacing: .08em; text-transform: uppercase; color: var(--muted); font-weight: 400; margin: 0 0 .5rem; }
+  .chatlog { display: flex; flex-direction: column; gap: .4rem; max-height: 320px; overflow-y: auto; margin-bottom: .5rem; }
+  .chatlog .u { font-family: ${MONO_STACK}; font-size: .74rem; color: var(--muted); }
+  .chatlog .u::before { content: "tmct> "; color: var(--taught); }
+  .chatlog .a { font-size: .88rem; line-height: 1.4; white-space: pre-wrap; }
+  .chatlog .t { font-family: ${MONO_STACK}; font-size: .74rem; color: var(--muted); font-style: italic; }
+  .chatlog .t::before { content: "\\2022 "; }
+  .pills { display: flex; flex-wrap: wrap; gap: .35rem; margin-bottom: .5rem; }
+  .pills:empty { display: none; margin-bottom: 0; }
+  .pill { font-family: ${MONO_STACK}; font-size: .72rem; padding: .25rem .6rem; border: 1px solid var(--line); background: var(--bg); color: var(--ink); border-radius: 999px; }
+  .pill:hover { border-color: var(--taught); }
+  .chatask { display: flex; align-items: center; gap: .5rem; border-top: 1px solid var(--line); padding-top: .5rem; }
+  .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; }
   .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); }
@@ -150,8 +233,9 @@ ${THEME_TOKENS_CSS}
   .controls-row .turn { margin-left: auto; font-family: ${MONO_STACK}; font-size: .78rem; color: var(--muted); font-variant-numeric: tabular-nums; }
   .goal-line { font-family: ${MONO_STACK}; font-size: .78rem; color: var(--muted); margin-top: .5rem; }
   .status { font-family: ${MONO_STACK}; font-size: .74rem; color: var(--muted); margin-top: .3rem; }
-  body.preview .controls-row, body.preview .status { display: none; }
+  body.preview .side, body.preview .controls-row, body.preview .status { display: none; }
   body.preview main { padding: 0; max-width: none; }
+  body.preview .stage { display: block; }
   body.preview .eyebrow, body.preview h1 { display: none; }
 </style>
 </head>
@@ -159,8 +243,21 @@ ${THEME_TOKENS_CSS}
 <main>
   <div class="eyebrow">tmct &middot; the adventure</div>
   <h1>A room, drawn from exactly what the text already says is there</h1>
-  <div class="room-frame" id="roomFrame">
-    <div class="sprite-row" id="spriteRow"></div>
+  <div class="stage">
+    <div class="room-frame" id="roomFrame">
+      <div class="sprite-row" id="spriteRow"></div>
+    </div>
+    <aside class="side" aria-label="The adventure's log and chat">
+      <div class="chat">
+        <h2>what's happened, and what you can do</h2>
+        <div class="chatlog" id="chatlog" aria-live="polite"></div>
+        <div class="pills" id="pills"></div>
+        <form class="chatask" id="chatform">
+          <span class="prompt mono">tmct&gt;</span>
+          <input id="chatq" type="text" placeholder="go north" aria-label="Type a command, or ask a question" disabled>
+        </form>
+      </div>
+    </aside>
   </div>
   <div class="caption" id="caption"></div>
   <div class="goal-line" id="goalLine"></div>
@@ -182,6 +279,8 @@ const ADVENTURE = ${pageData};
   const createTicker = ${createTicker.toString()};
   const spriteClassForObject = ${spriteClassForObject.toString()};
   const roomSceneObjects = ${roomSceneObjects.toString()};
+  const spriteAncestryRows = ${spriteAncestryRows.toString()};
+  const factsForSubject = ${factsForSubject.toString()};
   const esc = ${escapeHtml.toString()};
   const el = (id) => document.getElementById(id);
   const spriteRow = el("spriteRow");
@@ -192,6 +291,10 @@ const ADVENTURE = ${pageData};
   const resetBtn = el("resetBtn");
   const playBtn = el("playBtn");
   const stepBtn = el("stepBtn");
+  const chatlogEl = el("chatlog");
+  const pillsEl = el("pills");
+  const chatformEl = el("chatform");
+  const chatqEl = el("chatq");
 
   const params = new URLSearchParams(location.search);
   const preview = params.get("preview") === "1";
@@ -208,44 +311,124 @@ const ADVENTURE = ${pageData};
     return lines.length ? lines.join(" ") : "Nothing more about the " + here + " is written down yet.";
   }
 
+  // ---- chat/event log — every manual exchange AND every auto-play tick's
+  // own narration append here, in order, so it reads as one continuous
+  // history rather than a line overwritten every tick.
+  function addChatLine(cls, html) {
+    const d = document.createElement("div");
+    d.className = cls; d.innerHTML = html;
+    chatlogEl.appendChild(d); chatlogEl.scrollTop = chatlogEl.scrollHeight;
+  }
+
+  // ---- contextual pills — refreshed every redraw from the CURRENT room's
+  // own roomAffordances-derived list (mirroring pillsForRoom against
+  // tmctAdventure.roomAffordances, the same way captionFor above mirrors
+  // roomCaptionText against tmctAdventure.worldDigestRows), so a pill for a
+  // room the player has left, or an object already taken, never lingers.
+  // Clicking one inserts its exact command text into the input and focuses
+  // it; it never auto-submits, so free typing still works and a clicked
+  // suggestion can still be edited first.
+  function pillsFor(rows, state, here) {
+    return tmctAdventure.roomAffordances(rows, state, here);
+  }
+  function renderPills(rows, state, here) {
+    const actions = pillsFor(rows, state, here);
+    pillsEl.innerHTML = actions.map((a) => '<button type="button" class="pill">' + esc(a) + "</button>").join("");
+  }
+  pillsEl.addEventListener("click", (e) => {
+    const btn = e.target.closest(".pill");
+    if (!btn || !chatqEl) return;
+    chatqEl.value = btn.textContent;
+    chatqEl.focus();
+  });
+
+  // ---- sprite resolution — property/instance-aware (sprite-templates.mjs's
+  // resolveSpriteAsset), keyed on the OBJECT'S OWN NAME (via
+  // spriteAncestryRows' synthetic subClassOf edge to its declared class) so
+  // a named object (cabinet, butler) can carry its own data/sprites/*.toml
+  // template while the data-cls attribute still reflects the DECLARED class
+  // (container/furniture/portable/person/room) — the CSS accent-color rules
+  // stay keyed on that declared class unchanged. The player's own "you" row
+  // has no backing fact row, so it resolves directly by its fixed
+  // "adventurer" class with no ancestry/property rows to check.
+  function resolveObjectSprite(rows, s) {
+    if (s.subject === "you") return tmctAdventure.resolveSpriteAsset("adventurer", [], [], ADVENTURE.spriteTemplates, tmctAdventure.SPRITE_REGISTRY);
+    return tmctAdventure.resolveSpriteAsset(
+      s.subject, spriteAncestryRows(rows, s.subject), factsForSubject(rows, s.subject),
+      ADVENTURE.spriteTemplates, tmctAdventure.SPRITE_REGISTRY,
+    );
+  }
+
   function redraw(snap) {
     const objects = roomSceneObjects(snap.rows, snap.state, snap.here);
     const sprites = [{ subject: "you", spriteClass: "adventurer" }, ...objects];
     spriteRow.innerHTML = sprites.map((s) => {
-      const svg = tmctAdventure.resolveSpriteForClass(s.spriteClass, [], tmctAdventure.SPRITE_REGISTRY);
+      const svg = resolveObjectSprite(snap.rows, s);
       return '<div><div class="sprite" data-cls="' + esc(s.spriteClass) + '">' + svg + '</div>'
         + '<div class="sprite-label">' + esc(s.subject) + "</div></div>";
     }).join("");
     captionEl.textContent = captionFor(snap.rows, snap.state, snap.here);
     turnLabelEl.textContent = "turn: " + snap.turn;
+    renderPills(snap.rows, snap.state, snap.here);
+  }
+
+  // ---- 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.
+  let lock = Promise.resolve();
+  function withLock(fn) {
+    const run = lock.then(fn, fn);
+    lock = run.catch(() => {});
+    return run;
   }
 
+  chatformEl.addEventListener("submit", (e) => {
+    e.preventDefault();
+    const q = chatqEl.value.trim();
+    if (!q || !session) return;
+    chatqEl.value = "";
+    // A manual command lands mid-tick otherwise — pause first, and stay
+    // paused until the visitor presses play again.
+    ticker.pause();
+    addChatLine("u", esc(q));
+    withLock(async () => {
+      const result = await session.turn(q);
+      addChatLine("a", esc(result.answer).replace(/\\n/g, "<br>"));
+      const snap = await session.snapshot();
+      redraw(snap);
+    });
+  });
+
   async function boot() {
     session = await tmctAdventure.createAdventureSession(ADVENTURE.world);
     lastTicks = 0;
     const snap = await session.snapshot();
     redraw(snap);
     goalLineEl.textContent = "";
+    chatlogEl.innerHTML = "";
     statusEl.textContent = ADVENTURE.world.opening || "";
+    addChatLine("t", esc(ADVENTURE.world.opening || "the adventure begins."));
+    chatqEl.disabled = false;
     resetBtn.disabled = false; playBtn.disabled = false; stepBtn.disabled = false;
   }
 
   const ticker = createTicker({
-    onTick: async () => {
+    onTick: () => withLock(async () => {
       const result = await session.autoplayTick();
       lastTicks += 1;
       const snap = await session.snapshot();
       redraw(snap);
       goalLineEl.textContent = result.goal || "";
+      addChatLine("t", esc(result.goal || ""));
       if (result.done || result.stalled) ticker.pause();
-    },
+    }),
     onRender: (state) => {
       playBtn.textContent = state.playing ? "\\u23f8 pause" : "\\u25b6 play";
       playBtn.disabled = state.animating;
       stepBtn.disabled = state.animating || state.playing;
       resetBtn.disabled = state.animating;
     },
-    onReset: () => boot(),
+    onReset: () => withLock(boot),
     hasNext: () => !preview || lastTicks < ADVENTURE.previewMaxTicks,
     waitMs: ADVENTURE.tickWaitMs,
   });

package/src/services/adventure.mjs

@@ -251,6 +251,20 @@ const carriedByPlayer = (state, thing) => {
   return !!place && place.predicate === "mgx:located-in" && place.object === "player";
 };
 
+/** True when `object` is never a real placed game entity (no entry in
+ *  state.placements at all — checked first, so a hidden or elsewhere-placed
+ *  object never counts, only a term with NO placement anywhere) but some
+ *  OTHER fact still names it — almost always the background human/ConceptNet
+ *  corpus overlapping a room's own vocabulary ("garden mgx:hasA flower"),
+ *  which worldDigestRows already renders into the room's own prose ("Garden
+ *  has flower"). Without this distinction, examine/take/talk's shared
+ *  presence decline ("I don't see a flower here") directly contradicts what
+ *  the room's own description just said, in the same conversation. */
+function backgroundOnlyMention(rows, state, object) {
+  if (state.placements.has(object)) return false;
+  return (rows || []).some((r) => r.subject === object || r.object === object);
+}
+
 /** The room's real affordances — every exit, and every visible object's
  *  applicable verb — read from the EXACT SAME data take/open/talk/examine
  *  already check (visibleRoomOf, isContainer, isTyped, the placement
@@ -552,7 +566,23 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
     // existing rather than the true state (you're in it). Treat naming the
     // current room itself as always present.
     const isCurrentRoom = object === here;
-    if (!carried && !isCurrentRoom && visibleRoomOf(object, { rows, state }) !== here) {
+    const notHere = !carried && !isCurrentRoom && visibleRoomOf(object, { rows, state }) !== here;
+    // A background-only mention (e.g. "flower", surfaced only through the
+    // human corpus overlapping this room's own vocabulary — see
+    // backgroundOnlyMention's own docblock) is real, sourced knowledge, just
+    // never a placed prop. "talk" still declines (it's not a person), but
+    // honestly — never claiming the term doesn't exist when the room's own
+    // digest just said otherwise. "examine" instead falls through to the
+    // ordinary digest below, the same one "what is a flower" already answers
+    // from outside the game.
+    if (notHere && cmd.verb === "talk" && backgroundOnlyMention(rows, state, object)) {
+      return answer(
+        `the ${object} isn't someone you can talk to here — it's only mentioned in passing, not a real person in this scene.`,
+        noteFor(`talk — ${object} is a background-only mention, not a placed NPC; declined honestly`),
+        { miss: true },
+      );
+    }
+    if (notHere && !(cmd.verb === "examine" && backgroundOnlyMention(rows, state, object))) {
       return answer(
         `I don't see a ${object} here.`,
         noteFor(`${cmd.verb} — ${object} isn't visible in the ${here}; declined, hidden things stay hidden`),
@@ -650,6 +680,13 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
       return answer(`you can't take the ${object}.`, noteFor("take — the object is one of the cast; declined"), { miss: true });
     }
     if (visibleRoomOf(object, { rows, state }) !== here) {
+      if (backgroundOnlyMention(rows, state, object)) {
+        return answer(
+          `the ${object} isn't something you can take — it's only mentioned in passing here, not a real prop in this scene.`,
+          noteFor(`take — ${object} is a background-only mention, never a placed object; declined honestly`),
+          { miss: true },
+        );
+      }
       return answer(`I don't see a ${object} here.`, noteFor(`take — ${object} isn't visible in the ${here}; declined, hidden things stay hidden`), { miss: true });
     }
     return commit(
@@ -693,8 +730,13 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
   // precond/effect rows consulted through domain.mjs below; only the
   // hidden-contents reveal (a variable-arity effect over a discovered set)
   // stays hand-written JS, since no shipped rule shape covers that either.
-  const presentHere = place && place.predicate !== "mgx:hidden-in" && place.predicate !== "mgx:currently-in" && place.object === here;
-  if (!presentHere) {
+  // Presence reuses visibleRoomOf (the SAME check examine/talk/take already
+  // use), not a hand-rolled duplicate: an earlier version of this check
+  // excluded mgx:currently-in outright, so a genuinely-present NPC (placed
+  // that way, not fixed-in/stands-locked-in) fell into "I don't see a X
+  // here" instead of reaching the isContainer check just below, which would
+  // have honestly said "the X doesn't open."
+  if (visibleRoomOf(object, { rows, state }) !== here) {
     return answer(`I don't see a ${object} here.`, noteFor(`${cmd.verb} — ${object} isn't in the ${here}; declined`), { miss: true });
   }
   if (!isContainer(rows, object)) {

package/src/services/chat-session.mjs

@@ -27,6 +27,7 @@ import { createTelemetry } from "./telemetry.mjs";
 import * as defaultSource from "../adapters/source.mjs";
 import { resolveExtensions, mergedLexiconExtra } from "./extensions.mjs";
 import { runTurn, hasSeededVocabulary, vocabExampleHint } from "./chat.mjs";
+import { resolveGameConfig } from "../domain/game-config.mjs";
 
 /** Where session logs live, relative to the target repo. `.tmct/` is the repo's
  *  one artifact directory (gitignored, machine-local) — flip this single constant
@@ -182,6 +183,13 @@ export async function createSession({
     }
   }
 
+  // Every game's tuning knobs (spider-fly's mass economy, guess-the-number's
+  // bounds, the shared plan lane's search-depth cap), resolved once per
+  // session from this repo's tmct.toml — resolveGameConfig tolerates `toml`
+  // being null (no file, or one that failed to load above) by falling back
+  // to the shipped defaults for every key.
+  const gameConfig = resolveGameConfig(toml);
+
   // Ephemeral: keep config.graphFile pointing at the READ graph, but divert the
   // write base (repo → logs/memory/sessions) to a throwaway temp dir. The committed
   // target is never touched; the demo's memory simply doesn't persist across runs.
@@ -338,7 +346,7 @@ export async function createSession({
     async turn(line) {
       let result;
       try {
-        result = await runTurn(line, { config, source, graph, focus, last, memoryDir, sessionId, env, lexicon, narrate: narrateOn, vocabHint, tel, biasByBundle, planState });
+        result = await runTurn(line, { config, source, graph, focus, last, memoryDir, sessionId, env, lexicon, narrate: narrateOn, vocabHint, tel, biasByBundle, planState, gameConfig });
       } catch (e) {
         const ts = new Date().toISOString();
         const message = e instanceof Error ? e.message : String(e);

package/src/services/chat.mjs

@@ -54,6 +54,7 @@ import { dialogueActForLane } from "../domain/dialogue-acts.mjs";
 import { relatedForTerm } from "../domain/skos-view.mjs";
 import { adventureTurn, unclaimedAdventureOpening } from "./adventure.mjs";
 import { spiderFlyTurn } from "./spider-fly-turn.mjs";
+import { DEFAULT_GAME_CONFIG } from "../domain/game-config.mjs";
 
 // Composition: the chat surface supplies the domain parser's default lemma/POS
 // adapter (the browser bundle's ask-nlp stub carries no factory, so this is a
@@ -1559,6 +1560,16 @@ export function renderVerbose(last) {
 function conversationalTurn(line, ctx) {
   const raw = String(line);
   const q = raw.toLowerCase().replace(/[.!?]+$/, "").replace(/\s+/g, " ").trim();
+  // A live game (adventure/spider-fly/guess-the-number) already recognizes its
+  // OWN exact stop phrase ("stop playing", "I give up", ...) before this lane
+  // ever sees the line, so a bare word reaching here mid-game was never meant
+  // as a farewell — it's an in-game noun that fell through every game-shaped
+  // command check (e.g. "player", the adventure's own subject). The fuzzy-typo
+  // fallback below is a GUESS (bounded edit distance against "later" etc.),
+  // and a wrong guess ends the whole session — too costly a mistake to risk
+  // mid-game. The exact/closed-set farewell just above and below this guard
+  // stays live either way (a real "bye"/"exit" is unambiguous, never a guess).
+  const gameActive = Boolean(ctx.planHolder?.state?.adventure || ctx.planHolder?.state?.spiderFly || ctx.planHolder?.state?.game);
   const t = (id, slots = {}) => tRender(ctx.templates, id, slots) ?? TEMPLATES_UNAVAILABLE;
   const mk = (answer, { end = false, miss = false, via = "template", lane = null } = {}) => {
     const ts = new Date().toISOString();
@@ -1686,8 +1697,10 @@ function conversationalTurn(line, ctx) {
   // Fuzzy-typo fallback (A4): every exact/collapsed closed-set lookup above missed —
   // try a bounded edit-distance match against the flattened conversational phrase
   // pool ("helo", "thnx", "wat r u", "byee"), restricted to short non-code-ish
-  // input so a genuine near-miss structural question is never grabbed.
-  {
+  // input so a genuine near-miss structural question is never grabbed. Skipped
+  // entirely mid-game (see gameActive above) — never reached the CLI's own
+  // process-exit path from a guess before this fix existed.
+  if (!gameActive) {
     const fuzzyHit = fuzzyConversationalMatch(raw);
     if (fuzzyHit) {
       const bucket = classifyConversational(fuzzyHit);
@@ -10054,7 +10067,7 @@ const sameGoalSpec = (a, b) =>
  *  taught action rules (PLAN_HANOI's chat surface). Returns
  *  { text, via, deduced, note, plan? } or null when the query is none of the
  *  three shapes. Mutates planHolder.state (the session's plan slot). */
-async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", }) {
+async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", gameConfig = DEFAULT_GAME_CONFIG }) {
   let q = String(query).trim();
   // GOAL REVISION — "actually the goal is …", "instead, the goal is …", "the
   // goal is now …": a revision marker ahead of (or inside) a goal frame means
@@ -10349,9 +10362,10 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
     return { text: `I can't compile that goal: ${err?.message ?? err}`, via: "plan", deduced: "plan a move sequence (uncompilable goal)", note: "plan lane — goal compile decline" };
   }
   const { findActionPath } = await import("../domain/planning.mjs");
+  const maxDepth = gameConfig?.planning?.maxDepth ?? DEFAULT_GAME_CONFIG.planning.maxDepth;
   let found;
   try {
-    found = findActionPath(state, isGoal, (s) => movesFromRules(s, domain), { maxDepth: 300, stateKey: stateKeyFor });
+    found = findActionPath(state, isGoal, (s) => movesFromRules(s, domain), { maxDepth, stateKey: stateKeyFor });
   } catch (err) {
     if (err instanceof PlanBudgetError) {
       return { text: `the search space is too large (${err.message}) — narrow the classes involved.`, via: "plan", deduced: "plan a move sequence (budget exceeded)", note: "plan lane — budget decline" };
@@ -10360,7 +10374,7 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
   }
   if (!found) {
     return {
-      text: `no plan found within 300 moves from the current state to: ${goalText}.`,
+      text: `no plan found within ${maxDepth} moves from the current state to: ${goalText}.`,
       via: "plan", deduced: "plan a move sequence (no path)", note: "plan lane — honest miss: findActionPath returned null",
     };
   }
@@ -10635,7 +10649,7 @@ const DECISION_RECALL_RE = /^(?:remind\s+me\s+)?what\s+(?:did\s+)?(?:we|i|you)\s
  *  than silently accepted alongside the current location. */
 const MOVE_HISTORY_RE = /^where\s+did\s+(.+?)\s+(?:move|get\s+moved|go)(?:\s+to)?[?.!\s]*$/i;
 
-async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null, planHolder = null }) {
+async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null, planHolder = null, gameConfig = DEFAULT_GAME_CONFIG }) {
   const ts = new Date().toISOString();
   // DISCOURSE ANAPHORA: a follow-up like "which of those are tested" / "count
   // them" filters or counts the PREVIOUS answer's entity set, threaded as
@@ -11006,7 +11020,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // orientation card before this lane ever ran.
   let planResult = null;
   if (!handled && miss && memoryDir && planHolder) {
-    const planLane = await planLaneAnswer(query, { memoryDir, planHolder, sessionId });
+    const planLane = await planLaneAnswer(query, { memoryDir, planHolder, sessionId, gameConfig });
     if (planLane) {
       answer = planLane.text; via = planLane.via; recordMiss = false; handled = true;
       if (planLane.lane) dialogueLaneOverride = planLane.lane;
@@ -12449,22 +12463,23 @@ async function skosRelatedAnswer(memoryDir, query, cache) {
  *  captures (\S+) so a non-numeric bound is SEEN and declined rather than
  *  silently defaulted. */
 const GAME_BOUNDS_CLAUSE_RE = /\b(?:between\s+(\S+)\s+and\s+(\S+)|up\s+to\s+(\S+))\b/i;
-const GAME_BOUND_MAX = 1_000_000_000;
 
-/** The bounds an opening line states — { lo, hi } (default 1–100), or
- *  { problem } naming why the stated range is unplayable. */
-function parseGameBounds(text) {
+/** The bounds an opening line states — { lo, hi } (default `gameConfig`'s own
+ *  defaultLo/defaultHi), or { problem } naming why the stated range is
+ *  unplayable. `gameConfig` defaults to DEFAULT_GAME_CONFIG.guessNumber. */
+function parseGameBounds(text, gameConfig = DEFAULT_GAME_CONFIG.guessNumber) {
+  const { defaultLo, defaultHi, maxBound } = gameConfig;
   const m = String(text).match(GAME_BOUNDS_CLAUSE_RE);
-  if (!m) return { lo: 1, hi: 100 };
-  const tokens = (m[3] !== undefined ? ["1", m[3]] : [m[1], m[2]])
+  if (!m) return { lo: defaultLo, hi: defaultHi };
+  const tokens = (m[3] !== undefined ? [String(defaultLo), m[3]] : [m[1], m[2]])
     .map((t) => String(t).replace(/[,.?!]+$/, ""));
   if (!tokens.every((t) => /^-?\d+$/.test(t))) {
-    return { problem: 'I can only play with whole-number bounds — say "between 1 and 100".' };
+    return { problem: `I can only play with whole-number bounds — say "between ${defaultLo} and ${defaultHi}".` };
   }
   const lo = Number(tokens[0]);
   const hi = Number(tokens[1]);
-  if (Math.abs(lo) > GAME_BOUND_MAX || Math.abs(hi) > GAME_BOUND_MAX) {
-    return { problem: `that range is too big for a fair game — keep both bounds within ${GAME_BOUND_MAX.toLocaleString("en-US")}.` };
+  if (Math.abs(lo) > maxBound || Math.abs(hi) > maxBound) {
+    return { problem: `that range is too big for a fair game — keep both bounds within ${maxBound.toLocaleString("en-US")}.` };
   }
   if (hi < lo) return { problem: `no number is between ${lo} and ${hi} — that range is empty. Put the smaller bound first.` };
   if (hi === lo) return { problem: `between ${lo} and ${hi} leaves exactly one number, so there is nothing to guess. Pick a wider range.` };
@@ -12485,20 +12500,21 @@ const THINKER_OPEN_TAIL_RE = /^[\s,.!?—-]*(?:and\s+)?(?:i\s*(?:'ll|\s+will)\s+
 const INVITATION_OPEN_LEAD_RE = /^(?:let'?s\s+play|wanna\s+play|want\s+to\s+play|can\s+we\s+play|shall\s+we\s+play|do\s+you\s+want\s+to\s+play|will\s+you\s+play|play)\s+(?:a\s+)?(?:game\s+of\s+)?(?:guess[- ]the[- ]number|number[- ]guessing(?:\s+game)?|guessing\s+game)\b(.*)$/i;
 const INVITATION_OPEN_TAIL_RE = /^[\s,.!?—-]*(?:with\s+me|together)?[\s,.!?—-]*$/i;
 
-/** An opening move — { mode, bounds } — or null. */
-function matchGameOpening(line) {
+/** An opening move — { mode, bounds } — or null. `gameConfig` defaults to
+ *  DEFAULT_GAME_CONFIG.guessNumber and threads through to parseGameBounds. */
+function matchGameOpening(line, gameConfig = DEFAULT_GAME_CONFIG.guessNumber) {
   const l = String(line).trim();
   const guesser = l.match(GUESSER_OPEN_LEAD_RE);
   if (guesser && GUESSER_OPEN_TAIL_RE.test(guesser[1].replace(GAME_BOUNDS_CLAUSE_RE, " "))) {
-    return { mode: "guesser", bounds: parseGameBounds(l) };
+    return { mode: "guesser", bounds: parseGameBounds(l, gameConfig) };
   }
   const thinker = l.match(THINKER_OPEN_LEAD_RE);
   if (thinker && THINKER_OPEN_TAIL_RE.test(thinker[1].replace(GAME_BOUNDS_CLAUSE_RE, " "))) {
-    return { mode: "thinker", bounds: parseGameBounds(l) };
+    return { mode: "thinker", bounds: parseGameBounds(l, gameConfig) };
   }
   const invite = l.match(INVITATION_OPEN_LEAD_RE);
   if (invite && INVITATION_OPEN_TAIL_RE.test(invite[1].replace(GAME_BOUNDS_CLAUSE_RE, " "))) {
-    return { mode: "thinker", bounds: parseGameBounds(l) };
+    return { mode: "thinker", bounds: parseGameBounds(l, gameConfig) };
   }
   return null;
 }
@@ -12611,10 +12627,10 @@ function gameContinuationAnswer(line, game, planHolder) {
 /** The whole game lane for one turn: continuations first (active game only),
  *  then opening moves, with the one-at-a-time declines both ways across the
  *  shared plan slot. Null when the turn is not the game's to answer. */
-function guessNumberTurn(line, { planHolder, env }) {
+function guessNumberTurn(line, { planHolder, env, gameConfig = DEFAULT_GAME_CONFIG }) {
   const state = planHolder?.state ?? null;
   const game = state?.game ?? null;
-  const opening = matchGameOpening(line);
+  const opening = matchGameOpening(line, gameConfig?.guessNumber);
   if (game) {
     const continuation = gameContinuationAnswer(line, game, planHolder);
     if (continuation) return continuation;
@@ -12855,7 +12871,13 @@ function vocabAntecedentFrom(last) {
   return m[1];
 }
 
-export async function runTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = false, vocabHint = null, tel = null, biasByBundle = {}, factRowsCache: injectedFactRowsCache = null, planState = null, _noSplit = false } = {}) {
+export async function runTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = false, vocabHint = null, tel = null, biasByBundle = {}, factRowsCache: injectedFactRowsCache = null, planState = null, gameConfig = null, _noSplit = false } = {}) {
+  // Every game's tuning knobs (spider-fly's mass economy, guess-the-number's
+  // bounds, the shared plan lane's search-depth cap) — a caller's own
+  // gameConfig (chat-session.mjs resolves one per session from tmct.toml)
+  // wins outright; direct/library callers that omit it get the shipped
+  // defaults, byte-identical to before this seam existed.
+  const resolvedGameConfig = gameConfig ?? DEFAULT_GAME_CONFIG;
   const line = String(input ?? "").trim();
   // ONE fresh, empty cache for this turn only — every factRows() reader
   // reached from this call shares it, so the first reader computes
@@ -12912,7 +12934,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // the PLAN NEXT block below write planHolder.state; every other path leaves
   // it untouched, and the caller re-threads whatever comes back.
   const planHolder = { state: planState };
-  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache, vocabAntecedent, planHolder };
+  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache, vocabAntecedent, planHolder, gameConfig: resolvedGameConfig };
   // A DISPATCHED turn (count / slash-command / ask) becomes the new "last
   // answer" that why/say-more re-renders; a conversational turn does not.
   // Every dispatched turn's result passes through finish() here — the LAST
@@ -12973,7 +12995,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // line would otherwise read as a declarative to remember. A mid-game line
   // matching no game shape returns null here and the game stands untouched.
   {
-    const gameTurn = guessNumberTurn(workingLine, { planHolder, env });
+    const gameTurn = guessNumberTurn(workingLine, { planHolder, env, gameConfig: resolvedGameConfig });
     if (gameTurn) {
       note(trace, `lane: ${gameTurn.note}`);
       if (gameTurn.goal) note(trace, `goal: ${gameTurn.goal}`);
@@ -13015,7 +13037,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // opening line would otherwise read as a declarative or an orientation ask.
   {
     const sfTurn = await spiderFlyTurn(workingLine, {
-      planHolder, memoryDir, env, cache: factRowsCache, isPlanFrameLine,
+      planHolder, memoryDir, env, cache: factRowsCache, isPlanFrameLine, gameConfig: resolvedGameConfig,
     });
     if (sfTurn) {
       note(trace, `lane: ${sfTurn.note}`);