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

package/src/services/chat.mjs

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

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

@@ -2,11 +2,14 @@
 // a title bar (graph source, Open graph…/Open repo…), an explorer sidebar
 // reading each import/call/contains edge back as a plain sentence, a chat
 // centre over the same graph with a rail of suggested questions, and a status
-// bar carrying the graph's own counts. The chat session seeds BOTH the loaded
-// code graph and chat.html's general-knowledge bands (./chat-seed.json,
-// fetched lazily at runtime), so one conversation answers "what is a queue"
-// and "what imports src/core/model.mjs" alike — and degrades to graph-only
-// when the seed asset is unavailable.
+// bar carrying the graph's own counts. Clicking a term asks the engine what
+// relates to it (askRelatedFacts, over tmct_ask) and renders the answer, so the
+// sidebar and the chat put the same question to the same place.
+//
+// The chat session seeds BOTH the loaded code graph and chat.html's
+// general-knowledge bands (./chat-seed.json, fetched lazily at runtime), so one
+// conversation answers "what is a queue" and "what imports src/core/model.mjs"
+// alike — and degrades to graph-only when the seed asset is unavailable.
 //
 // The derivations are pure so the shell, the packaging scripts, and the unit
 // tests all share one code path; renderCodeExplorerHtml builds one
@@ -18,24 +21,14 @@
 
 import { THEME_TOKENS_CSS, SERIF_STACK, MONO_STACK, escapeHtml, embedJson, embedScriptText } from "./viz-theme.mjs";
 import { generateCodeHints } from "../domain/code-explorer-hints.mjs";
+import { phraseForRelation } from "../domain/ask-vocab.mjs";
+import { fetchWithProgress } from "./memory-panel-viz.mjs";
 
-// Third-person verb for each stored relation kind, symbol grain folded onto its
-// coarse sibling. A kind with no row here reads back as itself, never breaking
-// the sentence.
-const EDGE_PHRASE = new Map([
-  ["imports", "imports"],
-  ["calls", "calls"], ["callsSymbol", "calls"],
-  ["contains", "contains"],
-  ["defines", "defines"],
-  ["inherits", "inherits from"],
-  ["tests", "tests"],
-  ["touches", "touches"], ["touchesSymbol", "touches"],
-  ["cochange", "co-changes with"],
-  ["reexports", "re-exports"],
-]);
-
+// Third-person verb for each stored relation kind, symbol grain folded onto
+// its coarse sibling — derived from ask-vocab.mjs's own RELATIONS table
+// rather than a second hand-curated relation-verb table.
 export function edgePhrase(kind) {
-  return EDGE_PHRASE.get(String(kind || "")) || String(kind || "").replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase();
+  return phraseForRelation(kind);
 }
 
 // Both packagers (build-electron-app.mjs, build-demo-site.mjs) place
@@ -117,7 +110,7 @@ export function computeCodeExplorerData(payload, opts = {}) {
 const CLIENT_JS = String.raw`
 (function () {
   var DATA = window.__CODE_EXPLORER__;
-  var api = window.tmctCodeExplorer || null;
+  var api = window.tmct ? window.tmct.page : null;
   var els = {
     focus: document.getElementById("focus-name"),
     ledger: document.getElementById("ledger"),
@@ -133,11 +126,7 @@ const CLIENT_JS = String.raw`
   };
   var session = null;
 
-  function esc(s) {
-    return String(s == null ? "" : s).replace(/[&<>"']/g, function (c) {
-      return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c];
-    });
-  }
+  var esc = ${escapeHtml.toString()};
 
   function renderStats(data) {
     var s = data.ledger.stats;
@@ -155,11 +144,37 @@ const CLIENT_JS = String.raw`
     els.factTotal.textContent = (edges + seedState.facts).toLocaleString();
   }
 
-  function renderFocusRows(data) {
+  // "What relates to the focus", put to the engine. askRelatedFacts asks
+  // tmct_ask one question per relation kind the loaded graph carries, in both
+  // directions, and hands back the answers' own typed rows — the same ask()
+  // this page's chat turns reach, so the panel and the conversation answer one
+  // question one way. Null on the static page, which has no engine to ask.
+  function askRelated(focus) {
+    if (!api || !api.askRelatedFacts || !focus) return null;
+    try {
+      return api.askRelatedFacts(DATA.payload, focus);
+    } catch (e) {
+      console.warn("tmct code explorer: the related-facts ask failed, splitting the row list instead", e);
+      return null;
+    }
+  }
+
+  function rowKey(r) { return JSON.stringify([r.s, r.kind, r.o]); }
+
+  function renderFocusRows(data, related) {
     var focus = data.focus;
     var rows = data.ledger.rows;
-    var near = rows.filter(function (r) { return r.s === focus || r.o === focus; });
-    var rest = rows.filter(function (r) { return r.s !== focus && r.o !== focus; });
+    // The engine's answer whenever it grounded one. The row list's own split is
+    // what is left when there is no engine (the static page) or when every
+    // question came back parsed as something else — an identifier that is
+    // itself a relation verb reads as a question about the verb.
+    var grounded = Boolean(related && related.grounded);
+    var near = grounded ? related.rows : rows.filter(function (r) { return r.s === focus || r.o === focus; });
+    var nearKeys = {};
+    near.forEach(function (r) { nearKeys[rowKey(r)] = true; });
+    // Whatever the neighbourhood did not already name, in degree order: a bulk
+    // view of the rest of the graph, which is a fold and not a question.
+    var rest = rows.filter(function (r) { return !nearKeys[rowKey(r)]; });
     var ordered = near.concat(rest);
     els.ledger.innerHTML = ordered.map(function (r) {
       var hot = (r.s === focus || r.o === focus) ? " row-focus" : "";
@@ -168,7 +183,9 @@ const CLIENT_JS = String.raw`
         + '<span class="verb">' + esc(r.phrase) + '</span> '
         + '<button class="term" data-term="' + esc(r.o) + '">' + esc(r.o) + '</button>'
         + '</li>';
-    }).join("") || '<li class="row muted">no edges in this graph.</li>';
+    }).join("") || (grounded
+      ? '<li class="row muted">nothing in this graph relates to ' + esc(focus) + '.</li>'
+      : '<li class="row muted">no edges in this graph.</li>');
     els.focus.textContent = focus || "—";
   }
 
@@ -188,7 +205,7 @@ const CLIENT_JS = String.raw`
 
   function mountView(data) {
     renderStats(data);
-    renderFocusRows(data);
+    renderFocusRows(data, askRelated(data.focus));
     renderHints(data);
   }
 
@@ -233,23 +250,7 @@ const CLIENT_JS = String.raw`
   function seedNote(text) { if (els.seedStatus) els.seedStatus.textContent = text; }
   function mbText(n) { return (n / 1048576).toFixed(1); }
 
-  async function fetchTextWithProgress(url, onProgress) {
-    var res = await fetch(url);
-    if (!res.ok) throw new Error("HTTP " + res.status);
-    var total = Number(res.headers.get("content-length")) || 0;
-    if (!res.body || !res.body.getReader) return res.text();
-    var reader = res.body.getReader();
-    var chunks = [];
-    var loaded = 0;
-    for (;;) {
-      var step = await reader.read();
-      if (step.done) break;
-      chunks.push(step.value);
-      loaded += step.value.byteLength;
-      onProgress(loaded, total);
-    }
-    return new Blob(chunks).text();
-  }
+  var fetchWithProgress = ${fetchWithProgress.toString()};
 
   async function loadSeed() {
     try {
@@ -258,9 +259,10 @@ const CLIENT_JS = String.raw`
         seedNote("loading general knowledge…");
         text = await window.tmctDesktop.readSeed();
       } else {
-        text = await fetchTextWithProgress("./chat-seed.json" + SEED_QUERY, function (loaded, total) {
+        var seedBlob = await fetchWithProgress("./chat-seed.json" + SEED_QUERY, function (loaded, total) {
           seedNote("loading general knowledge… " + mbText(loaded) + (total ? " of " + mbText(total) : "") + " MB");
         });
+        text = await seedBlob.text();
       }
       if (text) {
         seedState.payload = JSON.parse(text);

package/src/services/ingest-viz.mjs

@@ -2,7 +2,7 @@
 // self-contained document shaped exactly like chat-page-viz.mjs's own
 // page-builder — one inlined <style> importing viz-theme.mjs's shared tokens,
 // behaviour as an inlined IIFE — running the ingest engine
-// (ingest-browser.bundle.js's globalThis.tmctIngest) by same-origin relative
+// (ingest-browser.bundle.js's globalThis.tmct) by same-origin relative
 // paths.
 //
 // The page's own chrome is a two-pane translate-tool layout: mode pills
@@ -26,46 +26,20 @@
 // input. scripts/build-demo-site.mjs calls it directly and writes the result
 // to public/ingest.html, after ingest-browser.bundle.js already exists.
 import { THEME_TOKENS_CSS, SERIF_STACK, MONO_STACK, escapeHtml } from "./viz-theme.mjs";
-import { bandLabelFor, statsSummaryLine, clearSiteAssetCaches, fetchWithProgress, renderStatsPanelInto } from "./memory-panel-viz.mjs";
+import {
+  bandLabelFor,
+  statsSummaryLine,
+  clearSiteAssetCaches,
+  fetchWithProgress,
+  renderStatsPanelInto,
+  loadProgressLine,
+  factTripleParts,
+} from "./memory-panel-viz.mjs";
+import { loadWinkVendor } from "./viz-boot.mjs";
+import { cloneMemoryPayload } from "../adapters/memory/core.mjs";
 
 const DEFAULT_TITLE = "the-mechanical-code-talker — ingest";
 
-/** One grounded fact as a canonical triple line — subject, predicate, object,
- *  each in its own cell so the pane can align them. Pure and
- *  `.toString()`-splice safe (no outer refs): the inline script splices this
- *  in and calls it per row. */
-export function factTripleParts(fact) {
-  return {
-    subject: String((fact && fact.subject) || ""),
-    predicate: String((fact && fact.predicate) || ""),
-    object: String((fact && fact.object) || ""),
-    provenance: String((fact && fact.provenance) || ""),
-  };
-}
-
-/** The boot statusline while the big assets stream in — the same aggregator
- *  chat-page-viz.mjs's own loadProgressLine is (kept as this page's own copy
- *  rather than a shared import — the two pages' boot lines diverge slightly
- *  and neither is a collaborator the other calls). `parts` is an array of
- *  { loaded, total } byte counts (total 0 when the response carried no
- *  Content-Length); with no usable total the line shows loaded bytes alone
- *  rather than inventing a denominator. Self-contained, `.toString()`-splice
- *  safe. */
-export function loadProgressLine(parts) {
-  const mb = (n) => (n / 1048576).toFixed(1);
-  let loaded = 0;
-  let total = 0;
-  let totalKnown = true;
-  for (const p of parts || []) {
-    loaded += (p && p.loaded) || 0;
-    if (p && p.total > 0) total += p.total;
-    else totalKnown = false;
-  }
-  return totalKnown && total > 0
-    ? "loading the engine… " + mb(loaded) + " MB / " + mb(total) + " MB"
-    : "loading the engine… " + mb(loaded) + " MB";
-}
-
 /** The self-contained ingest page. Pure — the same output for the same
  *  `title` every time; every piece of state (the session, each grounded fact)
  *  is computed live in the browser once the sibling ingest bundle loads. */
@@ -159,7 +133,7 @@ ${THEME_TOKENS_CSS}
      the right of the ingest column (a real layout column, not an overlay) —
      the same class names and breakpoint chat-page-viz.mjs's own docked panel
      uses, re-rendered after boot and after every ingest from
-     window.tmctIngest's own memoryStats(). */
+     window.tmct's own memoryStats(). */
   .statsPanel { flex: 0 0 300px; max-width: 300px; overflow-y: auto; border-left: 1px solid var(--line); padding: 1.1rem 1.2rem 1.6rem; font-family: ${MONO_STACK}; font-size: .74rem; line-height: 1.55; display: flex; flex-direction: column; }
   .statsPanel h2 { font-size: .66rem; letter-spacing: .07em; text-transform: uppercase; color: var(--muted); margin: 1.3rem 0 .5rem; }
   .statsPanel h2:first-child { margin-top: 0; }
@@ -385,8 +359,8 @@ ${THEME_TOKENS_CSS}
   // ---- memory stats: the docked panel, same convention as chat.html --------
   async function renderStatsPanel(stats) {
     if (!stats) {
-      if (!session || !window.tmctIngest.memoryStats) return;
-      try { stats = await window.tmctIngest.memoryStats(session.memoryDir); }
+      if (!session || !window.tmct.page.memoryStats) return;
+      try { stats = await window.tmct.page.memoryStats(session.memoryDir); }
       catch { return; }
     }
     factPillValueEl.textContent = Number(stats.total || 0).toLocaleString();
@@ -440,30 +414,14 @@ ${THEME_TOKENS_CSS}
       console.warn("tmct ingest: chat-seed.json unavailable — starting unseeded", err);
     }
   }
-  function cloneSeed() {
-    if (!seedPayload) return null;
-    try { return structuredClone(seedPayload); } catch { return JSON.parse(JSON.stringify(seedPayload)); }
-  }
-  function newSession() {
-    return window.tmctIngest.createIngestSession({ seedPayload: cloneSeed(), vocabSeeded: Boolean(seedPayload) });
+  const cloneMemoryPayload = ${cloneMemoryPayload.toString()};
+  async function newSession() {
+    return window.tmct.open({ seedPayload: cloneMemoryPayload(seedPayload), vocabSeeded: Boolean(seedPayload) });
   }
 
   // ---- engine boot ---------------------------------------------------------
-  const WINK_LOAD_TIMEOUT_MS = 8000;
-  async function tryLoadWink() {
-    let settled = false;
-    const timeout = new Promise((_, reject) => setTimeout(() => { if (!settled) reject(new Error("wink load stalled")); }, WINK_LOAD_TIMEOUT_MS));
-    try {
-      const mod = await Promise.race([import("./vendor/wink.js"), timeout]);
-      settled = true;
-      window.tmctIngest.registerWinkModel(() => ({ winkNLP: mod.winkNLP, model: mod.model }));
-      return "loaded";
-    } catch (err) {
-      settled = true;
-      console.warn("tmct ingest: the wink vendor asset failed to load; the recognizer needs it to split and parse sentences", err);
-      return "unavailable";
-    }
-  }
+  const loadWinkVendor = ${loadWinkVendor.toString()};
+  const tryLoadWink = loadWinkVendor({ register: (factory) => window.tmct.page.registerWinkModel(factory) });
 
   // The deploy's own version, read off the service worker file the build
   // already stamps — the only same-origin place the number exists at runtime
@@ -509,10 +467,10 @@ ${THEME_TOKENS_CSS}
     clearTimeout(saveTimer);
     saveTimer = null;
     if (persist) await persist.clear();
-    session = newSession();
+    session = await newSession();
     clearFactsPane();
     updateIngestEnabled();
-    const stats = await window.tmctIngest.memoryStats(session.memoryDir);
+    const stats = await window.tmct.page.memoryStats(session.memoryDir);
     statusEl.textContent = "forgot everything taught on this device. Back to the fresh seed (" + statsSummaryLine(stats, bandLabelFor) + ").";
     await renderStatsPanel(stats);
   }
@@ -528,9 +486,9 @@ ${THEME_TOKENS_CSS}
     await fetchSeedIfWanted();
     clearTimeout(saveTimer);
     saveTimer = null;
-    session = newSession();
+    session = await newSession();
     clearFactsPane();
-    const stats = await window.tmctIngest.memoryStats(session.memoryDir);
+    const stats = await window.tmct.page.memoryStats(session.memoryDir);
     statusEl.textContent = statsSummaryLine(stats, bandLabelFor) + ". Ready.";
     await renderStatsPanel(stats);
     updateIngestEnabled();
@@ -538,7 +496,7 @@ ${THEME_TOKENS_CSS}
   });
 
   async function boot() {
-    if (!window.tmctIngest) {
+    if (!window.tmct) {
       statusEl.textContent = "the ingest engine didn't load. This page needs its build step (npm run demo:build)";
       return;
     }
@@ -549,16 +507,16 @@ ${THEME_TOKENS_CSS}
       fetchSiteVersion().then((v) => { siteVersion = v; }),
     ]);
     progressActive = false;
-    if (window.tmctIngest.openPersistedStore) {
-      persist = window.tmctIngest.openPersistedStore({ storeKey: "ingest", stamp: siteVersion + ":" + seedFacts + ":" + SEED_STAMP });
+    if (window.tmct.page.openPersistedStore) {
+      persist = window.tmct.page.openPersistedStore({ storeKey: "ingest", stamp: siteVersion + ":" + seedFacts + ":" + SEED_STAMP });
     }
     const savedRecord = persist ? await persist.load() : null;
     session = savedRecord && savedRecord.payload
-      ? window.tmctIngest.createIngestSession({ seedPayload: savedRecord.payload, vocabSeeded: true })
-      : newSession();
+      ? await window.tmct.open({ seedPayload: savedRecord.payload, vocabSeeded: true })
+      : await newSession();
     setMode(false);
     updateIngestEnabled();
-    const stats = await window.tmctIngest.memoryStats(session.memoryDir);
+    const stats = await window.tmct.page.memoryStats(session.memoryDir);
     const winkPart = winkStatus === "loaded"
       ? "wink-nlp: loaded"
       : "wink-nlp unavailable. The recognizer can't split sentences without it";
@@ -611,10 +569,10 @@ ${THEME_TOKENS_CSS}
 
   // ---- download the canonical facts as JSONL -------------------------------
   downloadBtn.addEventListener("click", async () => {
-    if (!session || !window.tmctIngest.exportFactsJsonl) return;
+    if (!session || !window.tmct.page.exportFactsJsonl) return;
     let jsonl;
     try {
-      jsonl = await window.tmctIngest.exportFactsJsonl(session.memoryDir);
+      jsonl = await window.tmct.page.exportFactsJsonl(session.memoryDir);
     } catch (err) {
       statusEl.textContent = "couldn't build the download (" + (err && err.message ? err.message : err) + ")";
       return;