@polycode-projects/the-mechanical-code-talker 5.0.5 → 5.0.7

package/src/domain/memory/capability.mjs

@@ -18,7 +18,7 @@
 //
 // Pure and import-free of core.mjs, exactly like trust.mjs beside it.
 
-import { findIsaChain, SUBCLASS_PREDICATE, TYPE_PREDICATE } from "../syllogise.mjs";
+import { findIsaChain, buildSubClassSuccessors, SUBCLASS_PREDICATE, TYPE_PREDICATE } from "../syllogise.mjs";
 
 /** The negative-polarity CURIE prefix. A separate prefix, never an
  *  "mgx:not-<lemma>" mint: chat.mjs's predicatePhrase reads "mgx:not-fly" as
@@ -78,10 +78,14 @@ const byTrustThenName = (a, b) => (b.trust || 0) - (a.trust || 0) || String(a.su
 
 const asSet = (v) => (v instanceof Set ? v : new Set(Array.isArray(v) ? v : [v]));
 
-const isaEdgesOf = (facts) => ({
-  typeEdges: facts.filter((f) => f.predicate === TYPE_PREDICATE).map((f) => [f.subject, f.object]),
-  subClassEdges: facts.filter((f) => f.predicate === SUBCLASS_PREDICATE).map((f) => [f.subject, f.object]),
-});
+// The ⊑ adjacency is built here, once per call, rather than inside each chase:
+// every caller below chases many subjects over the same edges, and rebuilding
+// the index per chase makes one small search cost the whole edge set.
+const isaEdgesOf = (facts) => {
+  const typeEdges = facts.filter((f) => f.predicate === TYPE_PREDICATE).map((f) => [f.subject, f.object]);
+  const subClassEdges = facts.filter((f) => f.predicate === SUBCLASS_PREDICATE).map((f) => [f.subject, f.object]);
+  return { typeEdges, subClassSucc: buildSubClassSuccessors(subClassEdges) };
+};
 
 /** The shortest isa chain from any spelling of `subjects` up to `target`, or
  *  null. The chase is corpus-INCLUSIVE on purpose, and that is a considered
@@ -90,11 +94,11 @@ const isaEdgesOf = (facts) => ({
  *  would be fabrication. Here the premise being chased to — "bird can fly" — is
  *  itself corpus data on a fresh install, so a taught-only chase would find
  *  nothing to inherit and the whole feature would never fire. */
-function shortestChainTo(subjects, target, typeEdges, subClassEdges, maxHops) {
+function shortestChainTo(subjects, target, typeEdges, subClassSucc, maxHops) {
   let best = null;
   for (const s of subjects) {
     if (s === target) return [];
-    const chain = findIsaChain(s, new Set([target]), typeEdges, subClassEdges, { maxHops });
+    const chain = findIsaChain(s, new Set([target]), typeEdges, subClassSucc, { maxHops });
     if (chain && (!best || chain.length < best.length)) best = chain;
   }
   return best;
@@ -126,7 +130,7 @@ export function resolveCapabilityPolarity(subject, object, facts, { maxHops = 3
   const subjects = asSet(subject);
   const objects = asSet(object);
   const rows = Array.isArray(facts) ? facts : [];
-  const { typeEdges, subClassEdges } = isaEdgesOf(rows);
+  const { typeEdges, subClassSucc } = isaEdgesOf(rows);
 
   const carriers = rows.filter(
     (f) => (f.predicate === CAPABLE_OF_PREDICATE || f.predicate === NEG_CAPABLE_OF_PREDICATE) && objects.has(f.object),
@@ -139,7 +143,7 @@ export function resolveCapabilityPolarity(subject, object, facts, { maxHops = 3
       candidates.push({ fact, polarity, hops: 0, chain: null });
       continue;
     }
-    const chain = shortestChainTo(subjects, fact.subject, typeEdges, subClassEdges, maxHops);
+    const chain = shortestChainTo(subjects, fact.subject, typeEdges, subClassSucc, maxHops);
     if (chain && chain.length) candidates.push({ fact, polarity, hops: chain.length, chain });
   }
 
@@ -212,14 +216,14 @@ export function capabilityBaseRate(subject, object, facts, { maxHops = 3 } = {})
   };
 
   const split = siblings.map(capabilityOf);
-  const { typeEdges, subClassEdges } = isaEdgesOf(rows);
+  const { typeEdges, subClassSucc } = isaEdgesOf(rows);
   return {
     klass,
     kinds: siblings.length,
     positive: split.filter((s) => s.polarity === "positive"),
     negative: split.filter((s) => s.polarity === "negative"),
     unknown: split.filter((s) => s.polarity === "unknown"),
-    chain: shortestChainTo(subjects, klass, typeEdges, subClassEdges, maxHops),
+    chain: shortestChainTo(subjects, klass, typeEdges, subClassSucc, maxHops),
   };
 }
 

package/src/domain/router/drive.mjs

@@ -56,11 +56,14 @@ const refuse = (why, driver) => ({ calls: [], refused: true, terminated: true, p
 
 /** Execute the MEMBER-FILTER HTN method ("which methods of X end up calling Y")
  *  — the per-member hop the single-shot resolver cannot emit on its own. Step 1
- *  grounds members(X) via resolveOne; then, per CALLABLE member (sorted, bounded
- *  by the planner's MAX_STEPS budget), one tmct_callees hop. The fold is
- *  membersReaching (the bounded transitive callsSymbol closure), computed over
- *  the graph, never parsed from text. Honest refuses: no tmct_callees in the
- *  declared toolset, an unbindable filter target, an over-budget member list. */
+ *  grounds members(X) via resolveOne; then, per CALLABLE member (sorted), one
+ *  tmct_callees hop, so long as the whole list fits the planner's MAX_STEPS
+ *  budget. The fold is membersReaching (the bounded transitive callsSymbol
+ *  closure), computed over the graph, never parsed from text — it covers every
+ *  member whether or not the hops were emitted, so a class with more members
+ *  than the plan budget allows gets the same answer with a fold step in the
+ *  proof in place of the hop chain. Honest refuses: no tmct_callees in the
+ *  declared toolset, an unbindable filter target, an ungrounded member list. */
 async function memberFilterDrive(request, tools, ctx, segments) {
   const [setSeg, filterSeg] = segments;
   if (!tools.includes("tmct_callees")) {
@@ -81,29 +84,45 @@ async function memberFilterDrive(request, tools, ctx, segments) {
   const proof = [{ step: "causal-link", producer: "graph", condition: classInd.label, consumer: `step-1:${r1.selected.name}`, role: "action", ok: true }];
   for (const s of r1.proof) proof.push({ ...s, ofStep: 1 });
   const why = [
-    `HTN method: member-filter — enumerate members(${classInd.label}), hop tmct_callees per callable member, fold by bounded transitive reach of ${target.label}`,
+    `HTN method: member-filter — enumerate members(${classInd.label}), fold by bounded transitive reach of ${target.label} over every callable member, and hop tmct_callees per member while that hop chain fits the plan budget`,
     ...(r1.why || []).map((w) => `[1] ${w}`),
   ];
 
   const members = memberIndividuals(ctx.graph, classInd)
     .filter((m) => CALLABLE_MEMBER_CLASSES.has(m.class))
     .sort((a, b) => String(a.label).localeCompare(String(b.label)));
-  if (1 + members.length > MAX_STEPS) {
-    return refuse(`member-filter needs ${1 + members.length} steps (> budget ${MAX_STEPS}) — escalate`, ROUTER_DRIVER);
-  }
-  for (let i = 0; i < members.length; i += 1) {
-    const m = members[i];
-    const res = await ctx.dispatch("tmct_callees", { symbol: m.label });
-    if (!res.ok) return refuse(`the callees hop for ${m.label} did not ground: ${res.error}`, ROUTER_DRIVER);
-    calls.push({ name: "tmct_callees", input: { symbol: m.label } });
-    proof.push({ step: "causal-link", producer: "step-1", condition: m.label, consumer: `step-${i + 2}:tmct_callees`, role: "member-filter", ok: true });
-    why.push(`[${i + 2}] callees hop over ${m.label} (a member step 1 produced)`);
+  // MAX_STEPS bounds the emitted PLAN, not the answer. The fold below reads the
+  // graph's own callsSymbol edges in one pass over every member at any member
+  // count, so a member list too long to walk hop by hop still gets folded — it
+  // just gets no per-member hops. All of them or none: emitting the first seven
+  // of ninety-nine would read as "these are the members I checked", which is a
+  // trace of work nobody did.
+  const hopsFitTheBudget = 1 + members.length <= MAX_STEPS;
+  if (hopsFitTheBudget) {
+    for (let i = 0; i < members.length; i += 1) {
+      const m = members[i];
+      const res = await ctx.dispatch("tmct_callees", { symbol: m.label });
+      if (!res.ok) return refuse(`the callees hop for ${m.label} did not ground: ${res.error}`, ROUTER_DRIVER);
+      calls.push({ name: "tmct_callees", input: { symbol: m.label } });
+      proof.push({ step: "causal-link", producer: "step-1", condition: m.label, consumer: `step-${i + 2}:tmct_callees`, role: "member-filter", ok: true });
+      why.push(`[${i + 2}] callees hop over ${m.label} (a member step 1 produced)`);
+    }
+  } else {
+    proof.push({
+      step: "graph-fold", producer: "step-1", condition: target.label,
+      consumer: `fold:membersReaching(${classInd.label})`, role: "member-filter",
+      members: members.length, hops: 0, ok: true,
+    });
+    why.push(`[2] ${members.length} callable members needs a ${1 + members.length}-step plan against a budget of ${MAX_STEPS}, so no per-member callees hop was dispatched — the fold reads the same callsSymbol edges those hops would have reported, over every one of the ${members.length}`);
   }
 
   const composed = membersReaching(ctx.graph, classInd, target.label);
+  const trace = hopsFitTheBudget
+    ? calls.map((c) => c.name).join(" -> ")
+    : `${calls.map((c) => c.name).join(" -> ")} + graph fold over ${members.length} members`;
   return {
     calls, refused: false, terminated: true, proof, driver: ROUTER_DRIVER, why, composed,
-    observed: `plan(member-filter): ${calls.map((c) => c.name).join(" -> ")} => {${composed.join(", ")}}`,
+    observed: `plan(member-filter): ${trace} => {${composed.join(", ")}}`,
   };
 }
 

package/src/domain/router/resolver.mjs

@@ -36,6 +36,17 @@ const SUPERLATIVE_RE = new RegExp(
   "i",
 );
 
+// A PAST-TENSE report of an action already taken ("I ran the impact of X",
+// "someone called tmct_impact then tmct_untested"). The frames below key on topic
+// words with no tense test, so `\bimpacts?\b` fires on a narration exactly as it
+// does on an instruction and the router re-runs what the speaker said they had
+// already done. Closed and past-tense only, in both the subject and the verb: a
+// present-tense request ("run the impact of X", "I need the impact of X", "if I
+// run impact then the untested scan") must keep binding, so no bare
+// run/check/list here and no subjectless verb.
+const NARRATED_ACTION_RE =
+  /\b(?:i|we|you|they|someone|somebody)\s+(?:just\s+|already\s+|first\s+|then\s+|earlier\s+|previously\s+)?(?:ran|looked|listed|checked|called|did|used|inspected|described|viewed|examined|dumped|traced|printed|queried|opened|walked|pulled)\b/i;
+
 // ---- the ask-kind -> epistemic-topic MAPPING (the Stage-1 core) --------------
 // Keyed `${shape}:${kind}` off parseQuery's output. Every topic must be achievable by
 // exactly one registered capability (the bidirectional conformance test proves it).
@@ -218,6 +229,10 @@ export function mapParse(parse) {
 /** Match an imperative FRAME. Returns { name, arg|noArg, term, topic, source:"frame", why }
  *  or null. Backward-chains the frame's topic to a capability. */
 export function mapFrame(request) {
+  // A narrated trace is a report of work already done. Claiming it here dispatches
+  // that work a second time and calls the data an answer to "what am I trying to
+  // do", so the frames decline and the request goes on to the goal-reasoner.
+  if (NARRATED_ACTION_RE.test(request)) return null;
   for (const f of FRAMES) {
     if (!f.re.test(request)) continue;
     if (f.skipIfSuperlative && SUPERLATIVE_RE.test(request)) continue;
@@ -345,6 +360,40 @@ function testModuleTie(graph, matchInd, candidateInd) {
     || (e.subject === candidateInd.id && e.object === matchInd.id));
 }
 
+/** The tied-read check EVERY binding path runs, so one term cannot mean two
+ *  things down one route and one thing down another. A tie is either
+ *  resolveObject's own score tie (r.ambiguous) or a same-tier candidate the
+ *  graph's `tests` edge ties to the match. Returns the enumerate-or-refuse
+ *  answer — a refusal carrying one dispatched read per tied reading — or null
+ *  when the term names exactly one entity. `siblingTie` is off for a memory-graph
+ *  resolution, which has no code-graph tests-edge notion to check. */
+async function tiedReadRefusal(r, { term, capName, arg, ctx, execute, siblingTie = true }) {
+  const sibling = (siblingTie && !r.ambiguous)
+    ? (r.candidates || []).find((c) => testModuleTie(ctx.graph, r.match, c))
+    : null;
+  if (!r.ambiguous && !sibling) return null;
+  const pool = r.ambiguous ? [r.match, ...(r.candidates || [])].slice(0, 4) : [r.match, sibling];
+  const candidateResults = await dispatchEachCandidate(pool, capName, arg, ctx, execute);
+  const extra = candidateResults
+    ? { candidateResults, candidateCalls: pool.map((c) => ({ name: capName, input: { [arg]: c.label } })) }
+    : undefined;
+  return REFUSE(`"${term}" is ambiguous (${pool.map((m) => m.label).join(", ")}) — narrow it`, extra);
+}
+
+/** The arg key of a bound call's code-graph ENTITY slot, read off the registry's
+ *  own `resolves` precondition rather than a list kept here. A free-text slot
+ *  (tmct_search's query — declared with no resolves precondition) and a
+ *  memory-graph slot both return null, so neither is checked against the code
+ *  graph. Null when the call names no code-graph entity at all. */
+function codeGraphEntityArg(capName, input) {
+  for (const pre of preconditionsOf(capName)) {
+    if (pre.pred !== PRECOND.resolves || MEMORY_KINDS.includes(pre.as)) continue;
+    const arg = parametersOf(capName).find((p) => p.name === pre.param)?.arg ?? pre.param;
+    if (input[arg] != null) return arg;
+  }
+  return null;
+}
+
 /** Select a capability for a request and BIND its arguments — the full resolver.
  *  Order: command register -> NL parse -> imperative frame. Delegates entity binding to
  *  ctx.resolve and, unless `execute:false`, grounds it via ctx.dispatch. Returns
@@ -388,7 +437,18 @@ export async function resolveOne(request, declaredNames, ctx, { execute = true }
   // the two binding oracles never mix on one pick.
   let input = pick.input ? { ...pick.input } : {};
   let resolved = null;
-  if (!pick.input && !pick.noArg) {
+  if (pick.input) {
+    // A command pick arrives already bound, so it skips the binding step below.
+    // The tie check is not part of binding: a term naming two graph entities has
+    // to refuse on this route too, or the terse command form answers what the NL
+    // and frame routes both decline.
+    const entityArg = ctx.resolve ? codeGraphEntityArg(pick.name, input) : null;
+    if (entityArg) {
+      const term = String(input[entityArg]);
+      const tied = await tiedReadRefusal(ctx.resolve(term), { term, capName: pick.name, arg: entityArg, ctx, execute });
+      if (tied) return tied;
+    }
+  } else if (!pick.noArg) {
     const term = String(pick.term || "").trim();
     if (!term) return REFUSE(`the ${pick.topic} intent named no entity to bind`);
     const memoryBound = isMemoryTermSlot(pick.name, pick.arg);
@@ -400,22 +460,8 @@ export async function resolveOne(request, declaredNames, ctx, { execute = true }
         ? `the memory graph holds no facts mentioning "${term}" (honest miss)`
         : `"${term}" does not resolve to any graph entity (honest miss)`);
     }
-    // A tied read: either resolveObject's own score-tie (r.ambiguous), or a same-tier
-    // candidate the graph's own `tests` edge ties to the match (a source module and
-    // its test module — a grain neither side's raw score alone reveals as tied).
-    // resolveMemoryTerm's exact-match tiers have no code-graph tests-edge notion, so
-    // the sibling tie-check only applies on the code-graph resolution path.
-    const sibling = (!memoryBound && !r.ambiguous)
-      ? (r.candidates || []).find((c) => testModuleTie(ctx.graph, r.match, c))
-      : null;
-    if (r.ambiguous || sibling) {
-      const pool = r.ambiguous ? [r.match, ...(r.candidates || [])].slice(0, 4) : [r.match, sibling];
-      const candidateResults = await dispatchEachCandidate(pool, pick.name, pick.arg, ctx, execute);
-      const extra = candidateResults
-        ? { candidateResults, candidateCalls: pool.map((c) => ({ name: pick.name, input: { [pick.arg]: c.label } })) }
-        : undefined;
-      return REFUSE(`"${term}" is ambiguous (${pool.map((m) => m.label).join(", ")}) — narrow it`, extra);
-    }
+    const tied = await tiedReadRefusal(r, { term, capName: pick.name, arg: pick.arg, ctx, execute, siblingTie: !memoryBound });
+    if (tied) return tied;
     resolved = r.match;
     // The frame's own optional slots ride alongside the bound entity — declared
     // params of the same capability, so hallucinationsIn still validates them.

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

@@ -37,8 +37,8 @@ export const SPIDER_MASS_DECREMENT_PER_TURN = 0.5;
  *  the town square's own roles object, minus the food entry: nothing inert
  *  lies on a spider-and-fly board, and a null food role is what says so. */
 export const SPIDER_FLY_ROLES = Object.freeze({
-  predator: Object.freeze({ role: "predator", kind: "spider", idPrefix: "spider" }),
-  prey: Object.freeze({ role: "prey", kind: "fly", idPrefix: "fly" }),
+  predator: Object.freeze({ role: "predator", kind: "spider", idPrefix: "spider", hunts: "prey" }),
+  prey: Object.freeze({ role: "prey", kind: "fly", idPrefix: "fly", hunts: null }),
   food: null,
 });
 

package/src/domain/sprite-templates.mjs

@@ -244,12 +244,22 @@ function withUnfilledPlaceholdersDropped(template, svg) {
 /** Resolve ONE class term (no ancestor walk here — the caller repeats this
  *  at every level of the chain) against the template set, in specificity
  *  order: fully-specific match variant > parameterized template filled with
- *  an observed value > plain class template. Among satisfied match variants
- *  the most demanding one wins (bestSatisfiedVariant). A match variant that
- *  declares its own `[parameters.*]` is filled from them first, so a facing
- *  profile also carrying `[face]`/`[parameters.emotion]` renders the mood the
- *  instance's own mgx:feels fact names. Returns the SVG string, or null when
- *  nothing at this level matches. */
+ *  an observed value > plain class template > a parameterized template with
+ *  no fact to fill it, its own unfilled placeholders dropped. Among
+ *  satisfied match variants the most demanding one wins (bestSatisfiedVariant).
+ *  A match variant that declares its own `[parameters.*]` is filled from them
+ *  first, so a facing profile also carrying `[face]`/`[parameters.emotion]`
+ *  renders the mood the instance's own mgx:feels fact names. Returns the SVG
+ *  string, or null when nothing at this level matches.
+ *
+ *  The last step matters for a class whose only art IS a parameterized
+ *  template (e.g. lamp/cabinet at the sprite tier: one `[parameters.material]`
+ *  file, no plain sibling) — with no fact to fill it, `parameterizedFillAll`
+ *  correctly declines rather than guessing a material, but the class still
+ *  has real dedicated art. Dropping the unfilled tokens and returning that
+ *  art (the same treatment a satisfied match variant's own unfilled
+ *  placeholders already get) means an untaught instance renders as ITS OWN
+ *  class, not as whatever a less-specific ancestor happens to resolve to. */
 function resolveAtTerm(term, propertyFacts, templates) {
   const candidates = templatesForClass(term, templates);
   const matched = bestSatisfiedVariant(candidates, propertyFacts);
@@ -263,7 +273,9 @@ function resolveAtTerm(term, propertyFacts, templates) {
     if (filled) return filled;
   }
   const plain = candidates.find((t) => !t.match && !t.parameters);
-  return plain ? plain.svg : null;
+  if (plain) return plain.svg;
+  const parameterizedOnly = candidates.find((t) => !t.match && t.parameters);
+  return parameterizedOnly ? withUnfilledPlaceholdersDropped(parameterizedOnly, parameterizedOnly.svg) : null;
 }
 
 function resolveSpriteAssetRaw(className, factRows, propertyFacts, templates, spriteRegistry, rootFallback) {

package/src/domain/syllogise.mjs

@@ -1700,6 +1700,21 @@ export async function retractSubClassOf(repoDir, subject, object, {
   };
 }
 
+/** subject -> Set(objects) over a subClassOf edge list, the adjacency
+ *  `findIsaChain` walks. Building it is O(edges); a search from one subject is
+ *  O(that subject's own reachable set). A caller chasing MANY subjects over the
+ *  same edges should build this once and hand it to `findIsaChain` in place of
+ *  the edge list, or every small search pays for the whole graph again. */
+export function buildSubClassSuccessors(subClassEdges) {
+  const subSucc = new Map();
+  for (const [a, b] of subClassEdges || []) {
+    if (!a || !b || a === b) continue;
+    if (!subSucc.has(a)) subSucc.set(a, new Set());
+    subSucc.get(a).add(b);
+  }
+  return subSucc;
+}
+
 /**
  * PROOF SEARCH (not a third rule — a bounded rooted chase for a single "does
  * `subj` reach one of `targets`?" query). Walks OUTWARD from `subj` only,
@@ -1714,12 +1729,7 @@ export async function retractSubClassOf(repoDir, subject, object, {
  */
 export function findIsaChain(subj, targets, typeEdges, subClassEdges, { maxHops = 6 } = {}) {
   const targetSet = targets instanceof Set ? targets : new Set(targets || []);
-  const subSucc = new Map();
-  for (const [a, b] of subClassEdges || []) {
-    if (!a || !b || a === b) continue;
-    if (!subSucc.has(a)) subSucc.set(a, new Set());
-    subSucc.get(a).add(b);
-  }
+  const subSucc = subClassEdges instanceof Map ? subClassEdges : buildSubClassSuccessors(subClassEdges);
 
   let frontier = [];
   for (const [x, c] of typeEdges || []) {

package/src/domain/town-square-world.mjs

@@ -225,7 +225,7 @@ const TOWN_SQUARE_MARKET = layout({
 
 /** The chapel corner: an L of buildings in the north-west, a fence line across
  *  the south, three oaks. The only shipped layout with two predators, so it is
- *  where the avoid branch actually runs. */
+ *  where two hunters working the same board show up. */
 const TOWN_SQUARE_CHAPEL = layout({
   name: "town-square-chapel",
   gridSize: 14,

package/src/services/adventure-viz.mjs

@@ -92,7 +92,7 @@
 // an edit implies run through the browser bundle's own `session.applyEdit`
 // (adventure-browser-entry.mjs), never here — this module only renders and
 // reads.
-import { THEME_TOKENS_CSS, SERIF_STACK, MONO_STACK, escapeHtml, embedJson, embedScriptText, scenarioLabel, rowsForWorld, wordBeforeCursor } from "./viz-theme.mjs";
+import { THEME_TOKENS_CSS, SERIF_STACK, MONO_STACK, escapeHtml, embedJson, embedScriptText, scenarioLabel, rowsForWorld, wordBeforeCursor, demoEyebrowHtml, EYEBROW_LINKS_CSS } from "./viz-theme.mjs";
 import { createTicker, createSerialQueue } from "./viz-ticker.mjs";
 import { directedGridLayout } from "./viz-room-graph.mjs";
 import { worldDigestRows, roomAffordances, foldWorldState } from "./adventure.mjs";
@@ -628,7 +628,9 @@ ${THEME_TOKENS_CSS}
   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: 920px; margin: 0 auto; padding: 1.4rem 1.2rem 2.2rem; }
+  .visually-hidden { position: absolute; width: 1px; height: 1px; margin: -1px; padding: 0; overflow: hidden; clip: rect(0,0,0,0); white-space: nowrap; border: 0; }
   .eyebrow { font-family: ${MONO_STACK}; font-size: .7rem; letter-spacing: .12em; text-transform: uppercase; color: var(--gilt); }
+  ${EYEBROW_LINKS_CSS}
   .titlebar { display: flex; align-items: baseline; justify-content: space-between; gap: 1rem; flex-wrap: wrap; margin: .3rem 0 1rem; }
   button { font: inherit; color: inherit; background: none; cursor: pointer; }
   button:focus-visible { outline: 2px solid var(--ink); outline-offset: 2px; }
@@ -993,8 +995,9 @@ ${THEME_TOKENS_CSS}
 </head>
 <body>
 <main>
+  <h1 class="visually-hidden">the adventure</h1>
   <div class="titlebar">
-    <div class="eyebrow">tmct &middot; the adventure</div>
+    <div class="eyebrow">${demoEyebrowHtml("adventure", "the adventure")}</div>
     <button id="editModeBtn" type="button" class="mode-toggle" disabled>edit the world</button>
   </div>
   <p class="page-note" id="pageNote">${escapeHtml(scenarioList[0].worldPayload.opening || "")}</p>

package/src/services/adventure.mjs

@@ -1893,7 +1893,14 @@ export async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache
       );
     }
     const digest = await worldDigest(object, { memoryDir, memory, rows, state, graph, actingSubject });
-    const body = digest ?? `nothing more about the ${object} is written down yet.`;
+    // A thing that IS here with nothing written about it, and a word that only
+    // turns up in the room's own prose, are different answers. Sharing one line
+    // let "look at the door" reply "nothing more about the door is written down
+    // yet" in a house whose world model has no door at all, which reads as
+    // confirmation that a door is standing there.
+    const body = digest ?? (notHere
+      ? `there's no ${object} here — the word turns up in what's written about this place, but nothing by that name is in the scene.`
+      : `nothing more about the ${object} is written down yet.`);
     const containerNote = !person && isContainer(rows, object) ? ` ${containerStatusPhrase(object, { state })}` : "";
     // Framing follows the VERB the player typed, not the object's type: talking
     // to a lamp still reads as an attempted conversation (nothing replies, but