@polycode-projects/the-mechanical-code-talker 2.10.3 → 2.11.0

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.
 //
@@ -51,12 +51,14 @@ import {
   LIVE_PACK_NAME, cleanMissLiveTerm, renderLiveReferenceAnswer, liveProvenanceTag,
 } from "../domain/reference-pack.mjs";
 import { getReferencePackProvider } from "../adapters/corpus/reference-pack.mjs";
-import { getLiveReferenceProvider } from "../adapters/corpus/wikipedia-live.mjs";
+import { getLiveReferenceProvider, getResearchProvider } from "../adapters/corpus/wikipedia-live.mjs";
+import { researchTurn, researchSnapshot, resolveResearchConfig, RESEARCH_DEFAULTS } from "./research.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 { adventureTurn, unclaimedAdventureOpening, foldWorldState } from "./adventure.mjs";
 import { spiderFlyTurn } from "./spider-fly-turn.mjs";
 import { DEFAULT_GAME_CONFIG } from "../domain/game-config.mjs";
 
@@ -3137,7 +3139,8 @@ async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon
 // sentence said ("tony never eats ribs" -> tony eats ribs) — a truthful teach
 // read back as a confident lie. It belongs to NEG_MARKER_SRC below.
 const TEACH_ADVERB_SKIP_SRC = "(?:(?:usually|often|sometimes|rarely|always|typically|generally|"
-  + "occasionally|frequently|normally|regularly|commonly|mostly|currently|still|also|really|actually)\\s+)?";
+  + "occasionally|frequently|normally|regularly|commonly|mostly|currently|still|also|really|actually|"
+  + "closely|strongly|directly)\\s+)?";
 /** The negation markers a teach/query frame recognizes, in ONE place so the
  *  teach side and the query side can never disagree about what negates a
  *  sentence — the same discipline TEACH_ADVERB_SKIP_SRC is shared under. */
@@ -3162,6 +3165,96 @@ function splitTeachNegation(payload) {
   return { payload: `${m[1]} ${canFamily ? "can " : ""}${m[3]}`.trim(), negated: true };
 }
 const GENERAL_VERB_TEACH_RE = new RegExp(`^([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+)\\s+(.+?)[.!?]*$`, "i");
+/** The closed participle set the relational teach frames read as "X is
+ *  <participle> <prep> Y" — a past participle whose own form is the word, so it
+ *  reads back with no morphology. Closed by list (templates over general
+ *  grammar), so the frame can never widen onto an arbitrary "-ed" adjective. */
+const TEACH_PARTICIPLE_SRC = "connected|related|associated|linked|based|derived|composed|made|used|known|located|found|involved|concerned";
+/** The prepositions those participles take. A closed set, folded into the
+ *  minted predicate (mgx:<participle>-<prep>) the same way PREP_SRC folds into
+ *  the general-verb frame's. */
+const TEACH_PARTICIPLE_PREP_SRC = "with|to|from|by|of|in|on|for|as|about|into";
+/** "X is <participle> <prep> Y" — "sales are closely connected with marketing"
+ *  → sales mgx:connected-with marketing. The subject is one or two tokens (the
+ *  same bound the comparative/unknown-subject frames use), an optional adverb
+ *  is skipped, and the object is captured for a determiner-strip + 3-token cap
+ *  by its handler. */
+const PARTICIPLE_PREP_TEACH_RE = new RegExp(
+  `^(?:the\\s+|an?\\s+)?([\\w'-]+(?:\\s+[\\w'-]+)?)\\s+(?:is|are|was|were)\\s+${TEACH_ADVERB_SKIP_SRC}(${TEACH_PARTICIPLE_SRC})\\s+(${TEACH_PARTICIPLE_PREP_SRC})\\s+(.+)$`,
+  "i",
+);
+/** "X is a <noun> <participle> <prep> Y" — a copula-NP with a trailing
+ *  participle clause: "sales are activities related to selling" decomposes into
+ *  the class-membership half (sales ⊑ activity, through the ordinary mint/assert
+ *  path) AND the relational half (sales mgx:related-to selling). The NP head is
+ *  a single token, followed by a closed participle — which keeps this disjoint
+ *  from PARTICIPLE_PREP_TEACH_RE, where the participle sits right after the
+ *  copula. */
+const COPULA_NP_PARTICIPLE_TEACH_RE = new RegExp(
+  `^(?:the\\s+|an?\\s+)?([\\w'-]+(?:\\s+[\\w'-]+)?)\\s+(is|are|was|were)\\s+(?:an?\\s+)?([\\w'-]+)\\s+(${TEACH_PARTICIPLE_SRC})\\s+(${TEACH_PARTICIPLE_PREP_SRC})\\s+(.+)$`,
+  "i",
+);
+/** "A and B have/share the same <noun>" — "sales and marketing have the same
+ *  goal" → sales mgx:same-goal-as marketing. A closed shape; the conjunction
+ *  pre-pass leaves it alone (its second clause never opens with is/are/has/
+ *  have/can), so it reaches the teach dispatch whole. */
+const SAME_NOUN_TEACH_RE = /^(?:the\s+)?([\w'-]+)\s+and\s+(?:the\s+)?([\w'-]+)\s+(?:have|has|share|shares)\s+(?:the\s+)?same\s+([\w'-]+)[.!?]*$/i;
+/** "the letter is in the garden" — a locative teach whose subject the running
+ *  adventure world already places somewhere. Group 1 is the subject; the world
+ *  place is left to the fold, since the sentence is stored as a note either
+ *  way. */
+const LOCATIVE_TEACH_RE = /^(?:the\s+)?([\w'-]+)\s+(?:is|are|was|were)\s+(?:in|on|under|inside|at|near|behind|above|below)\s+(?:the\s+)?[\w'-]+/i;
+/** Fold a relational object down to its head phrase: cut at the first clause
+ *  boundary (a comma, semicolon, or a coordinating "or"/"and"), strip a leading
+ *  determiner, then cap at 3 tokens — "selling or the number of goods sold in a
+ *  period" folds to "selling", "the number of goods" to "number of goods".
+ *  Keeps a minted relational object bounded, the same discipline the general-
+ *  verb frame's own object fold uses. */
+function participleObject(raw) {
+  const cleaned = String(raw).trim()
+    .replace(/[.!?]+$/, "")
+    .split(/\s*[,;]\s*|\s+(?:or|and)\s+/i)[0]
+    .trim()
+    .replace(/^(?:the|an?|its|his|her|their|our|my|your|some|any)\s+/i, "");
+  return cleaned.split(/\s+/).slice(0, 3).join(" ");
+}
+/** Does a bare (unwrapped) sentence fit one of the relational teach frames —
+ *  including its negated twin, read through splitTeachNegation the same way the
+ *  general-verb and capability frames read theirs? Used only to admit the
+ *  sentence as a teach payload; the dispatch below re-matches and stores. */
+function matchesRelationalTeachFrame(sentence) {
+  const { payload } = splitTeachNegation(String(sentence || "").trim());
+  return PARTICIPLE_PREP_TEACH_RE.test(payload)
+    || COPULA_NP_PARTICIPLE_TEACH_RE.test(payload)
+    || SAME_NOUN_TEACH_RE.test(payload);
+}
+/** Does a relational-frame sentence name a code-graph entity? "the Router is
+ *  used by every handler" reads as a passive uses-CLAIM the ask engine verifies
+ *  against the graph ("No — no uses edge found…"), not a fact to store — the
+ *  participle+preposition frame would otherwise intercept it. When any term the
+ *  frame would store resolves to a graph entity, the frame yields so the graph
+ *  lane keeps the sentence. No graph (a bare/browser/ingest turn) means nothing
+ *  to yield to, so the frame proceeds. */
+async function relationalFrameNamesGraphEntity(sentence, graph) {
+  if (!graph) return false;
+  const { payload } = splitTeachNegation(String(sentence || "").trim());
+  let terms = null;
+  const pp = payload.match(PARTICIPLE_PREP_TEACH_RE);
+  if (pp) terms = [pp[1], participleObject(pp[4])];
+  else {
+    const np = payload.match(COPULA_NP_PARTICIPLE_TEACH_RE);
+    if (np) terms = [np[1], np[3], participleObject(np[6])];
+    else {
+      const same = payload.match(SAME_NOUN_TEACH_RE);
+      if (same) terms = [same[1], same[2]];
+    }
+  }
+  if (!terms) return false;
+  for (const t of terms) {
+    try { if (await resolveEntity(graph, String(t).trim())) return true; } catch { /* unresolved is fine */ }
+  }
+  return false;
+}
 /** Determiners/quantifiers that make the FIRST token an article, not a real
  *  bare-name subject ("every controller…", "the cache…") — GENERAL_VERB_TEACH_RE
  *  would otherwise happily bind them as a 1-token subject and misread the
@@ -3992,7 +4085,7 @@ async function teachExclusionReason(sentence) {
 }
 export { teachExclusionReason };
 
-async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cache = null, planHolder = null }) {
+async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cache = null, planHolder = null, graph = null }) {
   // A closed discourse-marker preamble ahead of a teach sentence ("howdy
   // pardner, remember that TaskController is fragile") would otherwise
   // corrupt TEACH_RE's own match, so strip it first. applyPreambleFrames is
@@ -4868,7 +4961,10 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
 
   let payload = null;
   if (wrapped && /\b(?:is|are)\b/i.test(wrapped)) payload = wrapped;
-  else if ((BARE_DECLARATIVE_RE.test(raw) || COMPARATIVE_TEACH_RE.test(raw) || matchBareHabitualTeach(raw) || matchBareCanTeach(raw)) && !QUESTION_LEAD_RE.test(raw) && !(await hasMidSentenceInterrogative(raw))) payload = raw;
+  else if ((BARE_DECLARATIVE_RE.test(raw) || COMPARATIVE_TEACH_RE.test(raw)
+      || (matchesRelationalTeachFrame(raw) && !(await relationalFrameNamesGraphEntity(raw, graph)))
+      || matchBareHabitualTeach(raw) || matchBareCanTeach(raw))
+      && !QUESTION_LEAD_RE.test(raw) && !(await hasMidSentenceInterrogative(raw))) payload = raw;
   if (!payload) {
     // "remember margo eats ribs", re-escaping here through a combination
     // that mechanism's own deliberate subject-shape restriction doesn't
@@ -4900,6 +4996,58 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       });
       if (stored) return stored;
     }
+    // RELATIONAL teach frames — a participle+preposition claim
+    // ("sales are closely connected with marketing"), a copula-NP with a
+    // trailing participle ("sales are activities related to selling"), or a
+    // shared-attribute claim ("sales and marketing have the same goal"). Each
+    // reads through splitTeachNegation like its comparative/general-verb
+    // siblings, so a negated form stores the mgxneg: twin.
+    {
+      const { payload: posPayload, negated } = splitTeachNegation(String(payload).trim());
+      // (D) participle + preposition, checked ahead of the copula-NP form so a
+      // bare participle right after the copula is never misread as a noun.
+      const pp = posPayload.match(PARTICIPLE_PREP_TEACH_RE);
+      if (pp) {
+        const pred = `mgx:${pp[2].toLowerCase()}-${pp[3].toLowerCase()}`;
+        const stored = await teachFact(memoryDir, sessionId, {
+          subject: pp[1].trim(), predicate: negated ? negatedPredicate(pred) : pred,
+          object: participleObject(pp[4]),
+        });
+        if (stored) return stored;
+      }
+      // (E) copula-NP + trailing participle — decomposed into the
+      // class-membership half (subject ⊑ singular(NP head)) and the relational
+      // half. The copula-NP shape is a deliberate declarative, strong enough to
+      // mint the membership directly, so it lands even when neither term is in
+      // the lexicon (the acceptance the ingest pipeline needs). Either half may
+      // stand on its own if the other's write fails.
+      const np = posPayload.match(COPULA_NP_PARTICIPLE_TEACH_RE);
+      if (np) {
+        const subject = np[1].trim();
+        const relPred = `mgx:${np[4].toLowerCase()}-${np[5].toLowerCase()}`;
+        const isaStored = await teachFact(memoryDir, sessionId, {
+          subject, predicate: SUBCLASS_PREDICATE, object: singularizeSurface(np[3]),
+        });
+        const relStored = await teachFact(memoryDir, sessionId, {
+          subject, predicate: negated ? negatedPredicate(relPred) : relPred,
+          object: participleObject(np[6]),
+        });
+        const stripNoted = (t) => String(t).replace(/^noted — remembered(?:\s+\d+\s+facts?)?:\s*/i, "").trim();
+        if (isaStored && relStored) return { text: `noted — remembered both: ${stripNoted(isaStored.text)}; and ${stripNoted(relStored.text)}`, via: "assert", miss: false };
+        if (relStored) return relStored;
+        if (isaStored) return isaStored;
+      }
+      // (F) shared attribute — "A and B have the same <noun>".
+      const same = posPayload.match(SAME_NOUN_TEACH_RE);
+      if (same) {
+        const pred = `mgx:same-${same[3].toLowerCase()}-as`;
+        const stored = await teachFact(memoryDir, sessionId, {
+          subject: same[1].trim(), predicate: negated ? negatedPredicate(pred) : pred,
+          object: same[2].trim(),
+        });
+        if (stored) return stored;
+      }
+    }
     for (const cand of assertCandidates(payload)) {
       // assertTurn ITSELF records the "every" quantifier (point 3) on a plain
       // universal success, so every caller (this loop AND the top-level
@@ -5114,6 +5262,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
@@ -5168,7 +5322,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,
@@ -5614,8 +5768,11 @@ 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|always", "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 vocabulary answer; always widens that to every grounded answer"],
+    ["research <topic> [limit N]", "fetch the topic from Simple English Wikipedia (the explicit ask is the network consent), store what it grounds, and queue its linked topics — \"research next\" steps the queue; also status/stop"],
     ["/help", "this list"],
     ["/exit", "leave the session (also Ctrl+C / Ctrl+D)"],
   ];
@@ -5895,6 +6052,14 @@ function predicatePhrase(predicate) {
   // "is smaller than" (never a 3sg fold — "smallers" isn't a word)
   const comp = /^mgx:([a-z]+(?:-[a-z]+)*)-than$/i.exec(p);
   if (comp) return `is ${comp[1].replace(/-/g, " ")} than`;
+  // a participle + preposition renders as its copula surface: mgx:connected-with
+  // -> "is connected with" (the participle is already a participle, so no 3sg
+  // fold — "connecteds" isn't a word)
+  const part = new RegExp(`^mgx:(${TEACH_PARTICIPLE_SRC})-([a-z]+)$`, "i").exec(p);
+  if (part) return `is ${part[1].toLowerCase()} ${part[2].toLowerCase()}`;
+  // a shared-attribute predicate: mgx:same-goal-as -> "has the same goal as"
+  const same = /^mgx:same-([a-z]+)-as$/i.exec(p);
+  if (same) return `has the same ${same[1].toLowerCase()} as`;
   const m = /^mgx:([a-z]+)(?:-([a-z]+))?$/i.exec(p);
   if (!m) return predicate;
   // a folded preposition renders back naturally: mgx:rest-on -> "rests on"
@@ -5976,6 +6141,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
@@ -7075,7 +7308,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.` : "";
@@ -7624,12 +7858,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;
@@ -9863,11 +10098,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;
 }
 
@@ -9924,7 +10168,7 @@ async function liveReferenceAnswerForKey(key, onLiveLookup) {
  *  key up in the shipped child triples pack and append every fact under child
  *  provenance, so the SAME question can be re-asked from the store. Null on a
  *  pack miss or any failure — the turn then proceeds byte-identically. */
-async function childPackFactsForKey(key, { memoryDir, env, cache }) {
+async function childPackFactsForKey(key, { memoryDir, env, cache, synthesisBudget = AUTO_SYNTHESIS_BUDGET }) {
   let row = null;
   try { row = await getChildPackProvider(env).lookup(key); } catch { row = null; }
   if (!row?.facts?.length) return null;
@@ -9935,22 +10179,87 @@ async function childPackFactsForKey(key, { memoryDir, env, cache }) {
     })));
   } catch { return null; }
   if (cache) cache.rows = null;
+  await synthesiseAroundTerm(memoryDir, key, cache, synthesisBudget);
   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, synthesisBudget = AUTO_SYNTHESIS_BUDGET) {
+  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, synthesisBudget);
+  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, budget = AUTO_SYNTHESIS_BUDGET) {
+  if (!memoryDir || !term || budget <= 0) 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,
+      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" /
@@ -10144,6 +10453,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;
@@ -11122,8 +11436,12 @@ const DECISION_RECALL_RE = /^(?:remind\s+me\s+)?what\s+(?:did\s+)?(?:we|i|you)\s
  *  than silently accepted alongside the current location. */
 const MOVE_HISTORY_RE = /^where\s+did\s+(.+?)\s+(?:move|get\s+moved|go)(?:\s+to)?[?.!\s]*$/i;
 
-async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null, planHolder = null, gameConfig = DEFAULT_GAME_CONFIG, liveReference = false, onLiveLookup = null }) {
+async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null, planHolder = null, gameConfig = DEFAULT_GAME_CONFIG, liveReference = false, onLiveLookup = null, uiContext = "cli", synthesisBudget = AUTO_SYNTHESIS_BUDGET }) {
   const ts = new Date().toISOString();
+  // The surface this turn runs on ("cli" default; "browser" from a web entry) —
+  // the honest-miss tail below points a browser/adventure miss at the teach
+  // lane instead of the CLI-only --repo/tmct-init remedy.
+  const browser = uiContext === "browser";
   // DISCOURSE ANAPHORA: a follow-up like "which of those are tested" / "count
   // them" filters or counts the PREVIOUS answer's entity set, threaded as
   // ask()'s `prev`. Prefers the FULL id set (`allIds`) over `matches`, since a
@@ -11165,6 +11483,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, synthesisBudget);
+        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
@@ -11320,8 +11663,12 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // examples are the wrong audience here), an unseeded one at the seed/
     // teach pair — vocabHint already carries exactly that split.
     answer = (!graph || noCodeGraph(graph)) && (!config || e?.emptyGraph || /^cannot read graph artifact\b/.test(thrown))
+      // A browser session has no `tmct init in a repo` to reach for, so its
+      // fallback drops that CLI-only remedy and keeps just the teach pointer.
       ? `I can't answer that as a code question — no code graph is loaded in this session. ${vocabHint
-        || "I can still remember and answer taught facts (try \"every bug is an issue\"), or run `tmct init` in a repo to index one."}`
+        || (browser
+          ? "I can still remember and answer taught facts (try \"every bug is an issue\")."
+          : "I can still remember and answer taught facts (try \"every bug is an issue\"), or run `tmct init` in a repo to index one.")}`
       : thrown;
     note(trace, `intermediate: the ask engine threw — ${thrown}`);
   }
@@ -11720,7 +12067,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       if (!bareMetaHit) {
         const refTerm = metaTermOf(factQuery, envelope);
         const key = refTerm ? await cleanMissPackKey(refTerm, { graph, memoryDir, lexicon, cache }) : null;
-        const learned = key ? await childPackFactsForKey(key, { memoryDir, env, cache }) : null;
+        const learned = key ? await childPackFactsForKey(key, { memoryDir, env, cache, synthesisBudget }) : null;
         if (learned) {
           const fact = (await factAnswer(memoryDir, factQuery, envelope, miss, biasByBundle, cache, newFocus?.label))
             ?? (await factReadBack(memoryDir, factQuery, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
@@ -11776,15 +12123,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, synthesisBudget);
   } else if (bareMetaHit?.live) {
     // The bare-form LIVE hit settles the same way, under live provenance.
     answer = bareMetaHit.text;
@@ -11793,7 +12140,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, synthesisBudget);
   } 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
@@ -12020,7 +12367,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // (4) #2 TEACH lane — a teach-shaped would-miss nothing above answered: route to
   // memory, or say what CAN be remembered (LOUD), never the wall / a silent drop.
   if (miss && recordMiss && via === "composed") {
-    const taught = await teachLane(query, { memoryDir, sessionId, lexicon, cache, planHolder });
+    const taught = await teachLane(query, { memoryDir, sessionId, lexicon, cache, planHolder, graph });
     if (taught) {
       answer = taught.text; via = taught.via; recordMiss = taught.miss;
       if (!taught.miss) dialogueLaneOverride = "teach";
@@ -12039,6 +12386,26 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       // kind of parent" as inherits) keeps its canonical: it genuinely
       // restates the relation the teach stored.
       if (envelope?.parsed?.fuzzyVerb) canonical = null;
+      // A mid-game locative teach is accepted and stored as the player's own
+      // note, but a running adventure's world only moves through actions — so
+      // when the taught subject is a term the world already places, the
+      // confirmation says so plainly. (The fold itself keeps taught rows out of
+      // the world state; this is the matching UX.)
+      if (!taught.miss && planHolder?.state?.adventure) {
+        const loc = String(query).trim().match(LOCATIVE_TEACH_RE);
+        if (loc) {
+          let placed = false;
+          try {
+            const { normFactTerm } = await import("../adapters/memory/core.mjs");
+            const world = foldWorldState(await factRows(memoryDir, cache));
+            placed = world.placements.has(normFactTerm(loc[1]));
+          } catch { placed = false; }
+          if (placed) {
+            answer = `${answer}\n(noted as your note — the game world itself only changes through actions like go, take and open.)`;
+            note(trace, "intermediate: mid-game locative teach — stored as a note; the adventure fold only moves through actions");
+          }
+        }
+      }
     }
   }
   // (4b) #4 AUTHOR lane — "who is <Name>", "what did <Name> touch",
@@ -12179,7 +12546,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   if (miss && recordMiss && via === "composed" && memoryDir) {
     const refTerm = metaTermOf(query, envelope);
     const key = refTerm ? await cleanMissPackKey(refTerm, { graph, memoryDir, lexicon, cache }) : null;
-    const learned = key ? await childPackFactsForKey(key, { memoryDir, env, 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));
@@ -12200,7 +12567,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, synthesisBudget);
       }
     }
     // The live Wikipedia supplement (opt-in), strictly AFTER both shipped
@@ -12216,7 +12583,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, synthesisBudget);
       }
     }
   }
@@ -12238,12 +12605,25 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     note(trace, `lane: (5) SHORT TAILORED MISS — every lane above declined; ${repeat ? "REPEAT collapsed to one-liner (wall kindness)" : "the full grammar wall was shortened + tailored to the query's keywords"}`);
   }
   // #4 HONEST-EMPTY POLISH — an empty CODE graph: any still-standing engine
-  // dead-end (an honest empty, the short miss, the bootstrap note) carries the exit
-  // toward a real graph, unless it already points there. Only when genuinely empty.
+  // dead-end (an honest empty, the short miss, the bootstrap note) carries the
+  // exit toward a real graph, unless it already points there. Only when
+  // genuinely empty. The CLI keeps the --repo/example pointer verbatim; a
+  // browser or a live adventure has no such command to reach for, so each gets
+  // a teach-forward pointer (and the adventure also names the world asides that
+  // are guaranteed to hit).
+  const adventureLive = !!planHolder?.state?.adventure;
   if (recordMiss && (via === "composed" || via === "miss")
       && noCodeGraph(graph) && !/--repo|tmct init|no code graph/i.test(answer)) {
-    answer = `${answer}\n(this repo has no code graph — for structure, point me at a \`.tmct/graph.json\` with \`--repo <path>\` or run \`npm run example:mini\`; tmct doesn't index code itself.)`;
-    note(trace, "intermediate: HONEST-EMPTY POLISH — the loaded graph has 0 modules, so the dead-end got a --repo/tmct init pointer appended");
+    if (adventureLive) {
+      answer = `${answer}\n(I don't know that yet — you can teach me: say "remember: <thing> is a <kind>". Or ask the world: "look", "where is the key", "talk to the butler".)`;
+      note(trace, "intermediate: HONEST-EMPTY POLISH — a live adventure miss points at the teach lane and the world asides, not the --repo remedy");
+    } else if (browser) {
+      answer = `${answer}\n(I don't know that yet — you can teach me: say "remember: <thing> is a <kind>".)`;
+      note(trace, "intermediate: HONEST-EMPTY POLISH — a browser miss points at the teach lane, not the CLI-only --repo remedy");
+    } else {
+      answer = `${answer}\n(this repo has no code graph — for structure, point me at a \`.tmct/graph.json\` with \`--repo <path>\` or run \`npm run example:mini\`; tmct doesn't index code itself.)`;
+      note(trace, "intermediate: HONEST-EMPTY POLISH — the loaded graph has 0 modules, so the dead-end got a --repo/tmct init pointer appended");
+    }
   }
   // TEACH-OFFER: a "what is X" miss where X is genuinely unknown EVERYWHERE —
   // not a real graph entity, not a schema/vocab term, and not already in
@@ -12314,6 +12694,27 @@ 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, and its superset /wiki always): 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 doubled onto an answer that
+  // already IS a Wikipedia read-out. Failure-tolerated, and network-gated by
+  // the same toggle (both values are truthy, so the rescue lanes above already
+  // ran). "always" widens the term fallback to an ordinary grounded ask's own
+  // parsed object, so a plain code/fact answer also gets corroborated; the
+  // adapter's throttle bounds the request rate.
+  if ((liveReference === "supplement" || liveReference === "always") && !recordMiss && via !== "reference") {
+    const supplementTerm = metaTermOf(query, envelope) || vagueTouchTermOf(query)
+      || (liveReference === "always" ? envelope?.parsed?.object : null);
+    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, synthesisBudget);
+      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.
@@ -12403,6 +12804,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
@@ -12451,12 +12854,15 @@ 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 === "always" ? "always" : v === "supplement" ? "supplement" : v ? "on" : "off");
+    if (arg !== "on" && arg !== "off" && arg !== "supplement" && arg !== "always") {
+      return mk(`live Wikipedia supplement is ${stateWord(liveReference)} — /wiki on, /wiki off, /wiki supplement, or /wiki always. `
+        + "When on, a question I can't answer also tries en.wikipedia.org (network); "
+        + "supplement adds a cited Wikipedia read-out under every grounded vocabulary answer too; "
+        + "always widens that to every grounded answer.");
     }
-    const next = arg === "on";
-    return mk(`live Wikipedia supplement ${next ? "on" : "off"}.`, { liveReferenceNext: next });
+    const next = arg === "always" ? "always" : arg === "supplement" ? "supplement" : arg === "on";
+    return mk(`live Wikipedia supplement ${stateWord(next)}.`, { liveReferenceNext: next });
   }
 
   // /memory [verbose] — what tmct remembers, as text (the same renderer
@@ -12563,6 +12969,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
@@ -13457,7 +13949,7 @@ function vocabAntecedentFrom(last) {
   return m[1];
 }
 
-export async function runTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = false, liveReference = false, onLiveLookup = null, vocabHint = null, tel = null, biasByBundle = {}, factRowsCache: injectedFactRowsCache = null, planState = null, gameConfig = null, _noSplit = false } = {}) {
+export async function runTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = false, liveReference = false, onLiveLookup = null, vocabHint = null, tel = null, biasByBundle = {}, factRowsCache: injectedFactRowsCache = null, planState = null, gameConfig = null, uiContext = "cli", synthesisBudget = AUTO_SYNTHESIS_BUDGET, researchState = null, researchConfig = null, _noSplit = false } = {}) {
   // Every game's tuning knobs (spider-fly's mass economy, guess-the-number's
   // bounds, the shared plan lane's search-depth cap) — a caller's own
   // gameConfig (chat-session.mjs resolves one per session from tmct.toml)
@@ -13522,7 +14014,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // the PLAN NEXT block below write planHolder.state; every other path leaves
   // it untouched, and the caller re-threads whatever comes back.
   const planHolder = { state: planState };
-  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, liveReference, onLiveLookup, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache, vocabAntecedent, planHolder, gameConfig: resolvedGameConfig };
+  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, liveReference, onLiveLookup, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache, vocabAntecedent, planHolder, gameConfig: resolvedGameConfig, uiContext, synthesisBudget };
   // A DISPATCHED turn (count / slash-command / ask) becomes the new "last
   // answer" that why/say-more re-renders; a conversational turn does not.
   // Every dispatched turn's result passes through finish() here — the LAST
@@ -13660,6 +14152,47 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     }
   }
 
+  // RESEARCH — "research <topic>[, limit N]" runs a Simple English Wikipedia
+  // queue through the same ingest path a live-Wikipedia rescue uses: depth 0
+  // now, the lead section's linked topics queued for "research next" (which
+  // the web pages' auto-play button submits turn by turn). The explicit
+  // request is the network consent for its own fetches — unlike the
+  // clean-miss rescue, which fires on an ordinary question and so stays
+  // behind /wiki on. Queue state threads turn-to-turn as researchState, the
+  // same way planState does.
+  {
+    const researchHolder = { state: researchState };
+    const resolvedResearchConfig = researchConfig ?? RESEARCH_DEFAULTS;
+    const rTurn = await researchTurn(workingLine, {
+      holder: researchHolder,
+      memoryDir,
+      lexicon,
+      provider: getResearchProvider({ minIntervalMs: resolvedResearchConfig.minIntervalMs }),
+      config: resolvedResearchConfig,
+      planActive: Boolean(planHolder.state && !planHolder.state.done),
+      pagerActive: Boolean(Array.isArray(last?.detail?.pending?.items) && last.detail.pending.items.length),
+      notify: onLiveLookup,
+      ingest: (key, article, tag) =>
+        ingestReferenceArticle(memoryDir, key, article, factRowsCache, () => tag, lexicon, synthesisBudget),
+    });
+    if (rTurn) {
+      note(trace, `lane: ${rTurn.note}`);
+      note(trace, `goal: ${rTurn.goal}`);
+      const result = plainTurn(workingLine, rTurn.text, { via: "research", miss: !!rTurn.miss, focus });
+      result.lane = "research";
+      const snapshot = researchSnapshot(researchHolder.state);
+      if (snapshot) result.record.research = snapshot;
+      const rec = withLast(result, rTurn.goal);
+      rec.planState = planHolder.state;
+      rec.researchState = researchHolder.state;
+      // Present on EVERY research turn — null when the run ended or never
+      // started — so a UI can tell "queue cleared" from "not a research
+      // turn" (where the field is absent entirely).
+      rec.research = snapshot;
+      return rec;
+    }
+  }
+
   // Conversational layer next (greetings, thanks, help, bye, why/say-more) — these
   // resolve no entity and carry their own preserved `last`. Bypasses withLast (a
   // conversational turn is never finish()'d / never becomes a new `last`), so the