@polycode-projects/the-mechanical-code-talker 4.0.1 → 4.1.0

package/src/services/adventure.mjs

@@ -174,7 +174,43 @@ async function resumedPosition(memoryDir) {
 
 // ---- the world-state fold ----------------------------------------------------
 
-const SNAPSHOT_RE = /^(.+)@turn(\d+)$/;
+// A snapshot subject is `base@turnN`, or `base@epochE@turnN` once a recast has
+// moved the world past epoch 0 — the fold below reads both, and epoch-0 writes
+// keep the bare form so an unrecast store never changes shape.
+const SNAPSHOT_RE = /^(.+?)@(?:epoch(\d+)@)?turn(\d+)$/;
+
+/** Which run of the world a store is on. Recasting a shared world (mud.html's
+ *  RESET, a slider, the scenario dropdown) reopens the same deterministic
+ *  instance ids over a fresh store while peers may still hold the old run's
+ *  snapshots — this marker is how every reader agrees the world has started
+ *  over. It is an ordinary add-only fact: each recast appends a larger value,
+ *  the fold takes the max, and merging two peers' stores converges because max
+ *  is order-free. */
+export const WORLD_EPOCH_PREDICATE = "mgx:world-epoch";
+const WORLD_EPOCH_SUBJECT = "world";
+
+/** The bare triple a recast writes to move the world onto `epoch`. The caller
+ *  supplies provenance the same way it does for the seed facts, so the marker
+ *  travels (and folds) as a world row. */
+export function worldEpochFact(epoch) {
+  return { subject: WORLD_EPOCH_SUBJECT, predicate: WORLD_EPOCH_PREDICATE, object: String(epoch) };
+}
+
+/** `{ base, epoch, turn }` for a snapshot subject, or null for a base subject.
+ *  The one parser every reader outside this file should use — a local
+ *  `@turn(\d+)$` regex reads an epoch-stamped subject's base as
+ *  "mole-1@epoch2", which matches no character. */
+export function parseSnapshotSubject(subject) {
+  const m = SNAPSHOT_RE.exec(String(subject || ""));
+  return m ? { base: m[1], epoch: m[2] ? Number(m[2]) : 0, turn: Number(m[3]) } : null;
+}
+
+/** The snapshot subject a turn writes: bare `@turnN` while the world is on
+ *  epoch 0 (every store that has never been recast, and every fact written
+ *  before epochs existed), the epoch-stamped form after. */
+export function snapshotSubject(base, turn, epoch = 0) {
+  return epoch > 0 ? `${base}@epoch${epoch}@turn${turn}` : `${base}@turn${turn}`;
+}
 const PLACEMENT_PREDICATES = new Set([
   "mgx:currently-in", "mgx:located-in", "mgx:fixed-in", "mgx:stands-locked-in", "mgx:hidden-in",
 ]);
@@ -242,6 +278,9 @@ const MUD_STATE_PREDICATES = new Set([
   KNOWS_ABOUT_PREDICATE,
   DISPLAY_NAME_PREDICATE,
   "rdf:type",
+  // Which run the world is on IS live world state: a peer that misses the
+  // recast marker keeps folding the old run's snapshots as current.
+  WORLD_EPOCH_PREDICATE,
 ]);
 
 /** Whether `predicate` carries live world state — where a thing stands, what
@@ -269,41 +308,61 @@ export function worldIndividualNames(rows) {
 }
 
 /** Fold fact rows into the CURRENT world state: per subject, the newest
- *  placement (base row = turn 0, @turnN snapshots override), the newest
- *  open/closed state, the newest mass, the exit map, and the turn counter (the
- *  largest @turnN suffix written so far — derived, never stored). Pure. */
+ *  placement (base row = turn 0 of the current epoch, snapshots override), the
+ *  newest open/closed state, the newest mass, the exit map, the turn counter
+ *  (the largest snapshot turn written in the current epoch — derived, never
+ *  stored), and the epoch itself.
+ *
+ *  Rows rank by the (epoch, turn) pair, so a recast can never be outranked by
+ *  the run it replaced: a peer's turn-9 snapshot from before the recast loses
+ *  to a turn-1 snapshot written after it. Base rows carry no stamp of their
+ *  own and rank as turn 0 of the CURRENT epoch — a recast re-seeds the same
+ *  deterministic ids, so the shard's own rows are exactly the state the new
+ *  run starts from. A store with no epoch marker and no stamped snapshot is
+ *  wholly on epoch 0 and folds as it always has. Pure. */
 export function foldWorldState(factRows) {
-  const placements = new Map(); // subject -> { predicate, object, turn }
-  const positions = new Map();  // subject -> { predicate, object, turn }
-  const openness = new Map();   // subject -> { open, turn }
-  const masses = new Map();     // subject -> { value, turn }
+  const rows = factRows || [];
+  let epoch = 0;
+  for (const row of rows) {
+    if (row.predicate === WORLD_EPOCH_PREDICATE) {
+      const marked = Number(row.object);
+      if (Number.isInteger(marked) && marked > epoch) epoch = marked;
+      continue;
+    }
+    const m = SNAPSHOT_RE.exec(row.subject);
+    if (m && m[2] && Number(m[2]) > epoch) epoch = Number(m[2]);
+  }
+  const placements = new Map(); // subject -> { predicate, object, turn, epoch }
+  const positions = new Map();  // subject -> { predicate, object, turn, epoch }
+  const openness = new Map();   // subject -> { open, turn, epoch }
+  const masses = new Map();     // subject -> { value, turn, epoch }
   const exits = new Map();      // room -> Map(direction -> room)
   let turnCount = 0;
-  for (const row of factRows || []) {
+  const outranks = (rowEpoch, turn, prior) =>
+    !prior || rowEpoch > prior.epoch || (rowEpoch === prior.epoch && turn >= prior.turn);
+  for (const row of rows) {
+    if (row.predicate === WORLD_EPOCH_PREDICATE) continue;
     const m = SNAPSHOT_RE.exec(row.subject);
     const base = m ? m[1] : row.subject;
-    const turn = m ? Number(m[2]) : 0;
-    if (m) turnCount = Math.max(turnCount, turn);
+    const rowEpoch = m ? (m[2] ? Number(m[2]) : 0) : epoch;
+    const turn = m ? Number(m[3]) : 0;
+    if (m && rowEpoch === epoch) turnCount = Math.max(turnCount, turn);
     if (PLACEMENT_PREDICATES.has(row.predicate)) {
-      const prior = placements.get(base);
-      if (!prior || turn >= prior.turn) placements.set(base, { predicate: row.predicate, object: row.object, turn });
+      if (outranks(rowEpoch, turn, placements.get(base))) placements.set(base, { predicate: row.predicate, object: row.object, turn, epoch: rowEpoch });
       continue;
     }
     if (POSITION_PREDICATES.has(row.predicate)) {
-      const prior = positions.get(base);
-      if (!prior || turn >= prior.turn) positions.set(base, { predicate: row.predicate, object: row.object, turn });
+      if (outranks(rowEpoch, turn, positions.get(base))) positions.set(base, { predicate: row.predicate, object: row.object, turn, epoch: rowEpoch });
       continue;
     }
     if (row.predicate === OPEN_PREDICATE) {
-      const prior = openness.get(base);
-      if (!prior || turn >= prior.turn) openness.set(base, { open: row.object === "true", turn });
+      if (outranks(rowEpoch, turn, openness.get(base))) openness.set(base, { open: row.object === "true", turn, epoch: rowEpoch });
       continue;
     }
     if (row.predicate === MASS_PREDICATE) {
       const value = Number(row.object);
       if (!Number.isFinite(value)) continue; // masses hold numbers; an unparsable one is no mass at all
-      const prior = masses.get(base);
-      if (!prior || turn >= prior.turn) masses.set(base, { value, turn });
+      if (outranks(rowEpoch, turn, masses.get(base))) masses.set(base, { value, turn, epoch: rowEpoch });
       continue;
     }
     const exit = EXIT_PREDICATE_RE.exec(row.predicate);
@@ -312,7 +371,7 @@ export function foldWorldState(factRows) {
       exits.get(row.subject).set(exit[1], row.object);
     }
   }
-  return { placements, positions, openness, masses, exits, turnCount };
+  return { placements, positions, openness, masses, exits, turnCount, epoch };
 }
 
 /** A subject's CURRENT within-room position, or null. A position goes stale
@@ -323,7 +382,7 @@ export function currentPosition(state, subject) {
   const pos = state.positions.get(subject);
   if (!pos) return null;
   const place = state.placements.get(subject);
-  if (place && pos.turn < place.turn) return null;
+  if (place && (pos.epoch < place.epoch || (pos.epoch === place.epoch && pos.turn < place.turn))) return null;
   return pos;
 }
 
@@ -551,7 +610,7 @@ export function runNpcPass({ rows, state, k, families, playerRoomAfter }) {
     if (!covered) continue;
     const linked = [...(state.exits.get(from)?.values() ?? [])].includes(target);
     if (!linked) continue;
-    writes.push({ subject: `${npc}@turn${k}`, predicate: effectPredicate, object: target });
+    writes.push({ subject: snapshotSubject(npc, k, state.epoch), predicate: effectPredicate, object: target });
     if (playerRoomAfter === target) lines.push(`the ${npc} walks in.`);
     else if (playerRoomAfter === from) lines.push(`the ${npc} leaves.`);
   }
@@ -704,8 +763,8 @@ export async function recordMassDrain(memoryDir, { world, subject, drainPerTurn,
   const left = Math.max(0, Math.round((mass - drainPerTurn) * 100) / 100);
   const k = state.turnCount + 1;
   await writeWorldTurn(memoryDir, world, k, [
-    { subject: `${subject}@turn${k}`, predicate: MASS_PREDICATE, object: String(left) },
-    ...(left > 0 ? [] : [{ subject: `${subject}@turn${k}`, predicate: "mgx:currently-in", object: STARVED_PLACE }]),
+    { subject: snapshotSubject(subject, k, state.epoch), predicate: MASS_PREDICATE, object: String(left) },
+    ...(left > 0 ? [] : [{ subject: snapshotSubject(subject, k, state.epoch), predicate: "mgx:currently-in", object: STARVED_PLACE }]),
   ], cache);
   return { mass: left, starved: left <= 0 };
 }
@@ -724,6 +783,9 @@ export async function recordMassDrain(memoryDir, { world, subject, drainPerTurn,
 // schedule) stay out of the view: hidden means hidden.
 
 const VIEW_EXCLUDED_PREDICATES = new Set([
+  // The recast counter is bookkeeping, not scenery — "World mgx:world-epoch 2"
+  // must never read back as room prose.
+  WORLD_EPOCH_PREDICATE,
   "mgx:hidden-in", "mgx:is-open", "mgx:is-npc", "mgx:is-container",
   // A bare number reads as an untranslated triple in room prose ("Mole-1
   // mgx:hasMass 8"). Mass reaches a player through the verbs that change it.
@@ -1293,7 +1355,7 @@ async function handleGoVerb(ctx) {
   const predator = predatorIn(rows, state, target);
   if (predator) {
     await writeWorldTurn(memoryDir, world, k, [
-      { subject: `${actingSubject}@turn${k}`, predicate: "mgx:currently-in", object: CONSUMED_PLACE },
+      { subject: snapshotSubject(actingSubject, k, state.epoch), predicate: "mgx:currently-in", object: CONSUMED_PLACE },
     ], cache);
     return answer(
       `you go ${cmd.direction} into the ${target} — and the ${predator} is waiting. It eats the ${actingSubject}. That's the end of its run.`,
@@ -1302,7 +1364,7 @@ async function handleGoVerb(ctx) {
     );
   }
   return commit(
-    [{ subject: `${actingSubject}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:currently-in", object: target }],
+    [{ subject: snapshotSubject(actingSubject, k, state.epoch), predicate: familyEffectPredicate(family) ?? "mgx:currently-in", object: target }],
     `you go ${cmd.direction}. Now in the ${target}.`,
     `go — the taught "go" family fired; ${actingSubject} moves ${here} -> ${target}`,
     `move through the world (now in the ${target})`,
@@ -1339,7 +1401,7 @@ async function handleTakeVerb(ctx) {
     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(
-    [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: actingSubject }],
+    [{ subject: snapshotSubject(object, k, state.epoch), predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: actingSubject }],
     `you take the ${object}.`,
     `take — the taught "take" family fired; ${object} is now carried`,
     `carry the ${object}`,
@@ -1353,7 +1415,7 @@ async function handleDropOrGiveVerb(ctx) {
   }
   if (cmd.verb === "drop") {
     return commit(
-      [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: here }],
+      [{ subject: snapshotSubject(object, k, state.epoch), predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: here }],
       `you drop the ${object} in the ${here}.`,
       `drop — the taught "drop" family fired; ${object} rests in the ${here}`,
       `set the ${object} down`,
@@ -1364,7 +1426,7 @@ async function handleDropOrGiveVerb(ctx) {
     return answer(`the ${receiver} isn't here.`, noteFor(`give — ${receiver} isn't one of the cast standing in the ${here}; precondition declined by name`), { miss: true });
   }
   return commit(
-    [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: receiver }],
+    [{ subject: snapshotSubject(object, k, state.epoch), predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: receiver }],
     `you give the ${object} to the ${receiver}.`,
     `give — the taught "give" family fired; the ${receiver} holds the ${object}`,
     `hand the ${object} over`,
@@ -1496,8 +1558,8 @@ async function handleEatVerb(ctx) {
   await recordGone(memoryDir, { observer: actingSubject, thing: object, k, cache });
   return commit(
     [
-      { subject: `${actingSubject}@turn${k}`, predicate: MASS_PREDICATE, object: String(grown) },
-      { subject: `${object}@turn${k}`, predicate: "mgx:located-in", object: CONSUMED_PLACE },
+      { subject: snapshotSubject(actingSubject, k, state.epoch), predicate: MASS_PREDICATE, object: String(grown) },
+      { subject: snapshotSubject(object, k, state.epoch), predicate: "mgx:located-in", object: CONSUMED_PLACE },
     ],
     `you eat the ${object}. It adds ${gained} to your mass, so you weigh ${grown} now.`,
     `eat — the ${object}'s ${gained} mass moves onto ${actingSubject} (now ${grown}) and the ${object} leaves the world`,
@@ -1537,7 +1599,7 @@ async function handlePutVerb(ctx) {
     );
   }
   return commit(
-    [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: container }],
+    [{ subject: snapshotSubject(object, k, state.epoch), predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: container }],
     `you put the ${object} in the ${container}.`,
     `put — the taught "put" family fired; the ${object} now sits in the ${container}`,
     `put the ${object} in the ${container}`,
@@ -1585,7 +1647,7 @@ async function handleContainerVerb(ctx) {
       return answer(text, noteFor(`${cmd.verb} — the taught "${cmd.verb}" family's ${failed.predicate} precondition declined by name`), { miss: true });
     }
     const effSubject = roleBinding(effect.subjectRole, ctx.actingSubject, object, domain);
-    const writeIsOpen = { subject: `${effSubject}@turn${k}`, predicate: effect.predicate, object: effect.value };
+    const writeIsOpen = { subject: snapshotSubject(effSubject, k, state.epoch), predicate: effect.predicate, object: effect.value };
 
     if (cmd.verb === "open") {
       const revealed = [...state.placements]
@@ -1595,7 +1657,7 @@ async function handleContainerVerb(ctx) {
       return commit(
         [
           writeIsOpen,
-          ...revealed.map((thing) => ({ subject: `${thing}@turn${k}`, predicate: "mgx:located-in", object })),
+          ...revealed.map((thing) => ({ subject: snapshotSubject(thing, k, state.epoch), predicate: "mgx:located-in", object })),
         ],
         revealed.length
           ? `you open the ${object} — inside: the ${revealed.join(", the ")}.`
@@ -1646,7 +1708,7 @@ async function handleContainerVerb(ctx) {
     );
   }
   return commit(
-    [{ subject: `${object}@turn${k}`, predicate: "mgx:fixed-in", object: here }],
+    [{ subject: snapshotSubject(object, k, state.epoch), predicate: "mgx:fixed-in", object: here }],
     `you unlock the ${object} with the ${required}.`,
     `unlock — the lock releases; ${object} now stands unlocked (still fixed) in the ${here}`,
     `unlock the ${object}`,

package/src/services/chat-page-viz.mjs

@@ -185,6 +185,18 @@ export function tapeRowFor(direction, message) {
   return { type: type, direction: direction, detail: detail, family: FAMILIES[type] || "link" };
 }
 
+/**
+ * The wire tape's own clock stamp for a message as it arrives —
+ * `HH:MM:SS.mmm`, local time, zero-padded.
+ *
+ * Self-contained (no outer refs), `.toString()`-splice safe.
+ */
+export function tapeClock() {
+  const at = new Date();
+  const pad = (n, width) => String(n).padStart(width, "0");
+  return pad(at.getHours(), 2) + ":" + pad(at.getMinutes(), 2) + ":" + pad(at.getSeconds(), 2) + "." + pad(at.getMilliseconds(), 3);
+}
+
 /**
  * The node list: every peer this graph knows about, each with the node name it
  * chose and the timestamp of the most recent fact it contributed, most
@@ -256,6 +268,24 @@ export function nodeInitials(name) {
   return "??";
 }
 
+/**
+ * How long ago a node's most recent fact landed, relative to `nowMs`: "now"
+ * under 5s, otherwise the whole seconds/minutes/hours/days, coarsest unit
+ * that still reads as one number. `at` null/undefined (a peer with no
+ * activity yet) reads as an em dash rather than a bogus duration.
+ *
+ * Self-contained (no outer refs), `.toString()`-splice safe.
+ */
+export function relativeWhen(at, nowMs) {
+  if (at === null || at === undefined) return "—";
+  const seconds = Math.max(0, Math.round((nowMs - at) / 1000));
+  if (seconds < 5) return "now";
+  if (seconds < 60) return seconds + "s";
+  if (seconds < 3600) return Math.round(seconds / 60) + "m";
+  if (seconds < 86400) return Math.round(seconds / 3600) + "h";
+  return Math.round(seconds / 86400) + "d";
+}
+
 /**
  * The invite link: this page's own address carrying the offer blob, the world
  * id and the world's name. Any query or fragment the current address already
@@ -902,6 +932,8 @@ ${THEME_TOKENS_CSS}
   const nodeInitials = ${nodeInitials.toString()};
   const inviteLinkFor = ${inviteLinkFor.toString()};
   const inviteParamsFrom = ${inviteParamsFrom.toString()};
+  const tapeClock = ${tapeClock.toString()};
+  const relativeWhen = ${relativeWhen.toString()};
   const DIGEST_STRUCTURES = ${digestStructuresJson};
   const el = (id) => document.getElementById(id);
 
@@ -1827,12 +1859,6 @@ ${THEME_TOKENS_CSS}
   const tapeCounts = new Map();
   let wireMessageCount = 0;
 
-  function tapeClock() {
-    const at = new Date();
-    const pad = function (n, width) { return String(n).padStart(width, "0"); };
-    return pad(at.getHours(), 2) + ":" + pad(at.getMinutes(), 2) + ":" + pad(at.getSeconds(), 2) + "." + pad(at.getMilliseconds(), 3);
-  }
-
   function pushTape(entry) {
     // The meter counts real wire messages only; the tape below shows those
     // plus the local notes (state changes, a channel opening) that explain
@@ -1913,16 +1939,6 @@ ${THEME_TOKENS_CSS}
     answerPanelEl.hidden = !replyOutEl.value || (room && room.state === "connected");
   }
 
-  function relativeWhen(at, nowMs) {
-    if (at === null || at === undefined) return "—";
-    const seconds = Math.max(0, Math.round((nowMs - at) / 1000));
-    if (seconds < 5) return "now";
-    if (seconds < 60) return seconds + "s";
-    if (seconds < 3600) return Math.round(seconds / 60) + "m";
-    if (seconds < 86400) return Math.round(seconds / 3600) + "h";
-    return Math.round(seconds / 86400) + "d";
-  }
-
   function renderNodes() {
     if (!room || !p2p) {
       nodeCountEl.textContent = "";

package/src/services/chat.mjs

@@ -953,9 +953,35 @@ async function answerMemoryClassQuery(memoryDir, query) {
 // literal quantifier lookup. Placed ahead of it in runTurn: HOW_MANY_ARE_RE
 // reads "there" as a second noun and answers "I was never told a quantifier",
 // stealing the phrasing before a member count ever runs.
-const TAUGHT_CLASS_COUNT_RE = /^how\s+many\s+([a-z][\w-]*)\s*(.*)$/i;
+const TAUGHT_CLASS_COUNT_RE = /^how\s+many\s+([a-z][\w-]*(?:\s+[a-z][\w-]*)*)\s*(.*)$/i;
+
+/** The longest leading run of `nounRun`'s words that names a class something was
+ *  actually taught about, as `{asked, tail, members}` — its taught members and
+ *  whatever words are left over, joined onto `trailing` as the restrictor tail.
+ *  A class name is a noun PHRASE, not a word ("sprite class", "body of water"),
+ *  so the run is tried longest-first and the shortest reading wins only when no
+ *  longer one is on record. That ordering is what keeps a single-word class
+ *  carrying a restrictor ("list the animals in the graph") reading exactly as it
+ *  did when only the first word was ever considered. */
+async function longestTaughtClassInRun(memoryDir, nounRun, trailing, biasByBundle, cache) {
+  const words = String(nounRun || "").trim().split(/\s+/).filter(Boolean);
+  if (!words.length) return null;
+  if (COUNT_NOUNS[words[0].toLowerCase()]) return null; // a real graph-countable class — the code lanes own it
+  let normFactTerm;
+  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
+  const rows = await factRows(memoryDir, cache);
+  const isa = rows.filter((f) => ISA_PREDICATES.has(f.predicate));
+  for (let take = words.length; take >= 1; take -= 1) {
+    const asked = words.slice(0, take).join(" ").toLowerCase();
+    const variants = factTermVariants(normFactTerm, asked);
+    const members = rankByBiasThenTrust(isa.filter((f) => variants.has(f.object)), biasByBundle);
+    if (!members.length) continue; // nothing taught under this reading — try a shorter one
+    return { asked, tail: [words.slice(take).join(" "), String(trailing || "")].filter(Boolean).join(" ").trim(), members };
+  }
+  return null;
+}
 
-/** Count the taught members of a class named by a plain noun ("how many animals
+/** Count the taught members of a class named by a noun phrase ("how many animals
  *  are there" → every "X is a kind of animal"). Declines (null) for a real
  *  code-countable class (answerCount owns it) or a class nothing was taught
  *  about, so structural counts and the quantifier lane are unaffected. */
@@ -963,22 +989,16 @@ async function answerTaughtClassCount(memoryDir, query, biasByBundle = {}, cache
   if (!memoryDir) return null;
   const m = String(query).trim().match(TAUGHT_CLASS_COUNT_RE);
   if (!m) return null;
-  if (!DYNAMIC_TAIL_OK_RE.test((m[2] || "").trim())) return null;
-  const asked = m[1].toLowerCase();
-  if (COUNT_NOUNS[asked]) return null; // a real graph-countable class — answerCount owns it
-  let normFactTerm;
-  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
-  const rows = await factRows(memoryDir, cache);
-  const isa = rows.filter((f) => ISA_PREDICATES.has(f.predicate));
-  const variants = factTermVariants(normFactTerm, asked);
-  const members = rankByBiasThenTrust(isa.filter((f) => variants.has(f.object)), biasByBundle);
-  if (!members.length) return null; // nothing taught under this class name — later lanes own it
+  const hit = await longestTaughtClassInRun(memoryDir, m[1], m[2], biasByBundle, cache);
+  if (!hit) return null;
+  if (!DYNAMIC_TAIL_OK_RE.test(hit.tail)) return null;
   // A member whose SUBJECT is itself a countable graph class ("every class is a
   // component") is an asserted-vocabulary cardinality, not a member enumeration —
   // countFromFacts counts the real class, so defer to it rather than tallying the
   // one class-level fact.
-  if (members.some((f) => COUNT_NOUNS[String(f.subject).toLowerCase()])) return null;
-  return `${members.length} ${members.length === 1 ? asked.replace(/s$/, "") : asked}.`;
+  if (hit.members.some((f) => COUNT_NOUNS[String(f.subject).toLowerCase()])) return null;
+  const n = hit.members.length;
+  return `${n} ${n === 1 ? hit.asked.replace(/s$/, "") : hit.asked}.`;
 }
 
 // "list all animals" / "list the animals" — enumerate a taught class's members,
@@ -986,9 +1006,9 @@ async function answerTaughtClassCount(memoryDir, query, biasByBundle = {}, cache
 // leftovers: at scale the definition lane fills its cap with forward corpus facts
 // before the reverse-membership listing ever shows, and the conversational
 // orientation lane claims the bare "list …" phrasing before factReadBack runs.
-const MEMBERSHIP_LIST_RE = /^(?:list|show(?:\s+me)?)\s+(?:all\s+|the\s+)?([a-z][\w-]*)\s*(.*)$/i;
+const MEMBERSHIP_LIST_RE = /^(?:list|show(?:\s+me)?)\s+(?:all\s+|the\s+)?([a-z][\w-]*(?:\s+[a-z][\w-]*)*)\s*(.*)$/i;
 
-/** List the taught members of a class named by a plain noun ("list all animals"
+/** List the taught members of a class named by a noun phrase ("list all animals"
  *  → every "X is a kind of animal"). Declines (null) for a code-countable class
  *  or a class nothing was taught about; declines with a message for a real
  *  restrictor tail rather than answering as if it weren't there. */
@@ -996,16 +1016,9 @@ async function answerMembershipList(memoryDir, query, biasByBundle = {}, cache =
   if (!memoryDir) return null;
   const m = String(query).trim().match(MEMBERSHIP_LIST_RE);
   if (!m) return null;
-  const asked = m[1].toLowerCase();
-  if (COUNT_NOUNS[asked]) return null; // a real graph-countable class — the code list lane owns it
-  const tail = (m[2] || "").trim();
-  let normFactTerm;
-  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
-  const rows = await factRows(memoryDir, cache);
-  const isa = rows.filter((f) => ISA_PREDICATES.has(f.predicate));
-  const variants = factTermVariants(normFactTerm, asked);
-  const members = rankByBiasThenTrust(isa.filter((f) => variants.has(f.object)), biasByBundle);
-  if (!members.length) return null; // nothing taught under this class name — later lanes own it
+  const hit = await longestTaughtClassInRun(memoryDir, m[1], m[2], biasByBundle, cache);
+  if (!hit) return null;
+  const { asked, tail, members } = hit;
   if (!DYNAMIC_TAIL_OK_RE.test(tail)) {
     return {
       text: `I can list the ${asked}, but not the "${tail}" part of that question — `
@@ -7160,6 +7173,16 @@ const LOCATIVE_FACT_PREDICATE_RE = /^mgx:[a-z]+-(?:on|in|at|inside|under|below|a
  *  to the ordinary BARE_WHATIS_RE handling untouched. */
 const WHAT_IS_PREP_FACT_RE = new RegExp(`^what(?:'s|\\s+is|\\s+are)\\s+(${PREP_SRC})\\s+(.+?)\\s*[?.!]*$`, "i");
 
+/** "what parameters does a person sprite take" / "what materials does a bed
+ *  accept" — the object-fronted property question, where the property noun
+ *  leads and the verb closes. It reads the same folded verb-plus-noun predicates
+ *  the teach path already mints (mgx:take-parameter, mgx:accept-material,
+ *  mgx:offer-variant), so the predicate is recovered from the sentence's own two
+ *  ends rather than from a table of known property words: m[1] is the noun,
+ *  m[2] the subject, m[3] the verb. Consumed by factAnswer's (a-pre6) reader,
+ *  which diverts only on a real stored hit. */
+const OBJECT_FRONTED_PROPERTY_RE = /^what\s+([a-z][\w-]*)\s+(?:does|do)\s+(?:an?\s+|the\s+)?(.+?)\s+([a-z][a-z-]*)\s*[?.!]*$/i;
+
 // CAN_ASK_RE's remaining paraphrase-ladder siblings, all over the same
 // mgx:capableOf facts:
 //  - DO_VERB_ASK_RE: the do-support yes/no ("do birds fly", "does a dog
@@ -7666,6 +7689,35 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     }
   }
 
+  // (a-pre6) "what parameters does a person sprite take" — the object-fronted
+  // property question over a folded verb-plus-noun predicate. Both ends of the
+  // sentence carry half the predicate the teach path minted, so the verb and the
+  // noun are rejoined into mgx:<verb>-<noun> and looked up directly; the noun is
+  // tried through its own plural variants, since a question asks for "parameters"
+  // where the stored predicate names one "parameter". Checked before (a) for the
+  // same reason as its siblings above — the leading "what …" would otherwise be
+  // claimed as one literal term to define — and hit-gated the same way, so a
+  // sentence of this shape with nothing on record falls through untouched.
+  const propertyQ = q.match(OBJECT_FRONTED_PROPERTY_RE);
+  if (propertyQ) {
+    const verb = propertyQ[3].toLowerCase();
+    const subjectVariants = factTermVariants(normFactTerm, propertyQ[2]);
+    const predicates = new Set(
+      [...factTermVariants(normFactTerm, propertyQ[1])].map((noun) => normFactPredicate(`mgx:${verb}-${noun.replace(/\s+/g, "-")}`)),
+    );
+    const hits = (await factRows(memoryDir, cache)).filter(
+      (f) => predicates.has(normFactPredicate(f.predicate)) && subjectVariants.has(normFactTerm(f.subject)),
+    );
+    if (hits.length) {
+      const ranked = rankByBiasThenTrust(uniqueFacts(hits), biasByBundle);
+      const lines = ranked.map(renderFactLine);
+      const shown = lines.slice(0, FACT_ANSWER_CAP);
+      const rest = lines.slice(FACT_ANSWER_CAP);
+      const extra = rest.length ? `\n…and ${rest.length} more — say 'more' to see them.` : "";
+      return { text: shown.join("\n") + extra, replace: true, ...(rest.length ? { pending: { items: rest, noun: "facts" } } : {}) };
+    }
+  }
+
   // (a) meta-shaped questions ("what is a module", "what does cache mean") — the
   // parsed object term, matched against fact SUBJECTS; consulted for hits (append
   // alongside the schema-docs answer) and misses (facts answer alone) alike.
@@ -12526,11 +12578,16 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   let envelope = null;
   try {
     let text;
-    if (graph && (focus?.id || prev.length)) {
-      // Direct ask() when EITHER a focus is set (thread it as contextId so "it"
-      // binds) OR the previous turn produced a set to refer back to (thread it as
-      // `prev` for the anaphora node). Builds the SAME delimited envelope dispatchTool
-      // emits, so the parse below is identical either way.
+    if (graph?.individuals?.length || (graph && (focus?.id || prev.length))) {
+      // Direct ask() whenever the caller HANDED US a graph with something in it.
+      // The focus/prev pair is threaded through it (contextId so "it" binds, prev
+      // for the anaphora node), but neither is what earns the direct call: a
+      // caller that passes a real graph means that graph, and the tmct_ask branch
+      // below reads the CONFIG's graph instead — which an in-process session (a
+      // page's own world facts, say) has no file for. Gating on history alone
+      // refused every cold turn against a perfectly good graph and only started
+      // answering once a focus happened to be set. Builds the SAME delimited
+      // envelope dispatchTool emits, so the parse below is identical either way.
       const { ask } = await import("../domain/ask.mjs");
       const r = ask(graph, askQuery, { contextId: effectiveContextId, prev });
       text = `${r.content}${ASK_ENVELOPE_DELIM}${JSON.stringify(r.tmct_ask, null, 2)}`;
@@ -14084,9 +14141,20 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
   if (name === "plan") {
     note(trace, "goal: plan/execute a compound or maintenance-goal request over the graph (the capability router)");
     if (!argText) return mk("/plan needs a request, e.g. `/plan of the modules impacted by X, which are untested`.", { miss: true });
-    if (!graph) return mk("no graph loaded — /plan needs a code graph to plan over.", { miss: true });
+    // A KNOWN-EMPTY code graph is nothing to plan over, and it is what every
+    // memory-graph page and an un-pointed CLI session actually holds: each of
+    // its parameter slots would bind against an index with no entities in it.
+    // Where there is a memory store, hand the planner that instead — that is
+    // buildCapabilityPlanCtx's memory-only mode, where world facts bind and a
+    // code-graph capability refuses by naming the graph it hasn't got. Only a
+    // graph with something in it plans as a code graph. `source` travels with
+    // it: this turn reuses what it already holds and never loads one mid-turn.
+    const planGraph = graph && !noCodeGraph(graph) ? graph : null;
+    if (!planGraph && !memoryDir) return mk("no graph loaded — /plan needs a code graph or a memory store to plan over.", { miss: true });
     const { buildCapabilityPlanCtx, runCapabilityPlan, declaredCapabilityNames } = await import("../domain/router/drive.mjs");
-    const planCtx = await buildCapabilityPlanCtx({ ...capabilityPlanDeps(), config, source, tel, graph, memoryDir });
+    const planCtx = await buildCapabilityPlanCtx({
+      ...capabilityPlanDeps(), config, source: planGraph ? source : null, tel, graph: planGraph, memoryDir,
+    });
     try {
       const result = await runCapabilityPlan(argText, declaredCapabilityNames(), planCtx);
       if (result.refused) {