@polycode-projects/the-mechanical-code-talker 2.7.11 → 2.7.13

package/src/services/adventure-viz.mjs

@@ -0,0 +1,262 @@
+// adventure-viz.mjs — the adventure's own full-screen/home-page hero
+// (PLAN_GAMES_UPLIFT_V2.md Part B), styled directly after
+// spider-fly-viz.mjs's own self-contained page-builder: one inlined <style>
+// importing viz-theme.mjs's shared tokens, behaviour as an inlined IIFE, the
+// shared `createTicker` primitive spliced in via `.toString()` exactly the
+// way that page splices its own render-glue helpers.
+//
+// Where this page's data-loading DIVERGES from spider-fly's, on purpose:
+// spider-fly-world.mjs is itself a plain, dependency-free JS module (no I/O),
+// so its browser entry can call it directly to bootstrap a board. Ashcombe
+// Hall's canonical definition is a JSONL corpus source
+// (corpus/worlds/src/ashcombe-hall.jsonl), read through a Node fs/gzip
+// provider the browser cannot run. Rather than hand-duplicating the world as
+// a second, hardcoded JS copy (exactly the kind of drift this project's
+// worlds-pack build step exists to prevent), the real facts+rules are read
+// ONCE at build time (scripts/build-demo-site.mjs, the same Node path
+// test/services/adventure.test.mjs's own loadShippedWorldInto uses) and
+// embedded into this page as plain JSON — the same posture ledger.html
+// already takes with its own precomputed memory payload, just applied to a
+// second kind of build-time data.
+//
+// Two pure, `.toString()`-splice-safe pieces are exported as real functions
+// (not raw inline-script text) so they can be pinned directly by tests, the
+// same discipline spider-fly-viz.mjs holds classOfAgentId/
+// threadCellsForSpiderPlan to: `spriteClassForObject` (an object's sprite
+// class, from its own rdf:type or mgx:is-container fact — NOT from
+// adventure.mjs's private isContainer/isTyped, which this module cannot
+// 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).
+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";
+
+const DEFAULT_TITLE = "tmct — the adventure";
+const PREVIEW_MAX_TICKS = 30;
+const TICK_WAIT_MS = 900;
+
+/** An object's sprite class: `container` when it carries mgx:is-container
+ *  (a distinct icon from plain furniture, since Ashcombe's own cabinet and
+ *  portrait are typed "furniture" but read more clearly as a container on
+ *  screen), else its own rdf:type object, else the generic "portable"
+ *  fallback for anything a world places with no type fact at all. Pure,
+ *  self-contained — no reference to adventure.mjs's own private isContainer/
+ *  isTyped, since those aren't exported. */
+export function spriteClassForObject(rows, subject) {
+  const isContainer = (rows || []).some(
+    (r) => r.subject === subject && r.predicate === "mgx:is-container" && r.object === "true",
+  );
+  if (isContainer) return "container";
+  const typeRow = (rows || []).find((r) => r.subject === subject && r.predicate === "rdf:type");
+  return typeRow ? typeRow.object : "portable";
+}
+
+/** 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
+ *  hidden or carried object the text digest wouldn't also mention. `player`
+ *  is excluded; the caller draws the player's own adventurer sprite
+ *  separately. Pure. */
+export function roomSceneObjects(rows, state, here) {
+  const isTypedRoom = (subject) =>
+    (rows || []).some((r) => r.subject === subject && r.predicate === "rdf:type" && r.object === "room");
+  const visibleRoomOf = (subject) => {
+    const place = state.placements.get(subject);
+    if (!place || place.predicate === "mgx:hidden-in") return null;
+    if (place.predicate === "mgx:currently-in" || isTypedRoom(place.object)) return place.object;
+    const holder = place.object;
+    if (holder === "player") return null;
+    if (!state.openness.get(holder)?.open) return null;
+    const holderPlace = state.placements.get(holder);
+    return holderPlace && holderPlace.predicate !== "mgx:hidden-in" ? holderPlace.object : null;
+  };
+  const out = [];
+  for (const subject of [...state.placements.keys()].sort()) {
+    if (subject === "player") continue;
+    if (visibleRoomOf(subject) !== here) continue;
+    out.push({ subject, spriteClass: spriteClassForObject(rows, subject) });
+  }
+  return out;
+}
+
+/** 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
+ *  (`${subject} ${predicate} ${object}.`), so this never invents a phrase
+ *  the text digest doesn't already carry. Filters to rows about the room
+ *  itself (its own exits) or about something placed IN it — the same
+ *  "visible here" boundary `roomSceneObjects` draws from. The player's own
+ *  "is in the" row is excluded: the room frame already IS the current room,
+ *  so restating "you are here" is redundant, never informative. */
+export function roomCaptionText(rows, state, here) {
+  const hereCased = here.charAt(0).toUpperCase() + here.slice(1);
+  const lines = worldDigestRows(rows, state)
+    .filter((row) => row.subject !== "Player" && (row.object === here || row.subject === hereCased))
+    .map((row) => `${row.subject} ${row.predicate} ${row.object}.`);
+  return lines.length ? lines.join(" ") : `Nothing more about the ${here} is written down yet.`;
+}
+
+/** 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: "" } } = {}) {
+  const pageData = embedJson({
+    world: worldPayload,
+    previewMaxTicks: PREVIEW_MAX_TICKS,
+    tickWaitMs: TICK_WAIT_MS,
+  });
+
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(title)}</title>
+<style>
+${THEME_TOKENS_CSS}
+  html { background: var(--bg); }
+  body { margin: 0; background: var(--bg); color: var(--ink); font-family: ${SERIF_STACK}; font-size: 16px; line-height: 1.5; }
+  .mono { font-family: ${MONO_STACK}; }
+  main { max-width: 860px; margin: 0 auto; padding: 1.4rem 1.2rem 2.2rem; }
+  .eyebrow { font-family: ${MONO_STACK}; font-size: .7rem; letter-spacing: .08em; text-transform: uppercase; color: var(--muted); }
+  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; }
+  .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; }
+  .sprite svg { width: 100%; height: 100%; display: block; }
+  .sprite[data-cls="adventurer"] { color: var(--taught); }
+  .sprite[data-cls="person"] { color: var(--corpus); }
+  .sprite[data-cls="container"], .sprite[data-cls="furniture"] { color: var(--entail); }
+  .sprite[data-cls="portable"] { color: var(--alert); }
+  .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; }
+  .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); }
+  .controls-row button:disabled { opacity: .4; cursor: default; }
+  .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 main { padding: 0; max-width: none; }
+  body.preview .eyebrow, body.preview h1 { display: none; }
+</style>
+</head>
+<body>
+<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>
+  <div class="caption" id="caption"></div>
+  <div class="goal-line" id="goalLine"></div>
+  <div class="controls-row">
+    <button id="resetBtn" type="button" disabled>reset</button>
+    <button id="playBtn" type="button" disabled>&#9654; play</button>
+    <button id="stepBtn" type="button" disabled>step</button>
+    <span class="turn mono" id="turnLabel">turn: 0</span>
+  </div>
+  <div class="status" id="status">loading the engine&hellip;</div>
+</main>
+<script>
+const ADVENTURE = ${pageData};
+</script>
+<script src="./adventure-browser.bundle.js"></script>
+<script>
+(function () {
+  "use strict";
+  const createTicker = ${createTicker.toString()};
+  const spriteClassForObject = ${spriteClassForObject.toString()};
+  const roomSceneObjects = ${roomSceneObjects.toString()};
+  const esc = ${escapeHtml.toString()};
+  const el = (id) => document.getElementById(id);
+  const spriteRow = el("spriteRow");
+  const captionEl = el("caption");
+  const goalLineEl = el("goalLine");
+  const statusEl = el("status");
+  const turnLabelEl = el("turnLabel");
+  const resetBtn = el("resetBtn");
+  const playBtn = el("playBtn");
+  const stepBtn = el("stepBtn");
+
+  const params = new URLSearchParams(location.search);
+  const preview = params.get("preview") === "1";
+  document.body.classList.toggle("preview", preview);
+
+  let session = null;
+  let lastTicks = 0;
+
+  function captionFor(rows, state, here) {
+    const hereCased = here.charAt(0).toUpperCase() + here.slice(1);
+    const lines = tmctAdventure.worldDigestRows(rows, state)
+      .filter((row) => row.subject !== "Player" && (row.object === here || row.subject === hereCased))
+      .map((row) => row.subject + " " + row.predicate + " " + row.object + ".");
+    return lines.length ? lines.join(" ") : "Nothing more about the " + here + " is written down yet.";
+  }
+
+  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);
+      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;
+  }
+
+  async function boot() {
+    session = await tmctAdventure.createAdventureSession(ADVENTURE.world);
+    lastTicks = 0;
+    const snap = await session.snapshot();
+    redraw(snap);
+    goalLineEl.textContent = "";
+    statusEl.textContent = ADVENTURE.world.opening || "";
+    resetBtn.disabled = false; playBtn.disabled = false; stepBtn.disabled = false;
+  }
+
+  const ticker = createTicker({
+    onTick: async () => {
+      const result = await session.autoplayTick();
+      lastTicks += 1;
+      const snap = await session.snapshot();
+      redraw(snap);
+      goalLineEl.textContent = 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(),
+    hasNext: () => !preview || lastTicks < ADVENTURE.previewMaxTicks,
+    waitMs: ADVENTURE.tickWaitMs,
+  });
+  playBtn.addEventListener("click", () => ticker.play());
+  stepBtn.addEventListener("click", () => ticker.stepOnce());
+  resetBtn.addEventListener("click", () => ticker.reset());
+
+  boot().then(() => { if (preview) ticker.play(); });
+})();
+</script>
+</body>
+</html>
+`;
+}

package/src/services/adventure.mjs

@@ -12,6 +12,7 @@ import { worldProvenanceTag } from "../domain/worlds-pack.mjs";
 import { parseImperative } from "../domain/grammar/ace.mjs";
 import { createCompletionsGraphAdapter } from "../domain/completions/graph-adapter.mjs";
 import { actionFamilies } from "../domain/router/taught.mjs";
+import { compileDomain, precondHolds, roleBinding } from "../domain/domain.mjs";
 import { getWorldsPackProvider } from "../adapters/corpus/worlds-pack.mjs";
 import { appendFacts, appendRule, loadMemory, normFactTerm, readFactRows, readRuleRows } from "../adapters/memory/core.mjs";
 import { COMPLETIONS_STORE, generateCompletion } from "./completions.mjs";
@@ -78,7 +79,12 @@ async function openAdventure(opening, { planHolder, memoryDir, sessionId, env, c
     world = names[0];
   } else if (!names.includes(world)) {
     // An unknown "play X" is not necessarily an adventure ask at all ("play
-    // chess") — fall through to the ordinary lanes rather than claim it.
+    // spider" is spider-fly's own opener, not a broken adventure request) —
+    // fall through so a sibling game's opener keeps first refusal.
+    // unclaimedAdventureOpening below is chat's LAST-RESORT check: once
+    // every "play X" lane (this one included) has had its turn and none
+    // claimed the line, THAT'S when an unrecognized name gets named and
+    // declined honestly, never silently.
     return null;
   }
 
@@ -125,6 +131,31 @@ async function openAdventure(opening, { planHolder, memoryDir, sessionId, env, c
   };
 }
 
+/** chat's LAST-RESORT check for a named opener no lane claimed — "play
+ *  atlantis" when the pack has worlds but none is called that. Called AFTER
+ *  every other "play X"-shaped lane (spider-fly's own opener among them) has
+ *  already had its chance, so this never steals a name a sibling game
+ *  recognizes as its own (openAdventure's own fallthrough above stays
+ *  silent for exactly that reason). Only once nothing else wanted the line
+ *  does it get named and declined, rather than answered with an unrelated
+ *  generic non-answer. Null when the line isn't a named opener at all, or
+ *  the pack has no worlds (openAdventure's own first pass already gave that
+ *  case its honest missingPackAnswer, before any lane got a turn), or the
+ *  name IS one of the pack's — never re-decides a real hit. */
+export async function unclaimedAdventureOpening(line, { env }) {
+  const opening = matchAdventureOpening(line);
+  if (!opening?.world) return null;
+  const provider = getWorldsPackProvider(env);
+  let names = null;
+  try { names = await provider.list(); } catch { names = null; }
+  if (!names || !names.length || names.includes(opening.world)) return null;
+  return {
+    text: `I don't know a world called "${spokenNameOf(opening.world)}" — the pack has: ${names.map(spokenNameOf).join(", ")}.`,
+    lane: "game-inform",
+    note: `ADVENTURE — last-resort opening decline: "${opening.world}" names no world in the pack (has: ${names.join(", ")}), and no other lane claimed the line either`,
+  };
+}
+
 /** A resumed game's current room: non-null only when earlier @turnN
  *  snapshots exist (the world was already played in this store), folded the
  *  same way every other reader folds them. A fresh world returns null and
@@ -264,8 +295,10 @@ const affordanceSuffix = (actions) => (actions.length ? ` You can: ${actions.joi
 
 /** The effect predicate a family writes (its action-effect row's slot, with
  *  the mgx: prefix rule readers re-attach). Null when the family carries no
- *  effect row — the open/unlock/close families, whose datatype state writes
- *  have no shipped effect shape yet and ride the container logic below. */
+ *  effect row — unlock's family stays signature-only (its instrument match
+ *  needs a third, externally-supplied binding no shipped rule shape covers)
+ *  and rides the hand-written logic below; go/take/drop/give/open/close all
+ *  carry real effect rows and never hit this null. */
 function familyEffectPredicate(family) {
   const effect = (family || []).find((r) => r.kind === "action-effect");
   if (!effect?.slots?.predicate) return null;
@@ -449,6 +482,24 @@ function containerStatusPhrase(object, { state }) {
     : `the ${object} is open. It's empty.`;
 }
 
+/** `object`'s own datatype facts (its placement predicate, its open/closed
+ *  flag), as the tiny {subject,predicate,object} row set a "fact-value"
+ *  precond needs — read from the already-folded CURRENT truth (state.
+ *  placements/state.openness), never raw @turnN rows, so a superseded
+ *  snapshot can never look current. domain.mjs's own stateFromFacts can't
+ *  serve this: it keys "current" off an @stepN suffix (this world writes
+ *  @turnN) and restricts rows to individuals typed into some action's
+ *  SUBJECT class, which "furniture" (the container's own class) never is —
+ *  a container's own facts about itself would silently vanish through it. */
+function containerDatatypeState(state, object) {
+  const rows = [];
+  const place = state.placements.get(object);
+  if (place) rows.push({ subject: object, predicate: place.predicate, object: place.object });
+  const openness = state.openness.get(object);
+  if (openness) rows.push({ subject: object, predicate: OPEN_PREDICATE, object: openness.open ? "true" : "false" });
+  return rows;
+}
+
 async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
   const memory = await loadMemory(memoryDir);
   const rows = readFactRows(memory);
@@ -512,7 +563,8 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
     );
   }
 
-  const families = actionFamilies(readRuleRows(memory));
+  const ruleRows = readRuleRows(memory);
+  const families = actionFamilies(ruleRows);
   const family = families.get(cmd.verb);
   if (!family) {
     return answer(
@@ -619,9 +671,15 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
     );
   }
 
-  // open / unlock / close — the container verbs. Their families are
-  // signature-only (no shipped rule shape for a datatype effect yet), so the
-  // state writes are the closed container vocabulary below.
+  // open / unlock / close — the container verbs. presence and container-ness
+  // stay hand-checked here (visibility gating, not a state precondition);
+  // unlock's instrument match stays fully hand-written below it too — it
+  // needs a third, externally-supplied binding beyond subject/target, which
+  // this retrofit does not attempt. open/close's lock-state and open/closed
+  // checks, and their mgx:is-open write, are now taught "fact-value"
+  // 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) {
     return answer(`I don't see a ${object} here.`, noteFor(`${cmd.verb} — ${object} isn't in the ${here}; declined`), { miss: true });
@@ -629,40 +687,50 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
   if (!isContainer(rows, object)) {
     return answer(`the ${object} doesn't open.`, noteFor(`${cmd.verb} — no mgx:is-container fact on ${object}; declined by name`), { miss: true });
   }
-  const open = !!state.openness.get(object)?.open;
 
-  if (cmd.verb === "open") {
-    if (place.predicate === "mgx:stands-locked-in") {
-      return answer(`the ${object} is locked.`, noteFor(`open — ${object} stands locked; precondition declined by name`), { miss: true });
+  if (cmd.verb === "open" || cmd.verb === "close") {
+    const domain = compileDomain(rows, ruleRows);
+    const taughtAction = domain.actions.find((a) => a.name === cmd.verb);
+    const effect = taughtAction?.effects.find((e) => e.predicate === OPEN_PREDICATE);
+    if (!effect) {
+      return answer(
+        `this world doesn't teach how ${cmd.verb === "open" ? "opening" : "closing"} changes the ${object}.`,
+        noteFor(`${cmd.verb} — the taught "${cmd.verb}" family carries no ${OPEN_PREDICATE} effect; honest decline`),
+        { miss: true },
+      );
     }
-    if (open) {
-      return answer(`the ${object} is already open.`, noteFor("open — already open; declined"), { miss: true });
+    const factState = containerDatatypeState(state, object);
+    const failed = taughtAction.preconds.find((p) => !precondHolds(p, "player", object, factState, domain));
+    if (failed) {
+      const text = failed.predicate === "mgx:stands-locked-in"
+        ? `the ${object} is locked.`
+        : cmd.verb === "open" ? `the ${object} is already open.` : `the ${object} isn't open.`;
+      return answer(text, noteFor(`${cmd.verb} — the taught "${cmd.verb}" family's ${failed.predicate} precondition declined by name`), { miss: true });
     }
-    const revealed = [...state.placements]
-      .filter(([, p]) => p.predicate === "mgx:hidden-in" && p.object === object)
-      .map(([thing]) => thing)
-      .sort();
-    return commit(
-      [
-        { subject: `${object}@turn${k}`, predicate: "mgx:is-open", object: "true" },
-        ...revealed.map((thing) => ({ subject: `${thing}@turn${k}`, predicate: "mgx:located-in", object })),
-      ],
-      revealed.length
-        ? `you open the ${object} — inside: the ${revealed.join(", the ")}.`
-        : `you open the ${object}. It's empty.`,
-      `open — ${object} opens${revealed.length ? `, revealing ${revealed.join(", ")}` : ""}`,
-      `open the ${object}`,
-    );
-  }
-
-  if (cmd.verb === "close") {
-    if (!open) {
-      return answer(`the ${object} isn't open.`, noteFor("close — not open; declined"), { miss: true });
+    const effSubject = roleBinding(effect.subjectRole, "player", object, domain);
+    const writeIsOpen = { subject: `${effSubject}@turn${k}`, predicate: effect.predicate, object: effect.value };
+
+    if (cmd.verb === "open") {
+      const revealed = [...state.placements]
+        .filter(([, p]) => p.predicate === "mgx:hidden-in" && p.object === object)
+        .map(([thing]) => thing)
+        .sort();
+      return commit(
+        [
+          writeIsOpen,
+          ...revealed.map((thing) => ({ subject: `${thing}@turn${k}`, predicate: "mgx:located-in", object })),
+        ],
+        revealed.length
+          ? `you open the ${object} — inside: the ${revealed.join(", the ")}.`
+          : `you open the ${object}. It's empty.`,
+        `open — ${object} opens${revealed.length ? `, revealing ${revealed.join(", ")}` : ""} via the taught "open" family's effect`,
+        `open the ${object}`,
+      );
     }
     return commit(
-      [{ subject: `${object}@turn${k}`, predicate: "mgx:is-open", object: "false" }],
+      [writeIsOpen],
       `you close the ${object}.`,
-      `close — ${object} closes`,
+      `close — ${object} closes via the taught "close" family's effect`,
       `close the ${object}`,
     );
   }

package/src/services/chat.mjs

@@ -52,7 +52,7 @@ import { CHILD_PACK_NAME, childProvenanceTag } from "../domain/child-pack.mjs";
 import { getChildPackProvider } from "../adapters/corpus/child-pack.mjs";
 import { dialogueActForLane } from "../domain/dialogue-acts.mjs";
 import { relatedForTerm } from "../domain/skos-view.mjs";
-import { adventureTurn } from "./adventure.mjs";
+import { adventureTurn, unclaimedAdventureOpening } from "./adventure.mjs";
 import { spiderFlyTurn } from "./spider-fly-turn.mjs";
 
 // Composition: the chat surface supplies the domain parser's default lemma/POS
@@ -12646,6 +12646,24 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     }
   }
 
+  // A "play X" naming no world EITHER game lane above claimed — last resort,
+  // checked only once the adventure lane's own fallthrough and spider-fly's
+  // own opener have both passed on the line, so this never outguesses a
+  // sibling game's own recognized phrasing. Honest by name ("I don't know a
+  // world called…") rather than the generic non-answer an unclaimed opener
+  // fell into before.
+  {
+    const unclaimed = await unclaimedAdventureOpening(workingLine, { env });
+    if (unclaimed) {
+      note(trace, `lane: ${unclaimed.note}`);
+      const result = plainTurn(workingLine, unclaimed.text, { via: "game", miss: true, focus });
+      result.lane = unclaimed.lane;
+      const rec = withLast(result, "play the adventure");
+      rec.planState = planHolder.state;
+      return rec;
+    }
+  }
+
   // Conversational layer next (greetings, thanks, help, bye, why/say-more) — these
   // resolve no entity and carry their own preserved `last`. Bypasses withLast (a
   // conversational turn is never finish()'d / never becomes a new `last`), so the

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

@@ -33,6 +33,7 @@
 import { THEME_TOKENS_CSS, SERIF_STACK, MONO_STACK, escapeHtml, embedJson } from "./viz-theme.mjs";
 import { createTicker } from "./viz-ticker.mjs";
 import { GRID_SIZE, WEB_HOME, WEB_RADIUS, isInWebBlock, cellId } from "../domain/spider-fly-world.mjs";
+import { FLY_INITIAL_MASS, SPIDER_INITIAL_MASS } from "./spider-fly.mjs";
 
 const CELL_PX = 44;
 const BOARD_PX = CELL_PX * GRID_SIZE;
@@ -111,6 +112,8 @@ export function renderSpiderFlyHtml({ title = DEFAULT_TITLE } = {}) {
     cellPx: CELL_PX,
     previewMaxTurns: PREVIEW_MAX_TURNS,
     tickWaitMs: TICK_WAIT_MS,
+    maxFlyMass: FLY_INITIAL_MASS,
+    maxSpiderMass: SPIDER_INITIAL_MASS,
   });
 
   return `<!doctype html>
@@ -154,6 +157,9 @@ ${THEME_TOKENS_CSS}
   .hud-id { font-family: ${MONO_STACK}; font-size: .74rem; }
   .hud-id.spider { color: var(--taught); } .hud-id.fly { color: var(--fly); } .hud-id.egg { color: var(--muted); }
   .hud-goal { font-size: .85rem; }
+  .mass-track { height: 4px; margin-top: .3rem; background: var(--line); border-radius: 2px; overflow: hidden; }
+  .mass-fill { height: 100%; background: var(--taught); }
+  .mass-fill.fly { background: var(--fly); }
   .hud-empty { color: var(--muted); font-size: .85rem; }
   .chatlog { display: flex; flex-direction: column; gap: .4rem; max-height: 220px; overflow-y: auto; margin-bottom: .5rem; }
   .chatlog:empty { display: none; margin-bottom: 0; }
@@ -264,6 +270,7 @@ const SPIDERFLY = ${gridData};
   // ---- state shared across redraws --------------------------------------
   let session = null;
   let lastAgents = {};
+  let lastActiveWebs = [];
   let lastTurn = 0;
   const goalById = {};
   const spriteEls = {};
@@ -324,13 +331,21 @@ const SPIDERFLY = ${gridData};
     lastAgents = agents;
   }
 
+  function massBarHtml(cls, mass) {
+    const maxMass = cls === "spider" ? SPIDERFLY.maxSpiderMass : cls === "fly" ? SPIDERFLY.maxFlyMass : null;
+    if (typeof mass !== "number" || !maxMass) return "";
+    const pct = Math.max(0, Math.min(100, (mass / maxMass) * 100));
+    return '<div class="mass-track"><div class="mass-fill ' + esc(cls) + '" style="width:' + pct + '%"></div></div>';
+  }
+
   function renderHud() {
     const ids = Object.keys(lastAgents).sort();
     if (!ids.length) { hudEl.innerHTML = '<div class="hud-empty">no agents on the board.</div>'; return; }
     hudEl.innerHTML = ids.map((id) => {
       const cls = classOfAgentId(id);
       return '<div class="hud-row"><span class="hud-id ' + esc(cls) + '">' + esc(id) + '</span>'
-        + '<span class="hud-goal">' + esc(goalById[id] || "watching\\u2026") + "</span></div>";
+        + '<span class="hud-goal">' + esc(goalById[id] || "watching\\u2026") + "</span>"
+        + massBarHtml(cls, lastAgents[id].mass) + "</div>";
     }).join("");
   }
 
@@ -340,7 +355,7 @@ const SPIDERFLY = ${gridData};
     directionDelta: tmctSpiderFly.DIRECTION_DELTA,
   };
 
-  function drawBoard(agents) {
+  function drawBoard(agents, activeWebs) {
     const w = SPIDERFLY.boardPx, h = SPIDERFLY.boardPx;
     boardCtx.clearRect(0, 0, w, h);
     boardCtx.fillStyle = cssVar("--taught-soft") || "rgba(46,125,79,.12)";
@@ -348,6 +363,20 @@ const SPIDERFLY = ${gridData};
       const p = tmctSpiderFly.parseCellId(wc);
       boardCtx.fillRect((p.x - 1) * cellSize, (p.y - 1) * cellSize, cellSize, cellSize);
     }
+    // A spider-built dynamic web is a distinct color from the always-on
+    // static home zone above, plus a dashed outline — same concept
+    // (hasActiveWebAt), visually two different things on the board.
+    boardCtx.fillStyle = cssVar("--alert-soft") || "rgba(176,80,63,.12)";
+    boardCtx.strokeStyle = cssVar("--alert") || "#B0503F";
+    boardCtx.lineWidth = 1;
+    boardCtx.setLineDash([3, 2]);
+    for (const web of activeWebs || []) {
+      const p = tmctSpiderFly.parseCellId(web.cell);
+      if (!p) continue;
+      boardCtx.fillRect((p.x - 1) * cellSize, (p.y - 1) * cellSize, cellSize, cellSize);
+      boardCtx.strokeRect((p.x - 1) * cellSize + 0.5, (p.y - 1) * cellSize + 0.5, cellSize - 1, cellSize - 1);
+    }
+    boardCtx.setLineDash([]);
     boardCtx.strokeStyle = cssVar("--line") || "#DDD9D0";
     boardCtx.lineWidth = 1;
     for (let i = 0; i <= SPIDERFLY.gridSize; i += 1) {
@@ -406,12 +435,13 @@ const SPIDERFLY = ${gridData};
   });
   boardFrame.addEventListener("mouseleave", () => { threadTip.style.display = "none"; });
 
-  function redraw(agents, turn) {
+  function redraw(agents, turn, activeWebs) {
     applyAgents(agents);
     renderHud();
     lastTurn = turn;
+    lastActiveWebs = activeWebs || [];
     turnLabelEl.textContent = "turn: " + turn;
-    drawBoard(agents);
+    drawBoard(agents, lastActiveWebs);
     drawPov();
   }
 
@@ -431,7 +461,7 @@ const SPIDERFLY = ${gridData};
       const result = await session.turn(q);
       addChatLine("a", esc(result.answer).replace(/\\n/g, "<br>"));
       const snap = await session.snapshot();
-      redraw(snap.agents, snap.turn);
+      redraw(snap.agents, snap.turn, snap.activeWebs);
     });
   });
 
@@ -447,7 +477,7 @@ const SPIDERFLY = ${gridData};
 
   async function boot() {
     session = await tmctSpiderFly.createSpiderFlySession();
-    redraw(session.initial.agents, session.initial.turn);
+    redraw(session.initial.agents, session.initial.turn, session.initial.activeWebs);
     statusEl.textContent = session.opening;
     chatqEl.disabled = false;
     resetBtn.disabled = false; playBtn.disabled = false; stepBtn.disabled = false;
@@ -457,7 +487,7 @@ const SPIDERFLY = ${gridData};
   const ticker = createTicker({
     onTick: () => withLock(async () => {
       const result = await session.tick();
-      redraw(result.agents, result.turn);
+      redraw(result.agents, result.turn, result.activeWebs);
     }),
     onRender: (state) => {
       playBtn.textContent = state.playing ? "\\u23f8 pause" : "\\u25b6 play";
@@ -479,10 +509,10 @@ const SPIDERFLY = ${gridData};
 
   boot().then(() => { if (preview) ticker.play(); });
 
-  new MutationObserver(() => { drawBoard(lastAgents); drawPov(); })
+  new MutationObserver(() => { drawBoard(lastAgents, lastActiveWebs); drawPov(); })
     .observe(document.documentElement, { attributes: true, attributeFilter: ["data-theme"] });
   if (window.matchMedia) {
-    window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", () => { drawBoard(lastAgents); drawPov(); });
+    window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", () => { drawBoard(lastAgents, lastActiveWebs); drawPov(); });
   }
 })();
 </script>