@polycode-projects/the-mechanical-code-talker 2.7.22 → 2.7.24

package/README.md

@@ -847,6 +847,29 @@ enabled = false             # local-only counters; never phones home
 [memory]
 retention_versions = 5      # snapshot generations memory/core.mjs keeps on manifest bootstrap
 backend = "sqlite"          # default | memory | sqlite (see "Memory backends" above)
+
+# Game tuning knobs (src/domain/game-config.mjs). Every OTHER game parameter
+# (disk/peg counts, the goal, ...) lives in the game's own taught-English
+# world instead — these are the handful of genuine magic numbers that
+# aren't expressible that way.
+[games.spider-fly]
+spider_initial_mass = 15
+spider_mass_decrement_per_turn = 0.5   # lower = slower to starve
+fly_initial_mass = 10
+fly_mass_decrement_per_turn = 1
+vision_radius = 4                      # Chebyshev radius an agent can see other agents within
+egg_hatch_delay_turns = 3              # turns between a lay and its hatch
+fly_spawn_interval_turns = 3           # a new fly arrives every Nth turn
+eggs_eaten_threshold = 2               # flies eaten since the last egg before the next one lays
+web_duration_turns = 10                # turns a spider-built web stays active
+
+[games.guess-number]
+default_lo = 1           # the range's default lower bound, when the opening line states none
+default_hi = 100         # the range's default upper bound, when the opening line states none
+max_bound = 1000000000   # sanity cap on either bound, however the opening line states it
+
+[planning]
+max_depth = 300  # the "solve it" plan lane's search-depth cap (hanoi, river-crossing, any taught-rule domain)
 ```
 
 ### Try it on an example graph

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "2.7.22",
+  "version": "2.7.24",
   "private": false,
   "type": "module",
   "description": "The Mechanical Code Talker (tmct) — a tolerant, offline, $0 chat surface that guides you toward precision queries about a software repository. ELIZA/PARRY-style but domain-obsessed with code. No model calls; no codebase index of its own.",

package/src/adapters/toml-config.mjs

@@ -117,6 +117,14 @@ export async function normalizeConfig(raw, { configDir } = {}) {
   if (src.extensions !== undefined) cfg.extensions = src.extensions;
   if (src.bias !== undefined) cfg.bias = src.bias;
 
+  // Game tuning knobs (src/domain/game-config.mjs): sparse PASS-THROUGH only,
+  // same discipline as [extensions]/[bias] above — the raw `[games.*]`/
+  // `[planning]` tables ride through unmodified (snake_case keys); mapping
+  // them onto the internal camelCase shape and filling in unset keys from
+  // the shipped defaults is resolveGameConfig's job, never this module's.
+  if (src.games !== undefined) cfg.games = src.games;
+  if (src.planning !== undefined) cfg.planning = src.planning;
+
   const idx = src.index || {};
   const index = {};
   if (idx.languages !== undefined) index.languages = idx.languages;

package/src/domain/game-config.mjs

@@ -0,0 +1,90 @@
+// game-config.mjs — the shipped defaults for every game's tuning knobs
+// (spider-fly's mass economy, guess-the-number's default/max bounds, the
+// shared plan lane's search-depth cap) and the pure function that folds a
+// normalized tmct.toml's [games]/[planning] tables over them.
+//
+// Every other game parameter lives in the game's own taught-English world
+// definition (data/games/hanoi-3.txt and friends) and never needs a knob
+// here — only a genuine magic number with no taught-fact home does.
+//
+// Pure: no filesystem access, no module-level mutable state. resolveGameConfig
+// is safe to call once per session and the result handed around freely —
+// several games/tests running in the same process never share or mutate one
+// another's resolved config.
+
+export const DEFAULT_GAME_CONFIG = Object.freeze({
+  spiderFly: Object.freeze({
+    spiderInitialMass: 15,
+    spiderMassDecrementPerTurn: 0.5,
+    flyInitialMass: 10,
+    flyMassDecrementPerTurn: 1,
+    visionRadius: 4,
+    eggHatchDelayTurns: 3,
+    flySpawnIntervalTurns: 3,
+    eggsEatenThreshold: 2,
+    webDurationTurns: 10,
+  }),
+  guessNumber: Object.freeze({
+    defaultLo: 1,
+    defaultHi: 100,
+    maxBound: 1_000_000_000,
+  }),
+  planning: Object.freeze({
+    maxDepth: 300,
+  }),
+});
+
+// snake_case tmct.toml key -> camelCase internal key, one map per table —
+// mirrors how toml-config.mjs's normalizeConfig maps every other section
+// (e.g. [tune]) onto its own internal shape.
+const SPIDER_FLY_KEY_MAP = Object.freeze({
+  spider_initial_mass: "spiderInitialMass",
+  spider_mass_decrement_per_turn: "spiderMassDecrementPerTurn",
+  fly_initial_mass: "flyInitialMass",
+  fly_mass_decrement_per_turn: "flyMassDecrementPerTurn",
+  vision_radius: "visionRadius",
+  egg_hatch_delay_turns: "eggHatchDelayTurns",
+  fly_spawn_interval_turns: "flySpawnIntervalTurns",
+  eggs_eaten_threshold: "eggsEatenThreshold",
+  web_duration_turns: "webDurationTurns",
+});
+
+const GUESS_NUMBER_KEY_MAP = Object.freeze({
+  default_lo: "defaultLo",
+  default_hi: "defaultHi",
+  max_bound: "maxBound",
+});
+
+const PLANNING_KEY_MAP = Object.freeze({
+  max_depth: "maxDepth",
+});
+
+/** `defaults` with every key `keyMap` names overridden by its raw snake_case
+ *  counterpart in `raw`, when actually present — every unset sibling keeps
+ *  the default, so the result is always fully populated. */
+function mergeSection(defaults, raw, keyMap) {
+  const out = { ...defaults };
+  if (!raw || typeof raw !== "object") return out;
+  for (const [tomlKey, camelKey] of Object.entries(keyMap)) {
+    if (raw[tomlKey] !== undefined) out[camelKey] = raw[tomlKey];
+  }
+  return out;
+}
+
+/**
+ * Fold a normalized tmct.toml's `games`/`planning` tables (the raw sparse
+ * pass-through src/adapters/toml-config.mjs's normalizeConfig produces —
+ * snake_case keys, present only when actually set in the file) over
+ * DEFAULT_GAME_CONFIG. `toml` may be null/undefined (no tmct.toml, or one
+ * that failed to load) — every key then falls back to its default. Returns a
+ * fully populated object of the same shape as DEFAULT_GAME_CONFIG; toml value
+ * wins per key when present, default otherwise.
+ */
+export function resolveGameConfig(toml) {
+  const games = toml?.games ?? {};
+  return {
+    spiderFly: mergeSection(DEFAULT_GAME_CONFIG.spiderFly, games["spider-fly"], SPIDER_FLY_KEY_MAP),
+    guessNumber: mergeSection(DEFAULT_GAME_CONFIG.guessNumber, games["guess-number"], GUESS_NUMBER_KEY_MAP),
+    planning: mergeSection(DEFAULT_GAME_CONFIG.planning, toml?.planning, PLANNING_KEY_MAP),
+  };
+}

package/src/domain/spider-fly-world.mjs

@@ -25,9 +25,12 @@ export const WEB_DURATION_TURNS = 10;
 // FLY_INITIAL_MASS/FLY_MASS_DECREMENT_PER_TURN): a spider starves like a fly
 // does, and gains exactly a fly's remaining mass on an eat. Heavier starting
 // mass than a single fly's worth on purpose — a spider that eats nothing for
-// a while has some runway before starving.
+// a while has some runway before starving. The decrement is half a fly's own
+// (spiders live longer between meals than flies do), and — like every other
+// tunable here — overridable per session via tmct.toml's [games.spider-fly]
+// (src/domain/game-config.mjs).
 export const SPIDER_INITIAL_MASS = 15;
-export const SPIDER_MASS_DECREMENT_PER_TURN = 1;
+export const SPIDER_MASS_DECREMENT_PER_TURN = 0.5;
 
 export const cellId = (x, y) => `cell-${x}-${y}`;
 

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;
@@ -86,6 +100,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
@@ -132,6 +159,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 +172,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 +196,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 +206,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>
@@ -192,6 +252,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,6 +272,37 @@ 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();
+  });
+
   function redraw(snap) {
     const objects = roomSceneObjects(snap.rows, snap.state, snap.here);
     const sprites = [{ subject: "you", spriteClass: "adventurer" }, ...objects];
@@ -218,34 +313,66 @@ const ADVENTURE = ${pageData};
     }).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);