@polycode-projects/the-mechanical-code-talker 2.10.2 → 2.10.5

package/src/services/chat.mjs

@@ -7,7 +7,7 @@
 // `it`/`this`/`that` refer back to whatever the last command or answer
 // resolved.
 //
-// Sessions are logged to <repo>/SESSION_LOG_DIR/session-<uuidv7>.log, plus a
+// Sessions are logged to <repo>/SESSION_LOG_DIR/session-<uuidv7>.md, plus a
 // structured sidecar (.tmct/sessions/session-<uuidv7>.jsonl, sessions.mjs) and
 // a `Session` individual upserted into graph.json per turn.
 //
@@ -55,6 +55,7 @@ import { getLiveReferenceProvider } from "../adapters/corpus/wikipedia-live.mjs"
 import { CHILD_PACK_NAME, childProvenanceTag } from "../domain/child-pack.mjs";
 import { getChildPackProvider } from "../adapters/corpus/child-pack.mjs";
 import { dialogueActForLane } from "../domain/dialogue-acts.mjs";
+import { subClassParents, ancestryChain, clusterSenses } from "../domain/sense-split.mjs";
 import { relatedForTerm } from "../domain/skos-view.mjs";
 import { adventureTurn, unclaimedAdventureOpening } from "./adventure.mjs";
 import { spiderFlyTurn } from "./spider-fly-turn.mjs";
@@ -2555,6 +2556,10 @@ const GOAL_CONJUNCT_RE = new RegExp(
 // three only REPORT.
 const PLAN_WHAT_NEXT_RE = /^(?:what(?:'s|\s+is)?|whats)\s+the\s+next\s+move[?.!\s]*$/i;
 const PLAN_MOVE_COUNT_RE = /^how\s+many\s+moves(?:\s+(?:are\s+(?:there|left)|remain(?:ing)?|left|to\s+go|in\s+the\s+plan|total))?[?.!\s]*$/i;
+// "what is the goal" while a goal is held — a read-back off planState, so a
+// mid-plan aside never falls to the child-pack lane and answers from corpus
+// vocabulary about the word "goal".
+const PLAN_GOAL_READBACK_RE = /^(?:what(?:'s|\s+is)\s+(?:the\s+|my\s+)?goal|remind\s+me\s+(?:of\s+|what\s+)?the\s+goal(?:\s+is)?|what\s+am\s+i\s+solving\s+for|what\s+goal(?:'s|\s+is)\s+(?:set|held))[?.!\s]*$/i;
 // "is that really the minimum number of moves?" / "could there be a shorter
 // plan than that?" — a confirmation of the planner's own optimality claim,
 // not a request to count anything (without this it fell to the unrelated
@@ -5110,6 +5115,12 @@ const MODULE_ORIENT_SVO_RE = new RegExp(`^what\\s+(.+?)\\s+does${TRAILING_ADVERB
 // terms. "what(?:'s|s|\s+is)" mirrors PERSONAL_ASSISTANT_NUDGE_RE's own
 // tolerance for the bare "whats" contraction spelling, just below.
 const MODULE_PURPOSE_RE = /^what(?:'s|s|\s+is)\s+(.+?)\s+(?:for|about)\??$/i;
+// "what is the purpose of the validate module" — the purpose-of phrasing of the
+// SAME module-grain overview, asking by the module's role rather than "for"/
+// "does". The captured object ("the validate module", "validate") is resolved
+// through the SAME exact-unique resolveEntity gate below; a non-module term
+// simply fails to resolve and the lane declines, so this never misroutes.
+const MODULE_PURPOSE_OF_RE = /^what(?:'s|s|\s+is)\s+the\s+(?:purpose|point|role|job|function)\s+of\s+(.+?)\??$/i;
 
 /** A module PATH as a reader types it — "src/core/store.mjs", "app/lib/b.mjs",
  *  or a bare "store.mjs". Requires a slash or a source-file extension, which is
@@ -5164,7 +5175,7 @@ async function moduleOrientLane(query, { graph }) {
   // (stripFillerWords already eats "please"/"could you" as filler; the politeness
   // regex only adds the "explain [to me]" wrapper on top).
   q = stripFillerWords(applyPreambleFrames(correctMisspellings(q))).replace(MODULE_ORIENT_POLITENESS_RE, "");
-  const m = q.match(MODULE_ORIENT_RE) || q.match(MODULE_PURPOSE_RE) || q.match(MODULE_ORIENT_SVO_RE);
+  const m = q.match(MODULE_ORIENT_RE) || q.match(MODULE_PURPOSE_OF_RE) || q.match(MODULE_PURPOSE_RE) || q.match(MODULE_ORIENT_SVO_RE);
   // "what does src/core/store.mjs do" already reached the overview; the bare
   // path and "what is <path>" did not, so the same module answered one
   // phrasing and walled two. Both are claimed here rather than in ask.mjs,
@@ -5610,8 +5621,10 @@ export async function helpText() {
     ["/plan <request>", "the capability router: plan+execute a compound or maintenance-goal request (\"of the modules impacted by X, which are untested\", \"what most needs a test\")"],
     ["/capabilities", "what /plan can plan over: the built-in graph tools plus your taught actions"],
     ["/syllogise <term>", "work out and remember what follows from the facts about a term (needed for chains longer than 2 hops)"],
+    ["/export <path>", "write the memory store to a file, as JSONL (the same shape `tmct memory --export` writes)"],
+    ["/ingest <path>", "read a local text file and store every fact the recognizer grounds from it (same recognizer as `tmct extract`)"],
     ["/narrate on|off", "verbose developer/debug mode: decision points, matched pattern, results+sources, goal per turn"],
-    ["/wiki on|off", "live Wikipedia supplement (default off): a question I can't answer also tries en.wikipedia.org (network), cited"],
+    ["/wiki on|off|supplement", "live Wikipedia (default off): on tries en.wikipedia.org when I can't answer (network), cited; supplement also adds a read-out under every grounded answer"],
     ["/help", "this list"],
     ["/exit", "leave the session (also Ctrl+C / Ctrl+D)"],
   ];
@@ -5798,8 +5811,38 @@ const FACT_PREDICATE_PHRASES = {
   "mgx:similarTo": "is similar to",
   "mgx:relatedTo": "is related to",
   "mgx:symbolOf": "is a symbol of",
+  // A loaded adventure world's placement predicates, so a describe read-back of
+  // a visible prop reads as English ("lamp is in the study") instead of the
+  // mechanical -s fold garbling them ("lamp locateds in study"). The world's
+  // SECRET/mechanics predicates (a hidden object's location, the objective
+  // marker, the lock/open/NPC internals) are kept out of the describe lane
+  // entirely by WORLD_INTERNAL_PREDICATES below, so they never render at all.
+  "mgx:currently-in": "is in",
+  "mgx:located-in": "is in",
+  "mgx:fixed-in": "is fixed in",
+  "mgx:stands-locked-in": "stands locked in",
+  "mgx:works-in": "works in",
 };
 
+/** The world-mechanics predicates the generic describe read-back must never
+ *  surface: a hidden object's location and the objective marker spoil the
+ *  puzzle, and the lock/container/open/NPC-schedule flags are datatype internals
+ *  the adventure's own readers answer in-game. Mirrors adventure.mjs's own
+ *  VIEW_EXCLUDED_PREDICATES — the same discipline the room-look digest uses. */
+const WORLD_INTERNAL_PREDICATES = new Set([
+  "mgx:hidden-in", "mgx:is-objective", "mgx:unlocks-with",
+  "mgx:is-npc", "mgx:acts-on-turn", "mgx:acts-toward",
+  "mgx:is-container", "mgx:is-open",
+]);
+
+/** The world PLACEMENT predicates carry curated phrases above so they render as
+ *  English, but they must stay OUT of the query-marker families derived from
+ *  FACT_PREDICATE_PHRASES — "what is in the study" is a members-of-class query,
+ *  not a reverse placement lookup, and "is in" is far too broad an anchor. */
+const WORLD_PLACEMENT_PREDICATES = new Set([
+  "mgx:currently-in", "mgx:located-in", "mgx:fixed-in", "mgx:stands-locked-in", "mgx:works-in",
+]);
+
 /** The MECHANICAL fallback for a predicate this table has no curated entry
  *  for — specifically generalVerbTeach's minted "mgx:<lemma>" predicates
  *  ("mgx:eat", "mgx:drive", …) — the mechanical INVERSE of singularizeSurface's
@@ -5889,6 +5932,7 @@ function relationRoleWord(predicate) {
 // (no curated second table) — the single-letter "a" is excluded, too short
 // to anchor on without risking eating a genuine multi-word subject.
 const TRAILING_PREDICATE_MARKERS = Object.entries(FACT_PREDICATE_PHRASES)
+  .filter(([predicate]) => !WORLD_PLACEMENT_PREDICATES.has(predicate))
   .map(([predicate, phrase]) => {
     const m = /^(?:is|are)\s+(.+)$/i.exec(phrase);
     return m ? { predicate, marker: m[1].trim().toLowerCase() } : null;
@@ -5941,6 +5985,74 @@ function renderFactLine(f) {
   return `i learned: ${factPhrase(f)}${cite}`;
 }
 
+const SENSE_CITE_RE = / \(source: [^)]*\)$/;
+
+/** Append an is-a object's superclass chain to its rendered fact line, before
+ *  the citation: "rover is a kind of dog" becomes "rover is a kind of dog →
+ *  canine → mammal → animal". Only the subject-side is-a lines of the queried
+ *  term get a chain; every other line renders unchanged. */
+function renderFactLineWithChain(f, parents, subjectVariants) {
+  const base = renderFactLine(f);
+  if (!ISA_PREDICATES.has(f.predicate) || !subjectVariants.has(f.subject)) return base;
+  const chain = ancestryChain(f.object, parents, { cap: 6 });
+  if (chain.length <= 1) return base;
+  const suffix = ` → ${chain.slice(1).join(" → ")}`;
+  const cite = base.match(SENSE_CITE_RE);
+  return cite ? base.slice(0, cite.index) + suffix + cite[0] : base + suffix;
+}
+
+/** Render a subject-scan fact list with each is-a object's superclass chain
+ *  shown, and — when the subject's is-a objects split into distinct concepts
+ *  (a `dog` sense and a `scout` sense of one "rover") — grouped by concept.
+ *  Grouping is presentation only: every fact still renders and is cited, in
+ *  the same order, under a "<subject>, the <concept>:" heading.
+ *
+ *  Returns `{ lines, grouped }`. `lines` is the flat, chain-enhanced rendering
+ *  (indented by `indent`) the caller uses when senses do not split. `grouped`
+ *  is a ready `{ text, replace, pending? }` answer when they do, else null. */
+function senseSplitFactList(hits, rows, subjectVariants, { indent = "" } = {}) {
+  const subClassEdges = rows.filter((f) => f.predicate === SUBCLASS_PREDICATE).map((f) => [f.subject, f.object]);
+  const parents = subClassParents(subClassEdges);
+  const lines = hits.map((f) => `${indent}${renderFactLineWithChain(f, parents, subjectVariants)}`);
+
+  const isaSubjectFacts = hits.filter((f) => ISA_PREDICATES.has(f.predicate) && subjectVariants.has(f.subject));
+  const isaObjects = [...new Set(isaSubjectFacts.map((f) => f.object))];
+  if (isaObjects.length < 2) return { lines, grouped: null };
+  const disjointEdges = rows.filter((f) => f.predicate === "owl:disjointWith").map((f) => [f.subject, f.object]);
+  const { split, clusters } = clusterSenses(isaObjects, { parents, disjointEdges });
+  if (!split) return { lines, grouped: null };
+
+  const subject = isaSubjectFacts[0].subject;
+  const clusterOf = new Map();
+  for (const c of clusters) for (const o of c.objects) clusterOf.set(o, c);
+  const otherHits = hits.filter((f) => !(ISA_PREDICATES.has(f.predicate) && subjectVariants.has(f.subject)));
+
+  const blocks = [];
+  const restItems = [];
+  let shownCount = 0;
+  const addLine = (f) => {
+    const rendered = renderFactLineWithChain(f, parents, subjectVariants);
+    if (shownCount < FACT_ANSWER_CAP) { shownCount += 1; return `${indent}${rendered}`; }
+    restItems.push(rendered);
+    return null;
+  };
+  for (const c of clusters) {
+    const clusterLines = isaSubjectFacts.filter((f) => clusterOf.get(f.object) === c).map(addLine).filter(Boolean);
+    if (clusterLines.length) blocks.push(`${indent}${subject}, the ${c.label}:\n${clusterLines.join("\n")}`);
+  }
+  if (otherHits.length) {
+    const otherLines = otherHits.map(addLine).filter(Boolean);
+    if (otherLines.length) blocks.push(`${indent}also about ${subject}:\n${otherLines.join("\n")}`);
+  }
+  const extra = restItems.length ? `\n${indent}…and ${restItems.length} more — say 'more' to see them.` : "";
+  const grouped = {
+    text: blocks.join("\n") + extra,
+    replace: true,
+    ...(restItems.length ? { pending: { items: restItems, noun: "facts" } } : {}),
+  };
+  return { lines, grouped };
+}
+
 /** "a"/"an" for a term, through the SAME grammar-rules.toml "article" rule and
  *  finish.mjs's beginsWithVowelSound every other agreement site in this file
  *  uses — never a hardcoded "a", which is ungrammatical for a vowel-initial
@@ -6654,7 +6766,7 @@ const REVERSE_PREDICATE_EXCLUDE = new Set([
   "mgx:ownedBy", "owl:disjointWith", "mgx:hasProperty", "mgx:receivesAction",
 ]);
 const REVERSE_PREDICATE_MARKERS = Object.entries(FACT_PREDICATE_PHRASES)
-  .filter(([predicate]) => !REVERSE_PREDICATE_EXCLUDE.has(predicate))
+  .filter(([predicate]) => !REVERSE_PREDICATE_EXCLUDE.has(predicate) && !WORLD_PLACEMENT_PREDICATES.has(predicate))
   .map(([predicate, phrase]) => ({
     predicate,
     re: new RegExp(`^what\\s+${escapeRegex(phrase)}\\s+(.+?)[?.!\\s]*$`, "i"),
@@ -6680,7 +6792,7 @@ const FORWARD_YESNO_EXCLUDE = new Set([
   "mgx:ownedBy",
 ]);
 const FORWARD_YESNO_MARKERS = Object.entries(FACT_PREDICATE_PHRASES)
-  .filter(([predicate]) => !FORWARD_YESNO_EXCLUDE.has(predicate))
+  .filter(([predicate]) => !FORWARD_YESNO_EXCLUDE.has(predicate) && !WORLD_PLACEMENT_PREDICATES.has(predicate))
   .map(([predicate, phrase]) => {
     let re;
     if (phrase === "can be") {
@@ -7003,8 +7115,11 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     const variants = factTermVariants(normFactTerm, subject);
     // factRows (trust+sourceIds-bearing), not the plain memoryFacts shape — the
     // bias-weighted ranking below needs each hit's sourceIds to resolve which
-    // bundle it came from (memory/bias.mjs's biasForRow).
-    const subjectHits = (await factRows(memoryDir, cache)).filter((f) => variants.has(f.subject));
+    // bundle it came from (memory/bias.mjs's biasForRow). A live world's secret
+    // and mechanics predicates are dropped so "what is the letter" never reads
+    // back where it's hidden or that it's the objective (WORLD_INTERNAL_PREDICATES).
+    const subjectHits = (await factRows(memoryDir, cache))
+      .filter((f) => variants.has(f.subject) && !WORLD_INTERNAL_PREDICATES.has(f.predicate));
     let hits = predicate ? subjectHits.filter((f) => f.predicate === predicate) : subjectHits;
     if (!hits.length) {
       // The subject itself is known, but not under this specific relation —
@@ -7037,7 +7152,8 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     // "disclosed, never dropped" contract). Unconfigured/tied bias degrades to
     // trust-desc, byte-identical to before this feature existed.
     hits = rankByBiasThenTrust(hits, biasByBundle);
-    const lines = hits.map(renderFactLine);
+    const { lines, grouped } = senseSplitFactList(hits, await factRows(memoryDir, cache), variants);
+    if (grouped) return { ...grouped, replace: miss };
     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.` : "";
@@ -7533,6 +7649,12 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
         hits = rows.filter((f) => overlaps(f.subject) || overlaps(f.object));
       }
     }
+    // A live adventure world's mechanics never leak through the describe lane:
+    // "what is the letter" must not read back where it's hidden or that it's the
+    // objective, and those datatype internals render as garbled non-English
+    // 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 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,
@@ -7580,12 +7702,13 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     // renders (Part 6's "disclosed, never dropped" contract); literalHit/
     // viaSubtype above already resolved off the pre-rank order.
     hits = rankByBiasThenTrust(hits, biasByBundle);
-    const lines = hits.map((f) => `  ${renderFactLine(f)}`);
+    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}` };
     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.` : "";
-    const header = `${hits.length} remembered fact${hits.length === 1 ? "" : "s"} about ${term}`
-      + `${viaSubtype ? " (including its known subtypes)" : ""}:`;
     return { text: `${header}\n${shown.join("\n")}${extra}`, replace: true, ...(rest.length ? { pending: { items: rest.map((l) => l.trim()), noun: "facts" } } : {}) };
   }
   return null;
@@ -9819,11 +9942,20 @@ async function cleanMissPackKey(term, { graph, memoryDir, lexicon, cache }) {
   if (!key) return null;
   if (await resolveEntity(graph, term)) return null;
   let normFactTerm;
-  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
+  let loadMemory;
+  let readRuleRows;
+  try { ({ normFactTerm, loadMemory, readRuleRows } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   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;
+  // 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.
+  try {
+    const ruleNames = readRuleRows(await loadMemory(memoryDir)).map((r) => normFactTerm(r.name)).filter(Boolean);
+    if (ruleNames.some((n) => variants.has(n))) return null;
+  } catch { /* tolerated — the fact gate above already ran */ }
   return key;
 }
 
@@ -9891,22 +10023,87 @@ async function childPackFactsForKey(key, { memoryDir, env, cache }) {
     })));
   } catch { return null; }
   if (cache) cache.rows = null;
+  await synthesiseAroundTerm(memoryDir, key, cache);
   return { key, count: row.facts.length };
 }
 
-/** Store the article's first-sentence isa as a subClassOf fact carrying
- *  reference provenance — AFTER the cited answer composed, and failure-
- *  tolerated: the answer stands whether or not the fact lands. */
-async function appendReferenceIsaFact(memoryDir, key, article, cache, tagFor = referenceProvenanceTag) {
-  if (!article?.isa) return;
+/** Store every triple the article's summary grounds — its first-sentence isa
+ *  plus each candidate the optimistic tier reads from the rest of the summary —
+ *  all under the article's own provenance, so a learned load becomes durable
+ *  knowledge rather than a single isa fact. Runs AFTER the cited answer composed
+ *  and is failure-tolerated: the answer stands whether or not the facts land.
+ *  The optimistic tier is pure (no recognizer re-entry), so this stays cheap on
+ *  the chat turn. Returns the count stored. */
+async function ingestReferenceArticle(memoryDir, key, article, cache, tagFor = referenceProvenanceTag, lexicon = null) {
+  if (!article) return 0;
+  const provenance = tagFor(article);
+  const facts = [];
+  const seen = new Set();
+  const add = (subject, predicate, object) => {
+    const id = `${subject}\0${predicate}\0${object}`;
+    if (subject && object && subject !== object && !seen.has(id)) { seen.add(id); facts.push({ subject, predicate, object, provenance }); }
+  };
+  if (article.isa) add(key, "rdfs:subClassOf", article.isa);
   try {
-    const { appendFact } = await import("../adapters/memory/core.mjs");
-    await appendFact(memoryDir, {
-      subject: key, predicate: "rdfs:subClassOf", object: article.isa,
-      provenance: tagFor(article),
-    });
+    const { optimisticTriples } = await import("./extract-facts.mjs");
+    for (const sentence of splitSentences(article.summary || article.text || "")) {
+      for (const t of optimisticTriples(sentence, { lexicon: lexicon ?? undefined })) add(t.subject, t.predicate, t.object);
+    }
+  } catch { /* the isa alone still lands below */ }
+  if (!facts.length) return 0;
+  try {
+    const { appendFacts } = await import("../adapters/memory/core.mjs");
+    await appendFacts(memoryDir, facts);
     if (cache) cache.rows = null;
-  } catch { /* tolerated — the cited answer is already composed */ }
+  } catch { return 0; }
+  await synthesiseAroundTerm(memoryDir, key, cache);
+  return facts.length;
+}
+
+// A learn-on-miss load stores a handful of new facts; the auto-synthesis pass
+// that connects them to the rest of the store is deliberately small — a low
+// budget, focus expanded through the loaded term — so it stays a per-ingest
+// materialisation, not the whole-store maintenance job /syllogise runs.
+const AUTO_SYNTHESIS_BUDGET = 12;
+
+/** After a learn-on-miss load stored new facts about `term`, run a bounded,
+ *  focus-scoped forward-chaining pass so the new facts connect to what's
+ *  already remembered — the auto sibling of the /syllogise command. Derived
+ *  facts carry entailed:* provenance at their discounted trust and are
+ *  retractable. Failure-tolerated: a synthesis miss never disturbs the answer
+ *  the load already composed. Returns the count derived. */
+async function synthesiseAroundTerm(memoryDir, term, cache) {
+  if (!memoryDir || !term) return 0;
+  try {
+    const { syllogise } = await import("../domain/syllogise.mjs");
+    const { loadMemory, readFactRows, appendFacts, normFactTerm } = await import("../adapters/memory/core.mjs");
+    const res = await syllogise(memoryDir, {
+      focus: [...factTermVariants(normFactTerm, term)],
+      expandFocus: true,
+      budget: AUTO_SYNTHESIS_BUDGET,
+      store: { loadMemory, readFactRows, appendFacts },
+    });
+    if (res?.count && cache) cache.rows = null;
+    return res?.count || 0;
+  } catch { return 0; }
+}
+
+/** The term an explicit "ask Wikipedia" phrasing names — "what does wikipedia
+ *  say about X", "ask wikipedia about X", "X on wikipedia" — or null when the
+ *  line isn't such a request. Unlike the clean-miss gate, this fires even when
+ *  local facts could answer: the user asked Wikipedia specifically. */
+const WIKIPEDIA_ASK_RES = [
+  /^what\s+(?:does|do)\s+wikipedia\s+say\s+(?:about\s+)?(.+?)[?.!\s]*$/i,
+  /^ask\s+wikipedia\s+(?:about\s+)?(.+?)[?.!\s]*$/i,
+  /^(?:look\s+up\s+|tell\s+me\s+about\s+|what\s+(?:is|are)\s+(?:an?\s+|the\s+)?)?(.+?)\s+on\s+wikipedia[?.!\s]*$/i,
+];
+function wikipediaAskTerm(query) {
+  const q = String(query || "").trim();
+  for (const re of WIKIPEDIA_ASK_RES) {
+    const m = q.match(re);
+    if (m && m[1] && m[1].trim()) return m[1].trim().replace(/^(?:an?|the)\s+/i, "");
+  }
+  return null;
 }
 
 /** The concept term a vague "what is a X" / "tell me about X" / "what does X mean" /
@@ -10100,6 +10297,11 @@ async function describeWrapperAnswer(query, { config, source, focus, graph, tel
   // captured term, same class of gap stripTrailingDiscourseTag (ask-vocab.mjs)
   // already fixes for the meta-whatis vocab lane.
   term = stripTrailingDiscourseTag(term);
+  // "tell me about the router thing" / "the logging stuff" — a vague filler
+  // noun wrapped around a real term. Strip it so the describe lane resolves
+  // the term itself; an unresolvable remainder still declines to the ordinary
+  // miss below, so this only ever widens what grounds, never misroutes.
+  term = term.replace(/\s+(?:thing|things|thingy|stuff)$/i, "").trim() || term;
   if (DESCRIBE_PRONOUN_RE.test(term)) {
     if (!focus?.label) return null; // no standing focus to resolve against — honest decline
     term = focus.label;
@@ -10684,7 +10886,7 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", ga
   if (wantsLegal) {
     let moves;
     try {
-      moves = movesFromRules(state, domain);
+      moves = movesFromRules(state, domain, { scope: "taught" });
     } catch (err) {
       if (err instanceof PlanBudgetError) {
         return { text: `too many possible moves to enumerate here (${err.message}) — narrow the classes involved.`, via: "plan", deduced: "list the legal moves (budget exceeded)", note: "plan lane — budget decline" };
@@ -10774,7 +10976,7 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", ga
   }
   let isGoal;
   try {
-    isGoal = compileGoal(goals, domain);
+    isGoal = compileGoal(goals, domain, { scope: "taught" });
   } catch (err) {
     return { text: `I can't compile that goal: ${err?.message ?? err}`, via: "plan", deduced: "plan a move sequence (uncompilable goal)", note: "plan lane — goal compile decline" };
   }
@@ -10782,7 +10984,7 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", ga
   const maxDepth = gameConfig?.planning?.maxDepth ?? DEFAULT_GAME_CONFIG.planning.maxDepth;
   let found;
   try {
-    found = findActionPath(state, isGoal, (s) => movesFromRules(s, domain), { maxDepth, stateKey: stateKeyFor });
+    found = findActionPath(state, isGoal, (s) => movesFromRules(s, domain, { scope: "taught" }), { maxDepth, stateKey: stateKeyFor });
   } catch (err) {
     if (err instanceof PlanBudgetError) {
       return { text: `the search space is too large (${err.message}) — narrow the classes involved.`, via: "plan", deduced: "plan a move sequence (budget exceeded)", note: "plan lane — budget decline" };
@@ -10883,7 +11085,7 @@ async function executePlanStep(planHolder, { memoryDir, sessionId = "" }) {
   const factRows = readFactRows(payload);
   const domain = compileDomain(factRows, readRuleRows(payload));
   const finalState = stateFromFacts(factRows, domain);
-  const holds = compileGoal(ps.goals, domain)(finalState);
+  const holds = compileGoal(ps.goals, domain, { scope: "taught" })(finalState);
   planHolder.state = { ...planHolder.state, done: true };
   return {
     text: holds
@@ -10940,6 +11142,18 @@ async function planFollowUpAnswer(query, { memoryDir, planHolder, pendingPager =
     };
   }
 
+  if (PLAN_GOAL_READBACK_RE.test(q)) {
+    if (!ps || !(ps.goalTexts?.length || ps.goals?.length)) return null;
+    const goalText = ps.goalTexts?.length ? ps.goalTexts.join("; ") : "the goal you set";
+    const status = activePlan
+      ? ` A plan is ready — ${ps.actions.length} move${ps.actions.length === 1 ? "" : "s"}; say "next" to step through it.`
+      : ' Say "solve it" when the board is taught.';
+    return {
+      text: `the goal is that ${goalText}.${status}`,
+      deduced: "read back the held goal",
+      note: "PLAN FOLLOW-UP — goal read-back from the held planState",
+    };
+  }
   if (PLAN_WHAT_NEXT_RE.test(q)) {
     if (!activePlan) return null;
     if (ps.done || ps.cursor >= ps.actions.length) {
@@ -11109,6 +11323,31 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       });
     }
   }
+  // EXPLICIT WIKIPEDIA ASK — "what does wikipedia say about X" / "ask wikipedia
+  // about X" / "X on wikipedia". Unlike the clean-miss packs, this fires even
+  // when local facts could answer: the user named the source. It still honours
+  // the network opt-in (a live lookup is a network request), so with the toggle
+  // off it points at /wiki on rather than reaching the network.
+  {
+    const wikiTerm = wikipediaAskTerm(query);
+    if (wikiTerm) {
+      note(trace, "goal: read what Wikipedia says about a named term (explicit source request)");
+      if (!liveReference) {
+        note(trace, "lane: WIKIPEDIA ASK — the explicit request needs the network opt-in; live Wikipedia is off");
+        return plainTurn(query, `live Wikipedia is off, so I won't reach the network. Turn it on with /wiki on (it fetches from en.wikipedia.org), then ask again.`, { via: "miss", miss: true, focus });
+      }
+      let liveKey = null;
+      try { liveKey = cleanMissLiveTerm(wikiTerm, lexicon ?? undefined); } catch { liveKey = null; }
+      const live = liveKey ? await liveReferenceAnswerForKey(liveKey, onLiveLookup) : null;
+      if (live) {
+        await ingestReferenceArticle(memoryDir, live.key, live.article, cache, liveProvenanceTag, lexicon);
+        note(trace, `lane: WIKIPEDIA ASK — answered from a live en.wikipedia.org lookup, cited (article "${live.article.title}", revid ${live.article.revid})`);
+        return plainTurn(query, live.text, { via: "reference", miss: false, focus });
+      }
+      note(trace, "lane: WIKIPEDIA ASK — no matching live article (no title, timeout, throttle, or drift-guard reject)");
+      return plainTurn(query, `I couldn't reach a matching Wikipedia article for "${wikiTerm}" just now.`, { via: "miss", miss: true, focus });
+    }
+  }
   // COLLECTIVE PLURAL SUBJECT — see COLLECTIVE_FORWARD_RE. Members are the
   // modules whose path carries the plural as a component; two or more make it
   // a group question, answered as the disclosed union over every member. One
@@ -11720,15 +11959,15 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   const coldPronounDecline = focus?.label ? null : coldPronounDeclineText(query);
   if (bareMetaHit?.reference) {
     // The bare-form reference hit mirrors (4h): the cited answer replaces the
-    // miss, the turn is no longer recorded as one, and the article's isa is
-    // stored after the answer composes.
+    // miss, the turn is no longer recorded as one, and the article's grounded
+    // triples are stored after the answer composes.
     answer = bareMetaHit.text;
     via = "reference";
     recordMiss = false;
     handled = true;
     note(trace, "lane: (2b) REFERENCE PACK — a bare \"what is X\" clean miss answered from the shipped reference pack, cited");
     note(trace, `source: reference pack ${REFERENCE_PACK_NAME} — article "${bareMetaHit.reference.article.title}" (revid ${bareMetaHit.reference.article.revid})`);
-    await appendReferenceIsaFact(memoryDir, bareMetaHit.reference.key, bareMetaHit.reference.article, cache);
+    await ingestReferenceArticle(memoryDir, bareMetaHit.reference.key, bareMetaHit.reference.article, cache, referenceProvenanceTag, lexicon);
   } else if (bareMetaHit?.live) {
     // The bare-form LIVE hit settles the same way, under live provenance.
     answer = bareMetaHit.text;
@@ -11737,7 +11976,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     handled = true;
     note(trace, "lane: (2b) LIVE WIKIPEDIA — a bare \"what is X\" clean miss answered from a live en.wikipedia.org lookup (opt-in), cited");
     note(trace, `source: live reference ${LIVE_PACK_NAME} — article "${bareMetaHit.live.article.title}" (revid ${bareMetaHit.live.article.revid})`);
-    await appendReferenceIsaFact(memoryDir, bareMetaHit.live.key, bareMetaHit.live.article, cache, liveProvenanceTag);
+    await ingestReferenceArticle(memoryDir, bareMetaHit.live.key, bareMetaHit.live.article, cache, liveProvenanceTag, lexicon);
   } else if (bareMetaHit) {
     answer = bareMetaHit.replace ? bareMetaHit.text : `${answer}\n${bareMetaHit.text}`;
     // Same discipline as lane (3): a fact-lane return flagged `miss` is an
@@ -12144,7 +12383,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
         recordMiss = false;
         note(trace, "lane: (4h) REFERENCE PACK — a clean miss on a lexicon term answered from the shipped reference pack, cited");
         note(trace, `source: reference pack ${REFERENCE_PACK_NAME} — article "${ref.article.title}" (revid ${ref.article.revid})`);
-        await appendReferenceIsaFact(memoryDir, ref.key, ref.article, cache);
+        await ingestReferenceArticle(memoryDir, ref.key, ref.article, cache, referenceProvenanceTag, lexicon);
       }
     }
     // The live Wikipedia supplement (opt-in), strictly AFTER both shipped
@@ -12160,7 +12399,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
         recordMiss = false;
         note(trace, "lane: (4h) LIVE WIKIPEDIA — a clean miss answered from a live en.wikipedia.org lookup (opt-in), cited");
         note(trace, `source: live reference ${LIVE_PACK_NAME} — article "${live.article.title}" (revid ${live.article.revid})`);
-        await appendReferenceIsaFact(memoryDir, live.key, live.article, cache, liveProvenanceTag);
+        await ingestReferenceArticle(memoryDir, live.key, live.article, cache, liveProvenanceTag, lexicon);
       }
     }
   }
@@ -12258,6 +12497,23 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     answer = `hypothetically, if ${counterfactualSubject[1].trim()} were removed: ${answer}`;
     note(trace, `intermediate: COUNTERFACTUAL_RE matched — compiled to a real traversal, wrapped as hypothetical ("${counterfactualSubject[1].trim()}" removed)`);
   }
+  // LIVE SUPPLEMENT (/wiki supplement): a grounded answer also carries what
+  // Wikipedia says about its subject — corroboration, not rescue. Scoped to a
+  // clean vocabulary subject (a "what is X" / "tell me about X" term), never a
+  // code-graph entity, and never doubled onto an answer that already IS a
+  // Wikipedia read-out. Failure-tolerated, and network-gated by the same toggle
+  // (the "supplement" value is truthy, so the rescue lanes above already ran).
+  if (liveReference === "supplement" && !recordMiss && via !== "reference") {
+    const supplementTerm = metaTermOf(query, envelope) || vagueTouchTermOf(query);
+    let liveKey = null;
+    try { liveKey = supplementTerm ? cleanMissLiveTerm(supplementTerm, lexicon ?? undefined) : null; } catch { liveKey = null; }
+    const live = liveKey ? await liveReferenceAnswerForKey(liveKey, onLiveLookup) : null;
+    if (live) {
+      answer = `${answer}\nWikipedia adds: ${live.text}`;
+      await ingestReferenceArticle(memoryDir, live.key, live.article, cache, liveProvenanceTag, lexicon);
+      note(trace, `intermediate: LIVE SUPPLEMENT — appended a cited en.wikipedia.org read-out for "${supplementTerm}" (supplement mode)`);
+    }
+  }
   // The concept force answers WITH real example instances — those are the entities the
   // turn "asked about" (the SchemaClass meta-node is documentation, not a code entity),
   // so record + expand them, not the schema match.
@@ -12347,6 +12603,8 @@ const GOAL_BY_COMMAND = {
   capabilities: "see what /plan can plan over — built-in query tools and taught actions",
   syllogise: "materialize the entailed facts that follow from what's remembered about one term",
   wiki: "toggle the live Wikipedia supplement for questions nothing local can answer",
+  export: "write the memory store to a file, in the standard JSONL shape",
+  ingest: "read a local text file and store every fact the recognizer grounds from it",
 };
 
 /** A slash-command → the mapped tool (or the /help, /focus, /narrate, unknown
@@ -12395,12 +12653,14 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
   // state). A bare "/wiki" reports the CURRENT state and changes nothing.
   if (name === "wiki") {
     const arg = argText.toLowerCase();
-    if (arg !== "on" && arg !== "off") {
-      return mk(`live Wikipedia supplement is ${liveReference ? "on" : "off"} — /wiki on or /wiki off. `
-        + "When on, a question I can't answer also tries en.wikipedia.org (network).");
+    const stateWord = (v) => (v === "supplement" ? "supplement" : v ? "on" : "off");
+    if (arg !== "on" && arg !== "off" && arg !== "supplement") {
+      return mk(`live Wikipedia supplement is ${stateWord(liveReference)} — /wiki on, /wiki off, or /wiki supplement. `
+        + "When on, a question I can't answer also tries en.wikipedia.org (network); "
+        + "supplement adds a cited Wikipedia read-out under every grounded answer too.");
     }
-    const next = arg === "on";
-    return mk(`live Wikipedia supplement ${next ? "on" : "off"}.`, { liveReferenceNext: next });
+    const next = arg === "supplement" ? "supplement" : arg === "on";
+    return mk(`live Wikipedia supplement ${stateWord(next)}.`, { liveReferenceNext: next });
   }
 
   // /memory [verbose] — what tmct remembers, as text (the same renderer
@@ -12507,6 +12767,92 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
     }
   }
 
+  // /export <path> — write the whole memory store as JSONL, the SAME shape
+  // `tmct memory --export` and the tmct_export cold tool already emit
+  // (serializeFactsJsonl, export-jsonl.mjs) — so a chat session can take its
+  // facts with it without dropping to a shell.
+  if (name === "export") {
+    note(trace, "goal: write the memory store to a file, in the standard JSONL shape");
+    if (!memoryDir) return mk("no memory store here — /export works inside a repo session.", { miss: true });
+    if (!argText) return mk("/export needs a path, e.g. `/export facts.jsonl`.", { miss: true });
+    try {
+      const { loadMemory } = await import("../adapters/memory/core.mjs");
+      const { serializeFactsJsonl } = await import("../adapters/memory/export-jsonl.mjs");
+      const { writeFile } = await import("node:fs/promises");
+      const { resolve } = await import("node:path");
+      const jsonl = serializeFactsJsonl(await loadMemory(memoryDir));
+      const out = resolve(process.cwd(), argText);
+      await writeFile(out, jsonl, "utf8");
+      const count = jsonl ? jsonl.trimEnd().split("\n").length : 0;
+      note(trace, `result: wrote ${count} fact(s) to ${out}`);
+      return mk(`wrote ${count} fact${count === 1 ? "" : "s"} to ${argText}.`);
+    } catch (e) {
+      return mk(String(e?.message || e), { miss: true }); // a broken store/path reads as its own clean error
+    }
+  }
+
+  // /ingest <path> — the TUI/CLI counterpart to `tmct extract`: read a local
+  // text file, run each sentence through the SAME recognizer the teach lane
+  // already grounds sentences with (runTurn itself — the identical per-
+  // sentence pass extract-facts.mjs's own CLI wrapper runs), and store every
+  // grounded fact into THIS session's own memory store. Deliberately does
+  // NOT call extract-facts.mjs's own main(): that entry point resolves its
+  // OWN memoryDir from a --repo path (or an ephemeral scratch dir), so it
+  // can never target the session's already-open backend handle — grounding
+  // through this session's live memoryDir is what makes an ingested fact
+  // answerable in the SAME conversation, not just written to disk somewhere.
+  if (name === "ingest") {
+    note(trace, "goal: ingest a local text file into the memory store, sentence by sentence");
+    if (!memoryDir) return mk("no memory store here — /ingest works inside a repo session.", { miss: true });
+    if (!argText) return mk("/ingest needs a path, e.g. `/ingest notes.txt`.", { miss: true });
+    const { resolve } = await import("node:path");
+    const { readFile } = await import("node:fs/promises");
+    const filePath = resolve(process.cwd(), argText);
+    let text;
+    try {
+      text = await readFile(filePath, "utf8");
+    } catch (e) {
+      return mk(`couldn't read ${argText} — ${e?.code === "ENOENT" ? "no such file." : String(e?.message || e)}`, { miss: true });
+    }
+    const { splitSentencesPreservingPaths } = await import("./sentences.mjs");
+    const { loadMemory, readFactRows, appendFact } = await import("../adapters/memory/core.mjs");
+    const { touchedFactRows } = await import("../domain/memory/touched-facts.mjs");
+    const sourceTag = filePath.split(/[\\/]/).pop();
+    const sentences = splitSentencesPreservingPaths(text);
+    let recognizedSentences = 0;
+    let factCount = 0;
+    for (const sentence of sentences) {
+      const before = readFactRows(await loadMemory(memoryDir));
+      const { record: ingestRecord } = await runTurn(sentence, { config, memoryDir, sessionId: uuidv7() });
+      if (ingestRecord?.via !== "assert" || ingestRecord?.miss) continue;
+      const after = readFactRows(await loadMemory(memoryDir));
+      const rows = touchedFactRows(before, after);
+      if (!rows.length) continue;
+      recognizedSentences += 1;
+      for (const row of rows) {
+        await appendFact(memoryDir, {
+          subject: row.subject, predicate: row.predicate, object: row.object,
+          provenance: `extracted:${sourceTag}`, quantifier: row.quantifier || "",
+        });
+        factCount += 1;
+      }
+    }
+    if (cache) cache.rows = null; // the fact-rows cache predates these writes
+    const skipped = sentences.length - recognizedSentences;
+    note(trace, `result: ${sentences.length} sentence(s), ${recognizedSentences} recognized, ${factCount} fact row(s), ${skipped} skipped`);
+    if (!factCount) {
+      return mk(
+        `read ${sentences.length} sentence${sentences.length === 1 ? "" : "s"} from ${argText} — none grounded into a `
+        + "recognized fact shape (an honest, expected gap; this is an attempt, not full NLU).",
+        { miss: true },
+      );
+    }
+    return mk(
+      `ingested ${factCount} fact${factCount === 1 ? "" : "s"} from ${argText} `
+      + `(${recognizedSentences} of ${sentences.length} sentence${sentences.length === 1 ? "" : "s"} recognized).`,
+    );
+  }
+
   // /plan <request> — the capability router (src/domain/router/*): plan+execute a
   // compound ("of the modules impacted by X, which are untested", "assess X
   // and then check Y") or maintenance-goal ("what most needs a test") request