@polycode-projects/the-mechanical-code-talker 2.10.3 → 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";
@@ -5114,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
@@ -5168,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,
@@ -5614,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)"],
   ];
@@ -5976,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
@@ -7075,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.` : "";
@@ -7624,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;
@@ -9863,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;
 }
 
@@ -9935,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" /
@@ -10144,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;
@@ -11165,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
@@ -11776,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;
@@ -11793,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
@@ -12200,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
@@ -12216,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);
       }
     }
   }
@@ -12314,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.
@@ -12403,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
@@ -12451,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
@@ -12563,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

package/src/services/code-explorer-viz.mjs

@@ -31,6 +31,17 @@ export function edgePhrase(kind) {
   return EDGE_PHRASE.get(String(kind || "")) || String(kind || "").replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase();
 }
 
+// Both packagers (build-electron-app.mjs, build-demo-site.mjs) place
+// vendor/wink.js one level below the page they render, so the same loader
+// script inlines into renderCodeExplorerHtml's `winkLoaderInline` slot for
+// either channel.
+export const VENDOR_WINK_LOADER_JS = `window.__WINK_LOADER__ = async function () {
+  var m = await import("./vendor/wink.js");
+  return { winkNLP: m.winkNLP, model: m.model };
+};`;
+
+export const DESKTOP_APP_URL = "https://gitlab.com/polycode-projects/the-mechanical-code-talker#the-code-explorer-desktop";
+
 const LEDGER_ROW_LIMIT_DEFAULT = 4000;
 
 /** Pure derivation over an entities payload (individuals + objectProperties).
@@ -247,9 +258,11 @@ const CLIENT_JS = String.raw`
  * computeCodeExplorerData's output. `bundleInline` inlines the dock engine
  * (for a single-file page / a data: URL); otherwise `bundleAvailable` links
  * `./code-explorer.bundle.js`. `winkLoaderInline` optionally inlines a wink
- * model loader as `window.__WINK_LOADER__`.
+ * model loader as `window.__WINK_LOADER__`. `showDesktopLink` adds a line
+ * pointing at the desktop app's README section — the desktop shell itself
+ * renders this page too and passes `false`, since it has nothing to point at.
  */
-export function renderCodeExplorerHtml(data, { bundleInline = "", bundleAvailable = false, winkLoaderInline = "", sourceName = "demo code graph" } = {}) {
+export function renderCodeExplorerHtml(data, { bundleInline = "", bundleAvailable = false, winkLoaderInline = "", sourceName = "demo code graph", showDesktopLink = false } = {}) {
   const payloadJson = embedJson(data.payload);
   const dataJson = embedJson({ ledger: data.ledger, hints: data.hints, focus: data.focus, meta: data.meta });
   const title = escapeHtml(data.meta?.title || "code explorer");
@@ -304,6 +317,7 @@ ul.rows { list-style: none; margin: 0; padding: 0; }
 <header>
   <h1>tmct code explorer</h1>
   <span class="sub">source: <span id="source-name">${escapeHtml(sourceName)}</span></span>
+  ${showDesktopLink ? `<span class="sub">Also available as a <a href="${DESKTOP_APP_URL}">desktop app</a>.</span>` : ""}
   <div class="pickers">
     <button id="open-graph">Open graph…</button>
     <button id="open-repo">Open repo…</button>