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

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

@@ -32,7 +32,7 @@ import { THEME_TOKENS_CSS, SERIF_STACK, MONO_STACK, escapeHtml } from "./viz-the
 import { provBucketFor } from "./ledger-viz.mjs";
 import { createTicker, prefersReducedMotion } from "./viz-ticker.mjs";
 import { sessionLogTimeOfDay, sessionLogHeaderMarkdown, sessionLogTurnMarkdown } from "./session-log-format.mjs";
-import { bandLabelFor, statsSummaryLine, fetchWithProgress, renderStatsPanelInto } from "./memory-panel-viz.mjs";
+import { bandLabelFor, statsSummaryLine, clearSiteAssetCaches, fetchWithProgress, renderStatsPanelInto } from "./memory-panel-viz.mjs";
 
 const DEFAULT_TITLE = "the-mechanical-code-talker — talk to it";
 
@@ -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
@@ -379,7 +409,7 @@ export function transcriptMarkdown(turns, meta, headerMd, turnMd) {
  *  live digest-bank twin (see chat-browser-entry.mjs) rather than to a
  *  client-side digest panel of this page's own; an empty list degrades to the
  *  flat list exactly as before this page could digest at all. */
-export function renderChatHtml({ title = DEFAULT_TITLE, digestStructures = [] } = {}) {
+export function renderChatHtml({ title = DEFAULT_TITLE, digestStructures = [], seedStamp = "" } = {}) {
   const digestStructuresJson = JSON.stringify(Array.isArray(digestStructures) ? digestStructures : []);
   const legendHtml = PROV_LEGEND.map(
     ([key, label]) => `<span class="legend-item"><i class="dot dot-${provKey(key)}"></i>${escapeHtml(label)}</span>`,
@@ -549,6 +579,13 @@ ${THEME_TOKENS_CSS}
      input and a round send button. The chrome's controls take the same shape,
      so the page's networking reads as ordinary chat furniture rather than as
      an instrument bolted on. */
+  /* the live fact count, in the topbar rather than the statusline: it is the
+     one number that says what this session actually knows, and a small line of
+     grey mono under the composer is where a wrong one goes unnoticed. Reads as
+     a pill like its neighbours, with the number itself at reading size. */
+  .fact-pill { display: inline-flex; align-items: baseline; gap: .34rem; font-family: ${MONO_STACK}; font-size: .68rem; letter-spacing: .06em; text-transform: uppercase; color: var(--muted); border: 1px solid var(--corpus-t1); border-radius: 99px; padding: .2rem .8rem; background: var(--corpus-soft); white-space: nowrap; }
+  .fact-pill .fact-pill-value { font-size: .96rem; letter-spacing: 0; font-variant-numeric: tabular-nums; font-weight: 600; color: var(--ink); }
+
   .chrome { display: flex; align-items: center; gap: .4rem; }
   .chrome-btn { font-family: ${SERIF_STACK}; font-size: .8rem; color: var(--muted); border: 1px solid var(--line); border-radius: 99px; padding: .22rem .75rem; background: var(--card); text-decoration: none; display: inline-flex; align-items: center; gap: .32rem; white-space: nowrap; line-height: 1.35; }
   .chrome-btn:hover { color: var(--ink); border-color: var(--ink); }
@@ -789,6 +826,10 @@ ${THEME_TOKENS_CSS}
         <span class="eyebrow">the-mechanical-code-talker</span>
       </div>
       <div class="chrome">
+        <span class="fact-pill" id="factPill" aria-live="polite"
+          title="every fact this session's memory holds right now — the starter memory it shipped with plus anything you have taught, researched or ingested">
+          <span class="fact-pill-value" id="factPillValue">&mdash;</span> facts
+        </span>
         <button type="button" class="state-pill" id="statePill" data-tone="idle"
           title="the shared-world connection; click to open the network panel">
           <i class="pill-dot"></i><span id="statePillWord">not shared</span>
@@ -880,6 +921,7 @@ ${THEME_TOKENS_CSS}
   const transcriptMarkdown = ${transcriptMarkdown.toString()};
   const bandLabelFor = ${bandLabelFor.toString()};
   const statsSummaryLine = ${statsSummaryLine.toString()};
+  const clearSiteAssetCaches = ${clearSiteAssetCaches.toString()};
   const fetchWithProgress = ${fetchWithProgress.toString()};
   const renderStatsPanelInto = ${renderStatsPanelInto.toString()};
   const createTicker = ${createTicker.toString()};
@@ -890,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);
 
@@ -900,6 +944,7 @@ ${THEME_TOKENS_CSS}
   const inputEl = el("composerInput");
   const sendBtn = el("composerSend");
   const statusEl = el("status");
+  const factPillValueEl = el("factPillValue");
   const statsPanelEl = el("statsPanelStats");
   const researchedPanelEl = el("researchedPanel");
   const wikiModeFieldset = el("wikiMode");
@@ -1102,11 +1147,18 @@ ${THEME_TOKENS_CSS}
     }
   }
 
+  // The build's own content hash for the seed. It rides in the URL this page
+  // fetches the seed by, so the service worker's cache-first read can only
+  // ever return the copy this page asked for. Empty in a build that had no
+  // seed to hash (the desktop shell's own render).
+  const SEED_STAMP = ${JSON.stringify(seedStamp)};
+  const SEED_QUERY = SEED_STAMP ? "?b=" + SEED_STAMP : "";
+
   let seedPayload = null;
   let seedFacts = 0;
   async function fetchSeed() {
     try {
-      const blob = await fetchWithProgress("./chat-seed.json", (loaded, total) => noteProgress("seed", loaded, total));
+      const blob = await fetchWithProgress("./chat-seed.json" + SEED_QUERY, (loaded, total) => noteProgress("seed", loaded, total));
       seedPayload = JSON.parse(await blob.text());
       seedFacts = (seedPayload.individuals || []).filter((i) => i.class === "Fact").length;
     } catch (err) {
@@ -1156,8 +1208,9 @@ ${THEME_TOKENS_CSS}
   // Best-effort IndexedDB (window.tmctChat.openPersistedStore): the whole
   // Backend-B payload snapshots after each teach turn, debounced so a burst
   // of teaching costs one multi-MB write, not one per fact. The stamp ties a
-  // snapshot to this deploy (site version) AND this seed (fact count) — either
-  // changing discards the snapshot in favour of the fresh seed.
+  // snapshot to this deploy (site version) AND this seed (its fact count and
+  // content hash) — any of them changing discards the snapshot in favour of
+  // the fresh seed.
   let persist = null;
   let saveTimer = null;
   let restoredCount = 0;
@@ -1217,6 +1270,7 @@ ${THEME_TOKENS_CSS}
       try { stats = await window.tmctChat.memoryStats(window.tmctChatSession.memoryDir); }
       catch { return; }
     }
+    factPillValueEl.textContent = Number(stats.total || 0).toLocaleString();
     renderStatsPanelInto(statsPanelEl, stats, {
       bandLabel: bandLabelFor,
       onForget: persist ? forgetEverything : null,
@@ -1598,14 +1652,20 @@ ${THEME_TOKENS_CSS}
     inputEl.focus();
   });
 
-  // "reset to seed" is the full re-initialisation: drop the persisted payload
-  // outright and reload, so boot re-seeds from the page's shipped seed as if on
-  // a first visit. Harder than "forget everything", which only swaps the live
+  // "reset to seed" is the full re-initialisation: drop everything this device
+  // holds and reload, so boot re-seeds from the page's shipped seed as if on a
+  // first visit. Harder than "forget everything", which only swaps the live
   // session — this trusts nothing in memory and re-fetches the seed asset.
+  //
+  // Both stores go, not just the payload: what you taught lives in IndexedDB,
+  // and the seed asset itself lives in the service worker's Cache Storage. A
+  // reset that cleared only the first would re-seed straight back out of a
+  // cached copy of an older seed, which is exactly what it promises not to do.
   el("reinitStore").addEventListener("click", async () => {
     clearTimeout(saveTimer);
     saveTimer = null;
     if (persist) await persist.clear();
+    await clearSiteAssetCaches();
     window.location.reload();
   });
 
@@ -1799,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
@@ -1885,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 = "";
@@ -2186,7 +2230,7 @@ ${THEME_TOKENS_CSS}
     progressActive = false;
     window.tmctChat.registerReferencePackProvider(fetchPackProvider);
     if (window.tmctChat.openPersistedStore) {
-      persist = window.tmctChat.openPersistedStore({ storeKey: "chat", stamp: siteVersion + ":" + seedFacts });
+      persist = window.tmctChat.openPersistedStore({ storeKey: "chat", stamp: siteVersion + ":" + seedFacts + ":" + SEED_STAMP });
     }
     const savedRecord = persist ? await persist.load() : null;
     const initialMode = readWikiMode();

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.
@@ -7758,6 +7810,13 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     // teach frame, in a store written before the spellings converged) is
     // found by the curated spelling it means.
     let hits = predicate ? subjectHits.filter((f) => normFactPredicate(f.predicate) === predicate) : subjectHits;
+    // A bare "what is X" answered ONLY by corpus-weak ConceptNet association(s)
+    // is the hedged "possibly: X is related to Y" guess, not a definition — treated
+    // as no hit at all so the honest-miss cascade below (teach lane, reference-pack/
+    // Wikipedia fallback) still gets a turn, instead of the hedge silently standing
+    // in as "already answered". A predicate-specific ask ("X used for") is untouched:
+    // scoped to the SAME undifferentiated shape the reference-pack fallback serves.
+    if (!predicate && hits.length && !hits.some(isRealGrounding)) hits = [];
     if (!hits.length) {
       // The subject itself is known — as a fact subject, or as the standing
       // focus a pronoun just resolved to — but not under this specific
@@ -7777,7 +7836,9 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
       // ishmael"): surface those reverse relations rather than missing, the same
       // facts "what do you know about X" would list.
       if (!predicate) {
-        const objectHits = rankByBiasThenTrust((await factRows(memoryDir, cache)).filter((f) => variants.has(f.object)), biasByBundle);
+        let objectHits = rankByBiasThenTrust((await factRows(memoryDir, cache)).filter((f) => variants.has(f.object)), biasByBundle);
+        // Same corpus-weak-only demotion as the subject-side hits above.
+        if (objectHits.length && !objectHits.some(isRealGrounding)) objectHits = [];
         if (objectHits.length) {
           const objLines = objectHits.map(renderFactLine);
           const objShown = objLines.slice(0, FACT_ANSWER_CAP);
@@ -8343,6 +8404,16 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     // besides. The adventure's own where/openness readers answer the legitimate
     // in-game questions from the world fold.
     hits = hits.filter((f) => !WORLD_INTERNAL_PREDICATES.has(f.predicate));
+    // A corpus-weak-only result set (every hit resolved ONLY through
+    // ConceptNet's /r/RelatedTo tier) still composes its hedged "possibly"
+    // lines below exactly as before — this reader's whole job is showing
+    // those, weak or not, so they're never suppressed from the text. But the
+    // result is flagged `weakOnly` so the shared honest-miss cascade (the
+    // reference-pack/Wikipedia fallback, below in runAsk) still gets a turn
+    // instead of the hedge silently standing in as "already answered" —
+    // mirroring isRealGrounding's other two call sites without breaking this
+    // one's own job.
+    const weakOnly = hits.length > 0 && !hits.some(isRealGrounding);
     // A genuinely empty result here is a real miss: "what do you know about
     // the last commit" needs a TEACH-OFFER, not a bare wall — added as a LATE
     // runTurn-level addition, below, alongside the sibling "what is X" offer,
@@ -8393,11 +8464,16 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     const header = `${hits.length} remembered fact${hits.length === 1 ? "" : "s"} about ${term}`
       + `${viaSubtype ? " (including its known subtypes)" : ""}:`;
     const { lines, grouped } = senseSplitFactList(hits, rows, variants, { indent: "  " });
-    if (grouped) return { ...grouped, text: `${header}\n${grouped.text}` };
+    if (grouped) return { ...grouped, text: `${header}\n${grouped.text}`, ...(weakOnly ? { weakOnly: true } : {}) };
     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: `${header}\n${shown.join("\n")}${extra}`, replace: true, ...(rest.length ? { pending: { items: rest.map((l) => l.trim()), noun: "facts" } } : {}) };
+    return {
+      text: `${header}\n${shown.join("\n")}${extra}`,
+      replace: true,
+      ...(rest.length ? { pending: { items: rest.map((l) => l.trim()), noun: "facts" } } : {}),
+      ...(weakOnly ? { weakOnly: true } : {}),
+    };
   }
   return null;
 }
@@ -10674,14 +10750,37 @@ async function curatedDefinitionAnswer(query, envelope, { memoryDir, lexicon })
   return { text: `${def} (source: corpus/seon)`, term };
 }
 
+/** True when `f` carries a source better than the ConceptNet `/r/RelatedTo`
+ *  corpus-weak tier — or no recorded source type at all (the conservative,
+ *  pre-existing read for legacy rows). A fact resolved ONLY by corpus-weak
+ *  source(s) is the hedged "possibly: X is related to Y" guess, not an
+ *  actual definition; callers treat it as no grounding at all rather than an
+ *  answer, so it can never by itself skip the honest-miss cascade below
+ *  (the teach lane, the reference-pack/Wikipedia fallback). Shared by the
+ *  bare "what is X" reader, the "what do you know about X" reader (both in
+ *  factAnswerReaders) and the learn-on-miss gate (cleanMissPackKey/
+ *  cleanMissLiveKey) so none of them can ever disagree. */
+function isRealGrounding(f) {
+  const types = f.sourceTypes || [];
+  return types.length === 0 || types.some((t) => t !== "corpusWeak");
+}
+
 // ---- learn-on-miss: the shipped child + reference packs behind the cleanest miss ----
 
+/** A remembered fact naming `term` is real grounding only when SOME source
+ *  behind it outranks the ConceptNet `/r/RelatedTo` corpus-weak tier — see
+ *  isRealGrounding just above. */
+function hasNonWeakGrounding(rows, variants) {
+  return rows.some((f) => (variants.has(f.subject) || variants.has(f.object)) && isRealGrounding(f));
+}
+
 /** The learn-on-miss gate, shared by the child-pack hook, the articled
  *  reference hook and the bare-form fallback so the three can never disagree.
  *  Passes only on the CLEANEST miss: a definition-shaped term the lexicon
- *  knows, resolving to no graph entity and no remembered fact — then, and
- *  only then, may a pack provider be consulted. Null means the turn proceeds
- *  byte-identically to a pack-less run. */
+ *  knows, resolving to no graph entity and no fact grounded above the
+ *  corpus-weak tier — then, and only then, may a pack provider be
+ *  consulted. Null means the turn proceeds byte-identically to a pack-less
+ *  run. */
 async function cleanMissPackKey(term, { graph, memoryDir, lexicon, cache }) {
   if (!term || !memoryDir) return null;
   let key = null;
@@ -10695,7 +10794,7 @@ async function cleanMissPackKey(term, { graph, memoryDir, lexicon, cache }) {
   const variants = factTermVariants(normFactTerm, term);
   variants.add(key);
   const rows = await factRows(memoryDir, cache);
-  if (rows.some((f) => variants.has(f.subject) || variants.has(f.object))) return null;
+  if (hasNonWeakGrounding(rows, variants)) return null;
   // A taught RULE that owns this term outranks any pack load: surfacing
   // unrelated conceptnet content over the user's own taught concept is worse
   // than the honest miss the decline leaves standing.
@@ -10723,10 +10822,10 @@ async function referencePackMissAnswer(term, { graph, memoryDir, lexicon, env, c
 }
 
 /** The LIVE variant of cleanMissPackKey — the same resolveEntity and
- *  remembered-fact checks, but through cleanMissLiveTerm, which drops the
- *  lexicon-membership wall: a word the lexicon has never met is exactly what
- *  the live lookup exists for. Null means the turn proceeds byte-identically
- *  to a live-off run. */
+ *  above-corpus-weak grounding checks, but through cleanMissLiveTerm, which
+ *  drops the lexicon-membership wall: a word the lexicon has never met is
+ *  exactly what the live lookup exists for. Null means the turn proceeds
+ *  byte-identically to a live-off run. */
 async function cleanMissLiveKey(term, { graph, memoryDir, lexicon, cache }) {
   if (!term || !memoryDir) return null;
   let key = null;
@@ -10738,7 +10837,7 @@ async function cleanMissLiveKey(term, { graph, memoryDir, lexicon, cache }) {
   const variants = factTermVariants(normFactTerm, term);
   variants.add(key);
   const rows = await factRows(memoryDir, cache);
-  if (rows.some((f) => variants.has(f.subject) || variants.has(f.object))) return null;
+  if (hasNonWeakGrounding(rows, variants)) return null;
   return key;
 }
 
@@ -12479,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)}`;
@@ -12641,6 +12745,13 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   let via = "composed";
   let recordMiss = miss;
   let factPending = null; // a truncated fact listing's held remainder (for "more" paging)
+  // Set when the memory-facts lane (W4, below) answered from a corpus-weak-only
+  // hit set (factAnswer's KNOW_ABOUT_RE reader, `weakOnly`) — the hedged
+  // "possibly" answer still stands as `answer`, but `via` is deliberately left
+  // at "composed" so the honest-miss cascade further down still gets a turn,
+  // and this flag lets the LEARN-ON-MISS PACKS lane resolve a reference-pack
+  // term for THIS query shape (which metaTermOf alone never recognizes).
+  let factLaneWeakOnly = false;
   // scm-svf1/cardinality-monotonicity/
   // cax-maxc0's LIVE proof chases (factReadBack) have no persisted Fact to
   // attach trust.mjs's entailed hook to, so they compute
@@ -13156,9 +13267,18 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       // the empty-graph orientation pointer below stays off it — a pronoun
       // decline with an index pointer under it is two answers to one turn.
       if (fact.selfContainedMiss) selfContainedMiss = true;
-      if (!fact.miss) {
+      // A `weakOnly` hit (the "what do you know about X" reader's
+      // corpus-weak-only hedge) is shown as `answer` above like any other
+      // fact-lane hit, but doesn't count as REAL grounding — via/recordMiss
+      // stay untouched so the honest-miss cascade below (the reference-pack
+      // lane in particular) still gets a turn at replacing the hedge with a
+      // real answer, exactly the discipline isRealGrounding's other two call
+      // sites already apply.
+      if (!fact.miss && !fact.weakOnly) {
         via = "fact";
         recordMiss = false;
+      } else if (fact.weakOnly) {
+        factLaneWeakOnly = true;
       }
       if (fact.pending) factPending = fact.pending; // a truncated fact list → paginable remainder
       if (typeof fact.trust === "number") entailedTrust = fact.trust; // live-chase trust (see the `entailedTrust` declaration above)
@@ -13465,13 +13585,19 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // pack's article speak, cited as before. Both packs missing leaves the
   // honest miss byte-identical.
   if (miss && recordMiss && via === "composed" && memoryDir) {
-    const refTerm = metaTermOf(query, envelope);
+    // metaTermOf only recognizes the "what is X"/"define X" shapes — a
+    // "what do you know about X" query only reaches this lane at all when
+    // its own reader (above) answered with a corpus-weak-only hedge
+    // (factLaneWeakOnly), so the KNOW_ABOUT_RE term is resolved directly the
+    // same way the TEACH-OFFER lane below already does for that shape.
+    const refTerm = metaTermOf(query, envelope)
+      || (factLaneWeakOnly ? expandContractions(String(query).trim()).match(KNOW_ABOUT_RE)?.[1]?.trim() : null);
     const key = refTerm ? await cleanMissPackKey(refTerm, { graph, memoryDir, lexicon, cache }) : null;
     const learned = key ? await childPackFactsForKey(key, { memoryDir, env, cache, synthesisBudget }) : null;
     if (learned) {
       const fact = (await factAnswer(memoryDir, query, envelope, miss, biasByBundle, cache, newFocus?.label))
         ?? (await factReadBack(memoryDir, query, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
-      if (fact && !fact.miss) {
+      if (fact && !fact.miss && !fact.weakOnly) {
         answer = fact.replace ? fact.text : `${answer}\n${fact.text}`;
         via = "fact";
         recordMiss = false;
@@ -13558,7 +13684,12 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
         const ent = knowAboutTerm ? null : await resolveEntity(graph, offerTerm);
         if (!ent) {
           const variants = factTermVariants(normFactTerm, offerTerm);
-          const known = (await memoryFacts(memoryDir)).some((f) => variants.has(f.subject) || variants.has(f.object));
+          // A corpus-weak-only match (ConceptNet's /r/RelatedTo hedge) is not
+          // real grounding — same isRealGrounding discipline as the bare
+          // "what is X" reader and the learn-on-miss gate, so a term with
+          // nothing but a loose association still gets the "teach me" offer
+          // rather than being silently counted as already known.
+          const known = hasNonWeakGrounding(await factRows(memoryDir, cache), variants);
           if (!known) teachOffer = unknownVocabTermOffer(cleanTerm);
         }
       }
@@ -14010,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) {
@@ -14698,11 +14840,18 @@ const LIST_KNOWN_KINDS_RE = /^list\s+(?:the\s+|all\s+(?:the\s+)?)?(?!facts?\b|th
 // conditional over a NAMED subject or an arbitrary property is a rule, not a
 // subclass fact, and stays outside this frame.
 const UNIVERSAL_CONDITIONAL_RE = /^if\s+(?:something|somebody|someone|anything)\s+is\s+an?\s+([\w-]+)\s*,?\s*(?:then\s+)?(?:it|they)\s+(?:is|are)\s+an?\s+([\w-]+)[.!?\s]*$/i;
-function rewriteVocabOpener(line) {
+function rewriteVocabOpener(line, { adventureLive = false } = {}) {
   let m = line.match(DESIRE_ABOUT_RE) || line.match(TELL_ABOUT_VARIANT_RE);
   if (m) return `tell me about ${m[1].trim()}`;
   m = line.match(UNIVERSAL_CONDITIONAL_RE);
   if (m) return `every ${m[1]} is ${indefiniteArticleFor(m[2])} ${m[2]}`;
+  // "what <noun> do you know [about]" shares its surface form with a live
+  // adventure's own personal-knowledge asides ("what food do you know
+  // about") — those ask what the CHARACTER has learned in-world, not for
+  // the taught CLASS's members, so this closed-set enumeration rewrite
+  // stands down while a world is live and leaves the line for the
+  // adventure lane to recognise (or not) on its own terms.
+  if (adventureLive) return null;
   m = line.match(KNOWN_KINDS_RE) || line.match(LIST_KNOWN_KINDS_RE);
   if (m) {
     const noun = teachableSubjectOf(m[1]);
@@ -14977,7 +15126,7 @@ async function dispatchTurn(input, { config, source = defaultSource, graph = nul
   const indirectMatch = line.match(INDIRECT_REQUEST_RE);
   const indirectLine = indirectMatch ? indirectMatch[1].trim() : line;
   const preRewriteLine = rewriteEntryPointQuestion(indirectLine) || rewriteProveThat(indirectLine)
-    || rewriteVocabOpener(indirectLine) || indirectLine;
+    || rewriteVocabOpener(indirectLine, { adventureLive: Boolean(planState?.adventure) }) || indirectLine;
   // rewriteUsesAsBaseFrame's discontiguous-frame rewrite: applied here, once,
   // before ANY dispatch lane sees the text. Null (no-op) for every turn that
   // doesn't match one of the four discontiguous shapes.