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

package/src/services/spider-fly-viz.mjs

@@ -83,7 +83,7 @@ function webCellIds() {
  * `geometry` is `{ parseCellId, cellId, directionDelta }` — the exact three
  * grid-geometry primitives spider-fly-world.mjs exports, injected rather
  * than imported so this function stays `.toString()`-splice safe (the
- * inlined page calls it with `window.tmctSpiderFly`'s own re-exports of the
+ * inlined page calls it with `window.tmct`'s own re-exports of the
  * same three). Returns the ordered cell-id array (length > 1) or null.
  */
 export function threadCellsForSpiderPlan(agents, geometry) {
@@ -558,7 +558,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   // lanes read exactly as much better with wink loaded as they do on every
   // other page. Fired eagerly here so it is likely settled well before a
   // visitor's first ordinary (non-game) question.
-  loadWinkVendor({ register: (factory) => tmctSpiderFly.registerWinkModel(factory) })();
+  loadWinkVendor({ register: (factory) => tmct.page.registerWinkModel(factory) })();
   const el = (id) => document.getElementById(id);
   const boardFrame = el("boardFrame");
   const boardCanvas = el("board");
@@ -661,12 +661,12 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   // takes, answered by the same pure resolver the tool wraps (sprite-request.mjs,
   // spliced in above) — the page holds the state and nothing else.
   function resolveSpriteFace(spriteRequest) {
-    if (!window.tmctSpiderFly) return "";
+    if (!window.tmct) return "";
     return resolveSpriteRequest(spriteRequest, {
       factRows: (session && session.taxonomyRows) || [],
       templates: SPIDERFLY.spriteTemplates,
-      spriteRegistry: tmctSpiderFly.SPRITE_REGISTRY,
-      resolveSpriteAsset: tmctSpiderFly.resolveSpriteAsset,
+      spriteRegistry: tmct.page.SPRITE_REGISTRY,
+      resolveSpriteAsset: tmct.page.resolveSpriteAsset,
     }).svg || "";
   }
 
@@ -718,7 +718,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
     for (const [id, a] of Object.entries(agents)) {
       const cls = agentKindOf(id);
       const node = ensureSpriteEl(id, cls, a);
-      const parsed = tmctSpiderFly.parseCellId(a.cell);
+      const parsed = tmct.page.parseCellId(a.cell);
       if (!parsed) continue;
       const pct = cellCenterPct(parsed.x, parsed.y);
       node.style.left = pct.leftPct + "%";
@@ -778,7 +778,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
         spriteLayer.appendChild(node);
         corpseEls[id] = node;
       }
-      const deathCell = tmctSpiderFly.parseCellId(corpse.cell);
+      const deathCell = tmct.page.parseCellId(corpse.cell);
       if (!deathCell) continue;
       const pct = cellCenterPct(deathCell.x, SPIDERFLY.gridSize);
       node.style.left = pct.leftPct + "%";
@@ -863,9 +863,9 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   });
 
   const threadGeometry = {
-    parseCellId: (id) => tmctSpiderFly.parseCellId(id),
-    cellId: (x, y) => tmctSpiderFly.cellId(x, y),
-    directionDelta: tmctSpiderFly.DIRECTION_DELTA,
+    parseCellId: (id) => tmct.page.parseCellId(id),
+    cellId: (x, y) => tmct.page.cellId(x, y),
+    directionDelta: tmct.page.DIRECTION_DELTA,
   };
 
   function drawBoard(agents, activeWebs) {
@@ -873,7 +873,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
     boardCtx.clearRect(0, 0, w, h);
     boardCtx.fillStyle = cssVar("--taught-soft") || "rgba(46,125,79,.12)";
     for (const wc of SPIDERFLY.webCells) {
-      const p = tmctSpiderFly.parseCellId(wc);
+      const p = tmct.page.parseCellId(wc);
       boardCtx.fillRect((p.x - 1) * cellSize, (p.y - 1) * cellSize, cellSize, cellSize);
     }
     // A spider-built dynamic web is a distinct color from the always-on
@@ -884,7 +884,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
     boardCtx.lineWidth = 1;
     boardCtx.setLineDash([3, 2]);
     for (const web of activeWebs || []) {
-      const p = tmctSpiderFly.parseCellId(web.cell);
+      const p = tmct.page.parseCellId(web.cell);
       if (!p) continue;
       boardCtx.fillRect((p.x - 1) * cellSize, (p.y - 1) * cellSize, cellSize, cellSize);
       boardCtx.strokeRect((p.x - 1) * cellSize + 0.5, (p.y - 1) * cellSize + 0.5, cellSize - 1, cellSize - 1);
@@ -904,7 +904,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
       boardCtx.beginPath();
       let prev = null;
       thread.forEach((c, i) => {
-        const p = tmctSpiderFly.parseCellId(c);
+        const p = tmct.page.parseCellId(c);
         const px = (p.x - 0.5) * cellSize, py = (p.y - 0.5) * cellSize;
         if (i === 0) boardCtx.moveTo(px, py); else boardCtx.lineTo(px, py);
         if (prev) threadHits.push({ x: (prev.x + px) / 2, y: (prev.y + py) / 2, step: i });
@@ -919,19 +919,19 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
     if (!povAgentId) return;
     const agent = lastAgents[povAgentId];
     if (!agent) { povAgentId = null; return; }
-    const p = tmctSpiderFly.parseCellId(agent.cell);
+    const p = tmct.page.parseCellId(agent.cell);
     // The live, slider-adjustable per-class radius (falling back to the
     // engine's own shipped default before the session has finished
     // booting) — a POV toggle always reflects whatever vision range this
     // class currently actually has, not a fixed constant.
     const radius = agentKindOf(povAgentId) === "spider"
-      ? (liveConfig.spiderVisionRadius ?? tmctSpiderFly.DEFAULT_VISION_RADIUS)
-      : (liveConfig.flyVisionRadius ?? tmctSpiderFly.DEFAULT_VISION_RADIUS);
-    const visible = new Set(tmctSpiderFly.visibleCells(p.x, p.y, radius));
+      ? (liveConfig.spiderVisionRadius ?? tmct.page.DEFAULT_VISION_RADIUS)
+      : (liveConfig.flyVisionRadius ?? tmct.page.DEFAULT_VISION_RADIUS);
+    const visible = new Set(tmct.page.visibleCells(p.x, p.y, radius));
     povCtx.fillStyle = "rgba(0,0,0,.55)";
     for (let gy = 1; gy <= SPIDERFLY.gridSize; gy += 1) {
       for (let gx = 1; gx <= SPIDERFLY.gridSize; gx += 1) {
-        if (visible.has(tmctSpiderFly.cellId(gx, gy))) continue;
+        if (visible.has(tmct.page.cellId(gx, gy))) continue;
         povCtx.fillRect((gx - 1) * cellSize, (gy - 1) * cellSize, cellSize, cellSize);
       }
     }
@@ -983,7 +983,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
     chatqEl.value = "";
     addChatLine("u", esc(q));
     withLock(async () => {
-      const result = await session.turn(q);
+      const result = await tmct.turn(q);
       addChatLine("a", esc(result.answer).replace(/\\n/g, "<br>"));
       const snap = await session.snapshot();
       redraw(snap.agents, snap.turn, snap.activeWebs);
@@ -1027,14 +1027,14 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   refreshPills();
 
   // ---- deception pills (§A.2.4): a SEPARATE dynamic rail, alongside (never
-  // replacing) the static one above. tmctSpiderFly.pillsForSpiderFly is the
+  // replacing) the static one above. tmct.page.pillsForSpiderFly is the
   // exact same pure function spider-fly-turn.mjs exports — this page never
   // reimplements the true/false claim logic, only renders its output and
   // fills #chatq on click, same click-to-fill discipline as every other
   // pill on this page (never auto-submits).
   function renderDynamicPills() {
     if (!session || !Object.keys(lastAgents).length) { dynamicPillsEl.innerHTML = ""; return; }
-    const result = tmctSpiderFly.pillsForSpiderFly(lastAgents, selectedAddresseeId, {});
+    const result = tmct.page.pillsForSpiderFly(lastAgents, selectedAddresseeId, {});
     selectedAddresseeId = result.addresseeId;
     const addrHtml = result.addressPills.map((p) =>
       '<button type="button" class="pill" data-role="dyn-addr" data-id="' + esc(p.id) + '"'
@@ -1099,7 +1099,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
 
   let tuningInitialized = false;
   async function boot() {
-    session = await tmctSpiderFly.createSpiderFlySession();
+    session = await tmct.open();
     // A reset mints a brand-new session (fresh board, fresh config) — the
     // FIRST boot seeds the sliders from the engine's own shipped defaults;
     // every boot after that re-applies whatever the visitor already had the

package/src/services/sprite-catalog-viz.mjs

@@ -631,7 +631,7 @@ const SPRITE_CHAT = ${embedJson({ rows: dockRows })};
           import("./vendor/wink.js"),
           winkTimeout(WINK_LOAD_TIMEOUT_MS, "wink vendor asset load timed out"),
         ]);
-        tmctSprites.registerWinkModel(() => ({ winkNLP: mod.winkNLP, model: mod.model }));
+        tmct.page.registerWinkModel(() => ({ winkNLP: mod.winkNLP, model: mod.model }));
       } catch (err) {
         console.warn("tmct sprites: the wink vendor asset failed to load, continuing without the lemma/POS tier", err);
       }
@@ -661,7 +661,7 @@ const SPRITE_CHAT = ${embedJson({ rows: dockRows })};
     addDockLine("u", q);
     if (!session) { addDockLine("a miss", "the engine is still loading. Try again in a moment."); return; }
     withLock(async () => {
-      const result = await session.turn(q);
+      const result = await tmct.turn(q);
       const missed = !!(result.record && result.record.miss);
       addDockLine(missed ? "a miss" : "a grounded", result.answer);
     });
@@ -677,7 +677,7 @@ const SPRITE_CHAT = ${embedJson({ rows: dockRows })};
   (async () => {
     try {
       await tryLoadWink();
-      session = await tmctSprites.createSpriteCatalogSession({ factRows: SPRITE_CHAT.rows });
+      session = await tmct.open({ factRows: SPRITE_CHAT.rows });
       dockqEl.disabled = false;
       dockStatusEl.textContent = SPRITE_CHAT.rows.length + " sprite facts on record. Ask away, or use a quick question.";
     } catch (err) {
@@ -865,7 +865,7 @@ ${spriteBundleScript}
   function wireSceneComposer() {
     const composeqEl = document.getElementById("composeq");
     if (!composeqEl) return;
-    const extractSceneItems = tmctSprites.extractSceneItems;
+    const extractSceneItems = tmct.page.extractSceneItems;
     const composeFormEl = document.getElementById("composeForm");
     const composePillsEl = document.getElementById("composePills");
     const sceneRowEl = document.getElementById("sceneRow");

package/src/surfaces/web/adventure-browser-entry.mjs

@@ -35,6 +35,8 @@
 // game-shaped falls through to the ordinary conversational layer, exactly
 // like a real CLI session.
 import { createTurnSession } from "./turn-session.mjs";
+import { publishTmctSurface } from "./tmct-surface.mjs";
+import { graphAsk, enginePlan } from "./engine-surface.mjs";
 import {
   createInMemoryStore, appendFacts, appendRule, loadMemory, readFactRows, removeFacts,
 } from "../../adapters/memory/core.mjs";
@@ -127,6 +129,7 @@ export async function createAdventureSession(worldPayload, { restoredPayload = n
 
   return {
     memoryDir,
+    graph,
 
     /** One auto-play tick: infer the goal, execute exactly one move through
      *  adventureTurn (adventure-autoplay.mjs's own contract), thread the
@@ -192,25 +195,21 @@ export async function createAdventureSession(worldPayload, { restoredPayload = n
   };
 }
 
-// Re-exported so the page's own rendering script (adventure-viz.mjs) never
-// has to duplicate sprite resolution, the digest reader, the room
-// affordances the chat dock's own pills read from, or (foldWorldState,
-// exposedFacts) the exposure-filtered fold the goal-status panel mirrors —
-// the same posture spider-fly-browser-entry.mjs's own
-// globalThis.tmctSpiderFly re-export takes. `relatedForTerm`/
-// `classAncestorChain` back the edit mode's own cursor-suggestion pills
-// (adventure-viz.mjs's suggestionsForTerm mirrors this same pairing against
-// the global, the same reach-through-the-global pattern captionFor/pillsFor
-// already use for their own adventure.mjs calls). `directedGridLayout`/
-// `roomGraphSvg` (viz-room-graph.mjs's shared BFS-grid room-map layout and
-// SVG renderer) back the manor-map panel, its lightbox and its edit-mode
-// whole-map twin the same way — neither is `.toString()`-splice-safe
-// (roomGraphSvg needs escapeHtml, directedGridLayout needs its own
-// module-level exit-delta table), so the page reaches them here instead of
-// re-implementing the layout a second time.
-globalThis.tmctAdventure = {
-  createAdventureSession, resolveSpriteForClass, SPRITE_REGISTRY, resolveSpriteAsset,
-  worldDigestRows, roomAffordances, foldWorldState, exposedFacts,
-  relatedForTerm, classAncestorChain, openPersistedStore,
-  directedGridLayout, roomGraphSvg,
-};
+// `tmct.page` keeps what the page draws with and the engine has no
+// plain-English form for: sprite resolution, the digest reader, the room
+// affordances the chat pills read from, the exposure-filtered fold the
+// goal-status panel mirrors, the SKOS neighbourhood and is-a chain behind the
+// edit mode's cursor pills, the persisted-store wrapper, and the manor map's
+// own BFS-grid layout and SVG renderer (neither is `.toString()`-splice-safe:
+// roomGraphSvg needs escapeHtml, directedGridLayout its own exit-delta table).
+publishTmctSurface({
+  open: createAdventureSession,
+  ask: graphAsk,
+  plan: enginePlan,
+  page: {
+    resolveSpriteForClass, SPRITE_REGISTRY, resolveSpriteAsset,
+    worldDigestRows, roomAffordances, foldWorldState, exposedFacts,
+    relatedForTerm, classAncestorChain, openPersistedStore,
+    directedGridLayout, roomGraphSvg,
+  },
+});

package/src/surfaces/web/chat-browser-entry.mjs

@@ -51,6 +51,8 @@ import { registerLiveReferenceProvider, registerResearchProvider } from "../../a
 // decides when to save/load/clear; this entry only carries the wrapper
 // across the bundle boundary.
 import { openPersistedStore } from "./idb-persist.mjs";
+import { publishTmctSurface } from "./tmct-surface.mjs";
+import { graphAsk, enginePlan } from "./engine-surface.mjs";
 
 /**
  * A browser chat session over the real turn engine.
@@ -70,7 +72,7 @@ import { openPersistedStore } from "./idb-persist.mjs";
  * is module-scope, last write wins, and every session created after this one
  * shares it.
  *
- * Returns { memoryDir, sessionId, turn }. `turn(line)` resolves to
+ * Returns { memoryDir, sessionId, graph, turn }. `turn(line)` resolves to
  * { answer, end, record, plan } and threads focus/last/planState between
  * calls exactly as the CLI session does.
  */
@@ -112,6 +114,7 @@ export function createChatSession({ seedPayload = null, vocabSeeded = false, liv
   return {
     memoryDir,
     sessionId,
+    graph,
     get liveReference() { return liveReferenceOn; },
     /** The page's toggle seam: set the live Wikipedia mode for every later turn
      *  (the `/wiki on|off|supplement|always` command sets the same state). */
@@ -144,4 +147,20 @@ export async function researchedFactRows(memoryDir) {
     .map((row) => ({ subject: row.subject, predicate: row.predicate, object: row.object }));
 }
 
-globalThis.tmctChat = { createChatSession, registerWinkModel, registerReferencePackProvider, registerLiveReferenceProvider, registerResearchProvider, normFactTerm, vocabExampleHint, memoryStats, openPersistedStore, exportFactsJsonl, researchedFactRows, splitSentences: splitSentencesPreservingPaths };
+// The page reaches the engine through the one shared surface: `tmct.open()`
+// opens this session, `tmct.turn()` runs the dock, `tmct.ask()` puts a
+// question to the session's own graph. What stays on `tmct.page` is what has
+// no plain-English form — the vendor/provider seams the page registers before
+// the first turn, its IndexedDB wrapper, and the two serializers its export
+// and paste-ingest controls run.
+publishTmctSurface({
+  open: createChatSession,
+  ask: graphAsk,
+  plan: enginePlan,
+  page: {
+    registerWinkModel, registerReferencePackProvider, registerLiveReferenceProvider,
+    registerResearchProvider, normFactTerm, vocabExampleHint, memoryStats,
+    openPersistedStore, exportFactsJsonl, researchedFactRows,
+    splitSentences: splitSentencesPreservingPaths,
+  },
+});

package/src/surfaces/web/code-explorer-browser-entry.mjs

@@ -22,6 +22,8 @@ import * as source from "../../adapters/source.mjs";
 import { computeCodeExplorerData, computeCodeLedger, edgePhrase } from "../../services/code-explorer-viz.mjs";
 import { generateCodeHints } from "../../domain/code-explorer-hints.mjs";
 import { createTurnSession } from "./turn-session.mjs";
+import { publishTmctSurface } from "./tmct-surface.mjs";
+import { graphAsk, enginePlan } from "./engine-surface.mjs";
 import { tmct_ask } from "../../tools/handlers/tmct-ask.mjs";
 import { RELATIONS } from "../../domain/ask-vocab.mjs";
 
@@ -37,7 +39,7 @@ import { RELATIONS } from "../../domain/ask-vocab.mjs";
  * payload carries the starter vocabulary. Teaches land in the same in-memory
  * store, so a taught fact never touches disk.
  *
- * Returns { memoryDir, sessionId, turn }, the createChatSession shape the
+ * Returns { memoryDir, sessionId, graph, turn }, the createChatSession shape the
  * page's chat expects.
  */
 export function createCodeExplorerSession({ graphPayload, seedPayload = null, vocabSeeded = false } = {}) {
@@ -69,6 +71,7 @@ export function createCodeExplorerSession({ graphPayload, seedPayload = null, vo
   return {
     memoryDir,
     sessionId,
+    graph,
     turn: turnSession.turn,
   };
 }
@@ -223,17 +226,27 @@ export function askRelatedFacts(graphPayload, term) {
   return { term, rows, asked, grounded };
 }
 
-// Exposed for the page's inline client: the re-derivation helpers so a graph
-// swapped through the desktop picker re-renders without duplicating logic, the
-// engine's own answer to "what relates to the focus", plus the wink loader hook
-// registerWinkModel and normFactTerm the chat shares with the ledger page.
-globalThis.tmctCodeExplorer = {
-  createCodeExplorerSession,
-  askRelatedFacts,
-  computeCodeExplorerData,
-  computeCodeLedger,
-  generateCodeHints,
-  parseEntities,
-  normFactTerm,
-  registerWinkModel,
-};
+// This page holds a REAL code graph, so `tmct.ask` is the engine answering
+// over it — the same round trip askRelatedFacts already makes twice per
+// relation kind to build the sidebar's rows.
+//
+// `tmct.page` keeps the re-derivation helpers a graph swapped through the
+// desktop picker re-renders with, plus the wink and term-normalizing seams the
+// chat shares with the ledger page. `createCodeExplorerSession` sits there
+// too: this page's client script is still one raw-text block, and it reaches
+// its factory through the bag rather than through `tmct.open()`.
+publishTmctSurface({
+  open: createCodeExplorerSession,
+  ask: graphAsk,
+  plan: enginePlan,
+  page: {
+    createCodeExplorerSession,
+    askRelatedFacts,
+    computeCodeExplorerData,
+    computeCodeLedger,
+    generateCodeHints,
+    parseEntities,
+    normFactTerm,
+    registerWinkModel,
+  },
+});

package/src/surfaces/web/engine-surface.mjs

@@ -0,0 +1,82 @@
+// engine-surface.mjs — the standard `ask` and `plan` routes a browser page
+// wires into publishTmctSurface (tmct-surface.mjs).
+//
+// Both run the SAME machinery the CLI runs, over the session's own in-memory
+// state rather than a repo on disk: `graphAsk` dispatches `tmct_ask` through
+// the tool layer and hands back the structured envelope beside the prose
+// (dispatchToolStructured's `{ content, data }`); `enginePlan` builds the
+// capability planner's context from whatever the session holds and runs one
+// request through it.
+//
+// Kept out of tmct-surface.mjs on purpose. That module is pure wiring and
+// imports nothing, so memory-ask-browser-entry.mjs — the one bundle that is
+// committed and published, and is deliberately small — can publish the same
+// `globalThis.tmct` without pulling the tool layer and the router into its
+// bundle.
+import { dispatchToolStructured } from "../../tools/server.mjs";
+import { capabilityPlanDeps, noCodeGraph } from "../../services/chat.mjs";
+
+/**
+ * One plain-English question, answered against the graph this session holds,
+ * through the same `tmct_ask` tool the CLI dispatches. Returns
+ * `{ answer, data, miss }` — `data` is ask()'s own envelope (the parse, the
+ * matches it found, the traversal it walked), which is what a panel renders
+ * rows from and what makes an answer auditable.
+ *
+ * A session whose graph is empty answers with an honest miss. That is the real
+ * state of a memory-only page: its rows are facts in a store, and ask() reads
+ * a graph. spider-fly is the page that closed that gap for its own world, by
+ * projecting its live board into a graph (worldRelationGraphPayload) before
+ * every turn — the same route is open to any page whose rows have a shape
+ * worth asking over.
+ */
+export async function graphAsk(request, options, session) {
+  const { content, data } = await dispatchToolStructured("tmct_ask", { query: request }, {
+    graph: session.graph,
+    memoryBackend: session.memoryDir,
+  });
+  return { answer: content, data, miss: Boolean(data?.miss) };
+}
+
+/**
+ * One compound or maintenance-goal request, planned and executed over whatever
+ * this session holds — the same capability router `/plan` reaches, with the
+ * same memory-only mode a page with no code graph needs (a code-graph
+ * capability there refuses by naming the graph it hasn't got).
+ *
+ * Returns the planner's own result: `{ refused, why, driver, calls, composed,
+ * observed }`. No prose is composed here — a page that wants the written
+ * answer asks for it in words through `tmct.turn("/plan …")`, which is the
+ * same split `dispatchTool` and `dispatchToolStructured` already draw.
+ */
+export async function enginePlan(request, options, session) {
+  const graph = session.graph && !noCodeGraph(session.graph) ? session.graph : null;
+  const memoryDir = session.memoryDir ?? null;
+  if (!graph && !memoryDir) {
+    return {
+      refused: true,
+      why: "nothing to plan over — this session holds neither a code graph nor a memory store",
+      driver: null, calls: [], composed: null, observed: null,
+    };
+  }
+  const { buildCapabilityPlanCtx, runCapabilityPlan, declaredCapabilityNames } =
+    await import("../../domain/router/drive.mjs");
+  const ctx = await buildCapabilityPlanCtx({
+    ...capabilityPlanDeps(), config: null, source: null, graph, memoryDir,
+  });
+  try {
+    const result = await runCapabilityPlan(request, declaredCapabilityNames(), ctx);
+    return {
+      refused: Boolean(result.refused),
+      why: Array.isArray(result.why) ? result.why.join("; ") : (result.why ?? null),
+      driver: result.driver ?? null,
+      calls: result.calls ?? [],
+      composed: result.composed ?? null,
+      observed: result.observed ?? null,
+    };
+  } finally {
+    // The taught registrations are per-ctx: dispose them so the next call
+    // re-reads the store instead of meeting a stale name collision.
+    for (const dispose of ctx.disposers || []) dispose();
+  }
+}

package/src/surfaces/web/ingest-browser-entry.mjs

@@ -32,6 +32,7 @@ import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
 import { registerWinkModel, winkInstance } from "../../adapters/wink-model.mjs";
 import { memoryStats, exportFactsJsonl } from "./memory-stats.mjs";
 import { openPersistedStore } from "./idb-persist.mjs";
+import { publishTmctSurface } from "./tmct-surface.mjs";
 
 // The pronoun subjects a bounded carry substitutes with the last unique
 // grounded subject in the SAME paragraph. Reset at every blank line, so a
@@ -192,7 +193,15 @@ export function createIngestSession({ seedPayload = null, vocabSeeded = false }
   };
 }
 
-globalThis.tmctIngest = {
-  createIngestSession, groundTextToFacts, exportFactsJsonl, registerWinkModel, normFactTerm,
-  memoryStats, openPersistedStore,
-};
+// This page grounds pasted prose into facts; it holds no conversation, so
+// `tmct.turn` is unwired and says so, and the one call the page makes is
+// `tmct.session.ingest(text)`. `tmct.page` keeps the recognizer entry point
+// the page also drives directly, the wink seam, the stats fold behind its
+// counters, its IndexedDB wrapper and its JSONL export.
+publishTmctSurface({
+  open: createIngestSession,
+  page: {
+    groundTextToFacts, exportFactsJsonl, registerWinkModel, normFactTerm,
+    memoryStats, openPersistedStore,
+  },
+});

package/src/surfaces/web/ledger-browser-entry.mjs

@@ -27,6 +27,8 @@ import { computeLedgerDataFromPayload } from "../../services/ledger-viz.mjs";
 import { digestTermFromPayloadBrowser } from "./digest-client.mjs";
 import { createTurnSession } from "./turn-session.mjs";
 import { exportFactsJsonl } from "./memory-stats.mjs";
+import { publishTmctSurface } from "./tmct-surface.mjs";
+import { graphAsk, enginePlan } from "./engine-surface.mjs";
 
 /**
  * A browser ledger-dock session over the real turn engine — createChatSession's
@@ -35,7 +37,7 @@ import { exportFactsJsonl } from "./memory-stats.mjs";
  * a fact taught through the dock extends the SAME graph the page renders
  * from, never a disconnected one.
  *
- * Returns { memoryDir, sessionId, turn }, identical to createChatSession.
+ * Returns { memoryDir, sessionId, graph, turn }, identical to createChatSession.
  * ledger-viz.mjs's own inline script calls computeLedgerDataFromPayload
  * (re-exported below) on `memoryDir.payload` after a turn whose record shows
  * a successful write (`via: "assert"` or `via: "retract"`, `miss: false`) to
@@ -52,14 +54,20 @@ export function createLedgerSession({ seedPayload = null, vocabSeeded = false }
   const sessionId = globalThis.crypto?.randomUUID?.() ?? String(Date.now());
 
   const session = createTurnSession({ memoryDir, graph, lexicon, sessionId, vocabHint });
-  return { memoryDir, sessionId, turn: session.turn };
+  return { memoryDir, sessionId, graph, turn: session.turn };
 }
 
-// Re-exported so ledger-viz.mjs's own inline script never has to duplicate
-// the derivation logic that builds rows/terms/edges/contradictions/
-// worthALook/stats from a payload — the same posture chat-browser-entry.mjs
-// takes re-exporting registerWinkModel for its own page's CDN wink load.
-// splitSentences + exportFactsJsonl carry the dock's paste-and-drop ingest and
-// its JSONL export across the bundle boundary, the same one-serializer posture
-// chat-browser-entry.mjs holds for its own page.
-globalThis.tmctLedger = { createLedgerSession, computeLedgerDataFromPayload, normFactTerm, registerWinkModel, registerResearchProvider, splitSentences: splitSentencesPreservingPaths, exportFactsJsonl, digestTermFromPayloadBrowser };
+// `tmct.page` keeps what the page's own script renders with and the engine has
+// no plain-English form for: the payload-to-rows/terms/edges/stats derivation
+// the ledger view re-mounts from after a successful teach, the digest reader,
+// the wink and research seams, and the two serializers behind the dock's
+// paste-ingest and JSONL export.
+publishTmctSurface({
+  open: createLedgerSession,
+  ask: graphAsk,
+  plan: enginePlan,
+  page: {
+    computeLedgerDataFromPayload, normFactTerm, registerWinkModel, registerResearchProvider,
+    splitSentences: splitSentencesPreservingPaths, exportFactsJsonl, digestTermFromPayloadBrowser,
+  },
+});

package/src/surfaces/web/memory-ask-browser-entry.mjs

@@ -1,20 +1,62 @@
 // memory-ask-browser-entry.mjs — the esbuild entry for the ledger page's
 // chat dock (`tmct viz`, src/services/ledger-viz.mjs).
 //
-// Re-exports `factAnswer` (src/services/chat.mjs) and `createInMemoryStore`
-// (src/adapters/memory/core.mjs), which lets the dock hand `factAnswer` the page's
-// already-embedded payload with zero fs I/O. Called with `envelope: null,
-// miss: true` to arm factAnswer's bare-question regex fallbacks directly,
-// bypassing the structural-graph parse pipeline this dock has no use for.
+// The one COMMITTED browser bundle: `tmct viz` is a real CLI command run
+// against a user's own local .tmct store, so this ships with the package. It
+// deliberately carries the question lanes only (factAnswer/factReadBack) and
+// not the full turn engine — see ledger-browser-entry.mjs's header for the
+// contrast with the demo site's own 1.5MB dock.
+//
+// It publishes the SAME `globalThis.tmct` every other page does, through
+// tmct-surface.mjs, which imports nothing — so this bundle gets the shared
+// contract without the tool layer or the capability router coming with it.
+// `tmct.turn` and `tmct.plan` are unwired here and say so: this dock asks
+// questions, it does not hold a conversation or plan anything.
 import { factAnswer, factReadBack } from "../../services/chat.mjs";
 import { createInMemoryStore, normFactTerm } from "../../adapters/memory/core.mjs";
 import { digestTermFromPayloadBrowser } from "./digest-client.mjs";
+import { publishTmctSurface } from "./tmct-surface.mjs";
+
+/** A question-only session over a payload the page already embeds — no fs I/O,
+ *  no turn engine. Returns `{ memoryDir }`. */
+export function createMemoryAskSession({ payload = null } = {}) {
+  const memoryDir = createInMemoryStore();
+  if (payload) memoryDir.payload = payload;
+  return { memoryDir };
+}
+
+/**
+ * One question, answered from the page's own embedded store. Runs the same
+ * cascade `runAsk` runs — factAnswer first, then factReadBack, which is where
+ * the taught-relation chases live ("who is the grandfather of ishmael") that
+ * factAnswer's own lanes don't reach.
+ *
+ * Both are called with `envelope: null, miss: true`, which arms factAnswer's
+ * bare-question fallbacks directly and skips the structural-graph parse
+ * pipeline this dock has no use for.
+ *
+ * Returns `{ answer, data, miss }`. `data` is the reader's own result, so a
+ * caller still sees the inferred `goal` line it computed on the way.
+ */
+export async function askMemory(request, options, session) {
+  let fact = null;
+  try { fact = await factAnswer(session.memoryDir, request, null, true, {}); } catch { fact = null; }
+  if (!(fact && fact.text)) {
+    try { fact = await factReadBack(session.memoryDir, request, null, true, null); } catch { fact = null; }
+  }
+  if (!(fact && fact.text)) return { answer: null, data: null, miss: true };
+  return { answer: fact.text, data: fact, miss: false };
+}
 
-// normFactTerm is re-exported too, for the page's client-side term normalization.
-// factReadBack carries the taught-relation chases (grandfather-style questions)
-// that factAnswer's own lanes don't reach.
-// digestTermFromPayloadBrowser lets the CLI `tmct viz` page read a refocused
-// term back as a digest client-side, from the structure table the page embeds —
-// the same narrative the demo ledger's live bundle produces, over the same
-// static store this page already carries.
-globalThis.tmctMemoryAsk = { factAnswer, factReadBack, createInMemoryStore, normFactTerm, digestTermFromPayloadBrowser };
+// `tmct.page` keeps the term normalizer the dock refocuses the ledger with,
+// and the client-side digest reader — the narrative the demo ledger's live
+// bundle produces, over the static structure table this page embeds.
+// `fallback`, because the demo ledger page carries this bundle AND the full
+// turn engine at once: this one answers where it is alone, and steps aside
+// wherever the live dock is loaded, whichever order the two arrive in.
+publishTmctSurface({
+  open: createMemoryAskSession,
+  ask: askMemory,
+  page: { normFactTerm, digestTermFromPayloadBrowser },
+  fallback: true,
+});