@polycode-projects/the-mechanical-code-talker 2.8.10 → 2.8.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "2.8.10",
+  "version": "2.8.13",
   "private": false,
   "type": "module",
   "description": "The Mechanical Code Talker (tmct) — a tolerant, offline, $0 chat surface that guides you toward precision queries about a software repository. ELIZA/PARRY-style but domain-obsessed with code. No model calls; no codebase index of its own.",
@@ -138,6 +138,7 @@
     "build:chat-bundle": "node scripts/build-chat-bundle.mjs",
     "build:spider-fly-bundle": "node scripts/build-spider-fly-bundle.mjs",
     "build:plan-bundle": "node scripts/build-plan-bundle.mjs",
+    "build:ledger-bundle": "node scripts/build-ledger-bundle.mjs",
     "build:chat-seed": "node scripts/build-chat-seed.mjs",
     "build:demo-graph": "node scripts/build-demo-graph.mjs",
     "build:demo-pack": "node scripts/build-demo-pack.mjs",

package/src/adapters/memory/blocks.mjs

@@ -9,6 +9,7 @@ import { join } from "node:path";
 import { splitIdentifierWords, tokenizeProse } from "../../domain/prose.mjs";
 import { idfWeight } from "../../domain/text-stats.mjs";
 import { SOURCE_PRIOR } from "../../domain/memory/trust.mjs";
+import { isMemoryOrSqliteHandle } from "./core.mjs";
 
 // A block inherits its Source's trust (operator 1.0, corpus 0.7); retrieval
 // weights relevance × trust via a bounded factor (0.5 + trust, ~[0.5, 1.5]).
@@ -50,8 +51,14 @@ async function atomicWrite(file, text) {
 }
 
 /** Load the block index ({ blocks: { id: { file, tokens[], rank } } }); a
- *  missing index is the empty bootstrap. */
+ *  missing index is the empty bootstrap. Session-block folding writes to
+ *  `.tmct/memory/blocks/` on disk (fold.mjs, session end) — a Backend B/C
+ *  handle (createInMemoryStore/createSqliteMemoryStore) has no such directory
+ *  to read, so it gets the SAME empty bootstrap a fresh Backend A repo gets,
+ *  never a raw `path.join(dir, …)` TypeError from treating the handle object
+ *  as a path string. */
 export async function loadBlockIndex(dir) {
+  if (isMemoryOrSqliteHandle(dir)) return { blocks: {} };
   try {
     return JSON.parse(await readFile(join(blocksDir(dir), INDEX_NAME), "utf8"));
   } catch (e) {
@@ -142,6 +149,9 @@ function rerank(index) {
  */
 export async function saveBlock(dir, { id, text, sourceType = DEFAULT_BLOCK_SOURCE_TYPE, createdAt = "" }) {
   if (!id) throw new Error("a block needs an id");
+  if (isMemoryOrSqliteHandle(dir)) {
+    throw new Error("saveBlock: dir is a memory/sqlite handle — session-block folding is Backend A only (no on-disk blocks/ directory to write)");
+  }
   const bdir = blocksDir(dir);
   await mkdir(bdir, { recursive: true });
   const file = `${safeName(id)}.txt`;
@@ -161,6 +171,7 @@ export async function saveBlock(dir, { id, text, sourceType = DEFAULT_BLOCK_SOUR
 
 /** Remove a block (id unknown → no-op) and re-rank the survivors. */
 export async function removeBlock(dir, id) {
+  if (isMemoryOrSqliteHandle(dir)) return false; // nothing was ever written; removing is a no-op, not an error
   const index = await loadBlockIndex(dir);
   const entry = index.blocks[id];
   if (!entry) return false;

package/src/adapters/memory/core.mjs

@@ -153,7 +153,13 @@ function isMemoryHandle(dir) {
 function isSqliteHandle(dir) {
   return !!dir && typeof dir === "object" && dir.backend === BACKEND_SQLITE;
 }
-function isMemoryOrSqliteHandle(dir) {
+/** True for a Backend B (in-memory) or Backend C (sqlite) handle — anything
+ *  that is NOT a plain repo-path string. Exported so every OTHER module that
+ *  takes a `dir` and might reach a raw `node:path`/`node:fs` call (blocks.mjs's
+ *  session-block index chief among them) can guard the same way this module
+ *  already does, instead of a bare `join(dir, …)` throwing Node's generic
+ *  "path argument must be of type string" at a caller with no idea why. */
+export function isMemoryOrSqliteHandle(dir) {
   return isMemoryHandle(dir) || isSqliteHandle(dir);
 }
 

package/src/services/chat-page-viz.mjs

@@ -1,25 +1,22 @@
-// chat-page-viz.mjs — "Talk to it"'s full-screen destination
-// (PLAN_GAMES_UPLIFT_V3.md Part C.4 item 1): a self-contained document shaped
-// exactly like spider-fly-viz.mjs/adventure-viz.mjs's own page-builders — one
-// inlined <style> importing viz-theme.mjs's shared tokens, behaviour as an
-// inlined IIFE — reusing the SAME chat engine the home page's embedded
-// #tmct-chat widget runs (chat-browser.bundle.js's globalThis.tmctChat,
-// chat-seed.json, public/reference-pack/), referenced by the same same-origin
-// relative paths chat-ui.mjs already uses. This module does not import or
-// re-render chat-ui.mjs — it is a second, independent consumer of the same
-// engine/bundle, the same relationship spider-fly-viz.mjs's own inlined chat
-// dock already has with createSpiderFlySession (both call the shared
-// session.turn(line), neither reimplements it).
+// chat-page-viz.mjs — chat.html, the full-screen chat page: a self-contained
+// document shaped exactly like spider-fly-viz.mjs/adventure-viz.mjs's own
+// page-builders — one inlined <style> importing viz-theme.mjs's shared
+// tokens, behaviour as an inlined IIFE — running the full chat engine
+// (chat-browser.bundle.js's globalThis.tmctChat, chat-seed.json,
+// public/reference-pack/) by same-origin relative paths. The same
+// relationship spider-fly-viz.mjs's own inlined chat dock has with
+// createSpiderFlySession: both call the shared session.turn(line), neither
+// reimplements it.
 //
-// What's actually new here, versus the embedded widget: full-screen
-// post-ChatGPT-style chrome (centered message column, bottom-fixed composer,
+// This page's own chrome: full-screen post-ChatGPT-style layout (centered
+// message column, bottom-fixed composer,
 // message bubbles) and this page's own signature element — a quiet
 // per-message PROVENANCE CHIP (taught / corpus / entailed) next to every
 // grounded answer, tmct's actual differentiator versus an LLM chatbot. The
 // chip is read straight off the SAME "(source: ...)" citation chat.mjs's own
 // factPhrase/renderFactLine convention already appends to most answers (see
 // e.g. `dog is a kind of animal (source: corpus:conceptnet ...)` — already
-// asserted by e2e/pages-chat.test.mjs against the embedded widget), never a
+// asserted by e2e/pages-chat-fullscreen.test.mjs against this page), never a
 // second provenance computation against memory internals: `provBucketFor`
 // (ledger-viz.mjs) is spliced in unmodified and applied to whatever citation
 // text the answer already carries, so this page's chip and the ledger's own
@@ -34,7 +31,7 @@
 import { THEME_TOKENS_CSS, SERIF_STACK, MONO_STACK, escapeHtml } from "./viz-theme.mjs";
 import { provBucketFor } from "./ledger-viz.mjs";
 
-const DEFAULT_TITLE = "tmct — talk to it";
+const DEFAULT_TITLE = "the-mechanical-code-talker — talk to it";
 
 // Reads left-to-right as the reader meets each tier: what you taught it
 // directly, what its bundled corpus already knew, what it worked out itself.
@@ -107,10 +104,36 @@ export function renderChatHtml({ title = DEFAULT_TITLE } = {}) {
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>${escapeHtml(title)}</title>
+<!--
+  Import map: resolves the "wink-nlp"/"wink-eng-lite-web-model" bare specifiers the
+  sibling chat bundle's own dynamic import() needs (pinned to the exact versions
+  package.json depends on) to esm.sh CDN builds — the same seam plan.html and
+  ledger.html each wire up for their own live sessions, mirrored here because this
+  page can be opened standalone (no import map inherited from a host document). The
+  bundle itself never touches wink-nlp directly — wink-model.mjs's own header
+  explains why a static import would drag the ~1 MB model into every bundle; only
+  the page's own inline script performs this CDN import, the same bounded-race
+  tryLoadWink() pattern public/tmct-browser.mjs uses.
+-->
+<script type="importmap">
+{
+  "imports": {
+    "wink-nlp": "https://esm.sh/wink-nlp@2.4.0",
+    "wink-eng-lite-web-model": "https://esm.sh/wink-eng-lite-web-model@1.8.1"
+  }
+}
+</script>
 <style>
 ${THEME_TOKENS_CSS}
   html, body { height: 100%; }
-  body { margin: 0; background: var(--bg); color: var(--ink); font-family: ${SERIF_STACK}; font-size: 16px; line-height: 1.5; display: flex; flex-direction: column; overflow: hidden; }
+  /* body is the OUTER row: the chat column plus the stats panel docked to its
+     right, each a sibling flex item stretching to the full viewport height
+     (flex row's default cross-axis stretch) — .chatCol carries the column
+     layout the chat chrome itself needs (topbar/main/composer/statusline
+     stacked), so this page keeps working exactly as before, just inside one
+     more layer. */
+  body { margin: 0; background: var(--bg); color: var(--ink); font-family: ${SERIF_STACK}; font-size: 16px; line-height: 1.5; display: flex; overflow: hidden; }
+  .chatCol { flex: 1 1 auto; min-width: 0; display: flex; flex-direction: column; }
   .mono { font-family: ${MONO_STACK}; }
   button { font: inherit; color: inherit; background: none; cursor: pointer; border: none; }
   button:focus-visible, input:focus-visible { outline: 2px solid var(--ink); outline-offset: 2px; }
@@ -126,7 +149,14 @@ ${THEME_TOKENS_CSS}
   .dot-taught { background: var(--taught); } .dot-corpus { background: var(--corpus); } .dot-entail { background: var(--entail); }
 
   main.chatMain { flex: 1 1 auto; overflow-y: auto; overscroll-behavior: contain; }
-  .messages { max-width: 720px; margin: 0 auto; padding: 1.2rem 1rem 1.6rem; display: flex; flex-direction: column; gap: .15rem; min-height: 100%; }
+  /* box-sizing: border-box so min-height: 100% below counts the padding IN,
+     not on top of it — without this, .messages renders ~45px taller than
+     main.chatMain's own visible height (its 1.2rem/1.6rem vertical padding,
+     added past a content-box min-height), so the initial scrollToEnd() (the
+     very first thing boot() does, right after the boot system line lands)
+     scrolls that overflow out of view and clips the boot message half under
+     the topbar before anyone reads it. */
+  .messages { box-sizing: border-box; max-width: 720px; margin: 0 auto; padding: 1.2rem 1rem 1.6rem; display: flex; flex-direction: column; gap: .15rem; min-height: 100%; }
 
   .msg-row { display: flex; flex-direction: column; margin: .35rem 0; max-width: 100%; }
   .msg-row.user { align-items: flex-end; }
@@ -155,6 +185,22 @@ ${THEME_TOKENS_CSS}
   .composer-inner button[type="submit"]:disabled { opacity: .4; cursor: default; }
   .statusline { max-width: 720px; margin: 0 auto; padding: 0 1.1rem .6rem; font-family: ${MONO_STACK}; font-size: .68rem; color: var(--muted); }
 
+  /* the provenance stats panel: what this session's memory holds, docked to
+     the right of the chat column (a real layout column, not an overlay) —
+     re-rendered after boot and after every turn from window.tmctChat's own
+     memoryStats(), never a second provenance computation. */
+  .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; }
+  .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; }
+  .statsPanel .band-row { display: flex; justify-content: space-between; gap: .6rem; margin: 0; padding: .12rem 0; }
+  .statsPanel .band-count { color: var(--muted); font-variant-numeric: tabular-nums; }
+  .statsPanel .taught-item { margin: 0 0 .7rem; }
+  .statsPanel .taught-tag { display: block; color: var(--muted); font-size: .66rem; margin-top: .15rem; word-break: break-word; }
+  .statsPanel .empty { color: var(--muted); margin: 0; }
+
+  @media (max-width: 860px) {
+    .statsPanel { display: none; }
+  }
   @media (max-width: 560px) {
     .legend { display: none; }
     .bubble { max-width: 92%; }
@@ -165,24 +211,29 @@ ${THEME_TOKENS_CSS}
 </style>
 </head>
 <body>
-  <header class="topbar">
-    <div class="brand">
-      <span class="eyebrow">tmct</span>
-      <h1>Talk to it</h1>
-    </div>
-    <div class="legend" aria-hidden="true">${legendHtml}</div>
-  </header>
-  <main class="chatMain">
-    <div class="messages" id="messages" role="log" aria-live="polite" aria-label="Conversation"></div>
-  </main>
-  <form class="composer" id="composer">
-    <div class="composer-inner">
-      <input id="composerInput" type="text" autocomplete="off" autocapitalize="off" spellcheck="false"
-        placeholder="loading the engine…" aria-label="Ask tmct something" disabled>
-      <button type="submit" id="composerSend" aria-label="Send" disabled>&#8594;</button>
-    </div>
-  </form>
-  <div class="statusline" id="status">loading the engine&hellip;</div>
+  <div class="chatCol">
+    <header class="topbar">
+      <div class="brand">
+        <span class="eyebrow">the-mechanical-code-talker</span>
+        <h1>Talk to it</h1>
+      </div>
+      <div class="legend" aria-hidden="true">${legendHtml}</div>
+    </header>
+    <main class="chatMain">
+      <div class="messages" id="messages" role="log" aria-live="polite" aria-label="Conversation"></div>
+    </main>
+    <form class="composer" id="composer">
+      <div class="composer-inner">
+        <input id="composerInput" type="text" autocomplete="off" autocapitalize="off" spellcheck="false"
+          placeholder="loading the engine…" aria-label="Ask tmct something" disabled>
+        <button type="submit" id="composerSend" aria-label="Send" disabled>&#8594;</button>
+      </div>
+    </form>
+    <div class="statusline" id="status">loading the engine&hellip;</div>
+  </div>
+  <aside class="statsPanel" id="statsPanel" aria-label="This session's memory">
+    <p class="empty">loading memory stats&hellip;</p>
+  </aside>
 <script src="./chat-browser.bundle.js"></script>
 <script>
 (function () {
@@ -196,6 +247,7 @@ ${THEME_TOKENS_CSS}
   const inputEl = el("composerInput");
   const sendBtn = el("composerSend");
   const statusEl = el("status");
+  const statsPanelEl = el("statsPanel");
 
   function scrollToEnd() {
     messagesEl.parentElement.scrollTop = messagesEl.parentElement.scrollHeight;
@@ -265,8 +317,8 @@ ${THEME_TOKENS_CSS}
   }
 
   // ---- engine boot -------------------------------------------------------
-  // Mirrors chat-ui.mjs's own boot sequence against the SAME bundle/seed/pack
-  // — a second consumer of the shared engine, not a fork of it.
+  // The same bounded-race wink load public/tmct-browser.mjs uses, against
+  // this page's own bundle/seed/pack.
   const WINK_LOAD_TIMEOUT_MS = 8000;
   const timeoutAfter = (ms, reason) => new Promise((_, reject) => setTimeout(() => reject(new Error(reason)), ms));
 
@@ -329,6 +381,77 @@ ${THEME_TOKENS_CSS}
     },
   };
 
+  // ---- memory stats: the boot message's own numbers, and the docked panel -
+  // Both read window.tmctChat.memoryStats(memoryDir) (chat-browser-entry.mjs)
+  // — one computation, reused, so the boot line and the panel can never
+  // disagree with each other about what this session's memory holds.
+  const BAND_LABELS = { human: "human persona", seon: "seon ontology", conceptnet: "ConceptNet" };
+  const BAND_ORDER = ["human", "seon", "conceptnet", "taught this session", "other"];
+  const bandLabel = (key) => BAND_LABELS[key] || key;
+
+  /** The boot system line's own memory summary — every seed band this
+   *  session actually loaded, named with its real count, left-to-right in
+   *  BAND_ORDER; a session with nothing seeded says so plainly instead of
+   *  naming zero facts. */
+  function statsSummaryLine(stats) {
+    if (!stats || !stats.total) return "no starter memory; starting empty";
+    const parts = BAND_ORDER.filter((k) => stats.bandCounts[k]).map((k) => stats.bandCounts[k] + " " + bandLabel(k));
+    return parts.length
+      ? "starter memory: " + parts.join(" + ") + " (" + stats.total + " facts total)"
+      : stats.total + " starter facts loaded";
+  }
+
+  function bandRow(label, count) {
+    const row = document.createElement("p");
+    row.className = "band-row";
+    const l = document.createElement("span");
+    l.textContent = label;
+    const c = document.createElement("span");
+    c.className = "band-count";
+    c.textContent = String(count);
+    row.appendChild(l);
+    row.appendChild(c);
+    return row;
+  }
+
+  /** (Re)render the docked panel from a memoryStats() result — stats may be
+   *  passed in already-computed (boot reuses its own call rather than asking
+   *  twice); omitted, it fetches fresh. Best-effort: a session not ready yet,
+   *  or a read that throws, leaves the panel showing whatever it last showed
+   *  rather than blanking it. */
+  async function renderStatsPanel(stats) {
+    if (!stats) {
+      if (!window.tmctChatSession || !window.tmctChat.memoryStats) return;
+      try { stats = await window.tmctChat.memoryStats(window.tmctChatSession.memoryDir); }
+      catch { return; }
+    }
+    statsPanelEl.textContent = "";
+    statsPanelEl.appendChild(Object.assign(document.createElement("h2"), { textContent: "this session's memory" }));
+    statsPanelEl.appendChild(bandRow("total facts", stats.total));
+    for (const key of BAND_ORDER) {
+      if (stats.bandCounts[key]) statsPanelEl.appendChild(bandRow(bandLabel(key), stats.bandCounts[key]));
+    }
+
+    statsPanelEl.appendChild(Object.assign(document.createElement("h2"), { textContent: "taught this session" }));
+    if (!stats.taught.length) {
+      const empty = document.createElement("p");
+      empty.className = "empty";
+      empty.textContent = 'nothing yet \\u2014 teach it something ("a dog is a kind of animal") and it lands here, with its source.';
+      statsPanelEl.appendChild(empty);
+    } else {
+      for (const fact of stats.taught.slice(-8).reverse()) {
+        const item = document.createElement("p");
+        item.className = "taught-item";
+        item.appendChild(document.createTextNode(fact.subject + " " + fact.predicate + " " + fact.object));
+        const tag = document.createElement("span");
+        tag.className = "taught-tag";
+        tag.textContent = fact.tag;
+        item.appendChild(tag);
+        statsPanelEl.appendChild(item);
+      }
+    }
+  }
+
   function renderStatus() {
     const seedPart = seedPayload
       ? "starter memory: " + seedFacts + " facts"
@@ -358,7 +481,10 @@ ${THEME_TOKENS_CSS}
     const pendingRow = addPendingAssistantBubble();
     setBusy(true);
     window.tmctChatSession.turn(q)
-      .then((result) => settleAssistantBubble(pendingRow, result.answer, result.record))
+      .then((result) => {
+        settleAssistantBubble(pendingRow, result.answer, result.record);
+        return renderStatsPanel(); // a teach turn just grew this session's memory; a plain ask leaves it unchanged either way
+      })
       .catch((err) => settleAssistantBubble(pendingRow,
         "something went wrong answering that (" + (err && err.message ? err.message : err) + ") \\u2014 try rephrasing",
         { miss: true }))
@@ -377,9 +503,10 @@ ${THEME_TOKENS_CSS}
     await Promise.all([fetchSeed(), tryLoadWink()]);
     window.tmctChat.registerReferencePackProvider(fetchPackProvider);
     window.tmctChatSession = newSession();
-    addSystemLine(seedPayload
-      ? "tmct \\u2014 the real engine, running in this page \\u2014 " + seedFacts + " starter facts loaded"
-      : "tmct \\u2014 the real engine, running in this page \\u2014 no starter memory; starting empty");
+    const stats = await window.tmctChat.memoryStats(window.tmctChatSession.memoryDir);
+    addSystemLine("tmct \\u2014 the real engine, running in this page \\u2014 " + statsSummaryLine(stats)
+      + ". Ask it something, or teach it a fact of your own.");
+    await renderStatsPanel(stats);
     inputEl.placeholder = seedPayload ? 'try "what is a dog"' : window.tmctChat.vocabExampleHint(false);
     renderStatus();
     setBusy(false);

package/src/services/ledger-viz.mjs

@@ -393,12 +393,20 @@ function microbarsHtml(items) {
 /** The dashboard strip: fact/term totals, the tier bar, graph density, a data-
  *  quality tile keyed off the SAME contradiction count worthALook surfaces,
  *  and the corpus-bundle/predicate leaderboards. Every tile reads straight
- *  off `stats` (computeLedgerStats) — no client-side recomputation. */
-function dashboardHtml(stats) {
+ *  off `stats` (computeLedgerStats) — no client-side recomputation.
+ *
+ *  Also the live dock's own re-render target: `id="dash"` gives a post-teach
+ *  refresh a single element to replace (`el("dash").outerHTML = dashboardHtml(...)`
+ *  — see renderLedgerHtml's inline script), and `fresh: true` marks that
+ *  replacement with a quiet settle-fade (`.dash.fresh`, below) rather than a
+ *  silent swap — the SAME function serves the server-rendered initial paint
+ *  (fresh omitted) and every live update after it, so the two can never drift. */
+function dashboardHtml(stats, { fresh = false } = {}) {
   const s = stats || {};
   const total = s.totalFacts || 0;
+  const freshCls = fresh ? " fresh" : "";
   if (!total) {
-    return `<section class="dash" aria-label="Ledger metrics"><div class="tile"><span class="tile-label">facts.total</span><span class="tile-value">0</span><span class="tile-sub">nothing taught yet</span></div></section>`;
+    return `<section class="dash${freshCls}" id="dash" aria-label="Ledger metrics"><div class="tile"><span class="tile-label">facts.total</span><span class="tile-value">0</span><span class="tile-sub">nothing taught yet</span></div></section>`;
   }
   const terms = s.totalTerms || 0;
   const qualityCls = s.contradictionCount > 0 ? " tile-alert" : "";
@@ -406,7 +414,7 @@ function dashboardHtml(stats) {
   const predicatesHtml = s.predicates?.length
     ? microbarsHtml(s.predicates.map((p) => ({ label: p.phrase || p.predicate, count: p.count })))
     : `<span class="tile-sub">none yet</span>`;
-  return `<section class="dash" aria-label="Ledger metrics">
+  return `<section class="dash${freshCls}" id="dash" aria-label="Ledger metrics">
     <div class="tile">
       <span class="tile-label">facts.total</span>
       <span class="tile-value">${total}</span>
@@ -462,11 +470,40 @@ function sparklineSvg(stats) {
   </svg>`;
 }
 
+/** The sparkline's own caption — "learned <date>" for a single-day graph,
+ *  "first … last …" once it spans more than one, or the generic fallback
+ *  before any dated fact exists. Its own named function (not inlined at the
+ *  one server call site) so the live dock's post-teach refresh can call the
+ *  identical logic client-side — see renderLedgerHtml's `sparkCaptionHtml`
+ *  toString-embed, below. */
+function sparkCaptionHtml(stats) {
+  return stats?.firstLearned && stats?.lastLearned
+    ? (stats.firstLearned.slice(0, 10) === stats.lastLearned.slice(0, 10)
+        ? `learned ${escapeHtml(stats.lastLearned.slice(0, 10))}`
+        : `first ${escapeHtml(stats.firstLearned.slice(0, 10))} &middot; last ${escapeHtml(stats.lastLearned.slice(0, 10))}`)
+    : "cumulative facts, teach order";
+}
+
 /** One complete, self-contained document: the ledger, segment rail,
  *  worth-a-look panel, breadcrumb/search, two-hop minimap, and (when the
  *  memory-ask bundle is present) the ask-the-graph chat dock, all over the
- *  embedded LEDGER/PAYLOAD data. */
-export function renderLedgerHtml({ rows, terms, edges, focus, contradictions, worthALook, payload, meta, memoryAskBundle, stats } = {}) {
+ *  embedded LEDGER/PAYLOAD data.
+ *
+ *  `ledgerBundleAvailable` (default false — every existing caller, including
+ *  bin/tmct.mjs's `tmct viz` and every test that doesn't pass it) governs
+ *  ONE thing: whether an external `<script src="./ledger-browser.bundle.js">`
+ *  reference is emitted at all. That bundle carries the full runTurn engine
+ *  (teach AND ask) and is Pages-demo-site-only — never built or shipped
+ *  alongside the CLI's own output — so the CLI's `renderLedgerHtml` call
+ *  never sets this and the page stays exactly as documented above, one
+ *  self-contained document with no external requests. Only
+ *  scripts/build-demo-site.mjs, which builds the sibling bundle itself
+ *  first, passes `true`. The dock's own runtime code below ALSO gates on
+ *  `typeof tmctLedger !== "undefined"` regardless — the two checks answer
+ *  different questions (did this render even offer the reference; did the
+ *  browser actually manage to load it), and both must hold for the live
+ *  path to run. */
+export function renderLedgerHtml({ rows, terms, edges, focus, contradictions, worthALook, payload, meta, memoryAskBundle, stats, ledgerBundleAvailable = false } = {}) {
   const ledgerJson = embedJson({ rows: rows || [], terms: terms || [], edges: edges || [], focus: focus || null, contradictions: contradictions || [], worthALook: worthALook || null, meta: meta || { shown: 0, total: 0, truncated: false } });
   const payloadJson = embedJson(payload || { individuals: [], objectProperties: [] });
   const shown = meta?.shown ?? (rows || []).length;
@@ -474,7 +511,10 @@ export function renderLedgerHtml({ rows, terms, edges, focus, contradictions, wo
   const bundleStr = typeof memoryAskBundle === "string" ? memoryAskBundle : "";
   const hasMemChat = bundleStr.length > 0;
   // The placeholder is honest: the canonical exchange only when its terms are
-  // really in this payload, otherwise a real term from this graph.
+  // really in this payload, otherwise a real term from this graph. Left as
+  // the query-only wording even when the live bundle is offered — the dock's
+  // own script swaps it for a teach-aware placeholder the moment it confirms
+  // tmctLedger actually loaded (never claimed ahead of that confirmation).
   const termSet = new Set((terms || []).map((t) => t.term));
   const placeholder = termSet.has("ishmael")
     ? "who is the grandfather of ishmael"
@@ -488,11 +528,6 @@ export function renderLedgerHtml({ rows, terms, edges, focus, contradictions, wo
         </form>
       </div>`
     : `<div class="chat chat-off"><p class="chatnote">chat unavailable — run <span class="mono">npm run build:ask-bundle</span> to enable the in-page ask engine.</p></div>`;
-  const sparkCaption = stats?.firstLearned && stats?.lastLearned
-    ? (stats.firstLearned.slice(0, 10) === stats.lastLearned.slice(0, 10)
-        ? `learned ${escapeHtml(stats.lastLearned.slice(0, 10))}`
-        : `first ${escapeHtml(stats.firstLearned.slice(0, 10))} &middot; last ${escapeHtml(stats.lastLearned.slice(0, 10))}`)
-    : "cumulative facts, teach order";
 
   return `<!doctype html>
 <html lang="en">
@@ -500,6 +535,29 @@ export function renderLedgerHtml({ rows, terms, edges, focus, contradictions, wo
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>${escapeHtml(title)}</title>
+<!--
+  Import map: resolves the "wink-nlp"/"wink-eng-lite-web-model" bare specifiers the
+  live ask-and-teach dock's own dynamic import() needs (pinned to the exact versions
+  package.json depends on) to esm.sh CDN builds — the same seam chat.html and
+  plan.html each wire up for their own live sessions, mirrored here because this page
+  can be opened standalone (no import map inherited from a host document; this
+  includes the self-contained file tmct viz writes to disk — a plain cross-origin
+  dynamic import() of a remote https:// URL, not a file:// read, so it works the
+  same way offline this page's own try/catch already handles for the deployed site:
+  the fetch fails and the wink tier degrades gracefully). Nothing in this file
+  touches wink-nlp directly — wink-model.mjs's own header explains why a static
+  import would drag the ~1 MB model into every bundle; only the page's own inline
+  script performs this CDN import, the same bounded-race tryLoadWink() pattern
+  public/tmct-browser.mjs uses.
+-->
+<script type="importmap">
+{
+  "imports": {
+    "wink-nlp": "https://esm.sh/wink-nlp@2.4.0",
+    "wink-eng-lite-web-model": "https://esm.sh/wink-eng-lite-web-model@1.8.1"
+  }
+}
+</script>
 <style>
 ${THEME_TOKENS_CSS}
   html { background: var(--bg); }
@@ -594,12 +652,26 @@ ${THEME_TOKENS_CSS}
   .chatlog .a { font-size: .9rem; line-height: 1.45; }
   .chatlog .a.miss { color: var(--muted); }
   .chatlog .a.goal { font-family: ${MONO_STACK}; font-size: .72rem; color: var(--muted); }
+  .chatlog .a.pending { color: var(--muted); font-style: italic; }
+  .chatlog .a.taught { border-left: 2px solid var(--taught); padding-left: .55rem; }
+  .chatlog .a.taught .tag { display: block; font-family: ${MONO_STACK}; font-size: .62rem; letter-spacing: .06em; text-transform: uppercase; color: var(--taught); margin-bottom: .18rem; }
   .chatask { display: flex; align-items: center; gap: .5rem; }
   .chatlog:not(:empty) + .chatask { border-top: 1px solid var(--line); margin-top: .55rem; padding-top: .55rem; }
   .chatask .prompt { color: var(--taught); font-size: .78rem; }
   .chatask input { flex: 1; font-family: ${MONO_STACK}; font-size: .78rem; background: var(--bg); color: var(--ink); border: 1px solid var(--line); border-radius: 6px; padding: .32rem .6rem; min-width: 0; }
+  .chatask input:disabled { opacity: .6; }
   .chatnote { font-family: ${MONO_STACK}; font-size: .72rem; color: var(--muted); margin: 0; }
-  @media (prefers-reduced-motion: no-preference) { .seg, .chip, .look { transition: border-color .12s ease, background-color .12s ease; } }
+  @media (prefers-reduced-motion: no-preference) {
+    .seg, .chip, .look { transition: border-color .12s ease, background-color .12s ease; }
+    /* A live teach re-render swaps the dash section wholesale (dashboardHtml
+       is called again in full — see the inline script below), so the "this
+       just changed" signal has to be an animation on the fresh markup itself,
+       never a transition (which needs an old and new state on the SAME node
+       to interpolate between). Off entirely under reduced motion — the
+       numbers still update, just without the settle-fade. */
+    .dash.fresh .tile { animation: freshsettle 1.6s ease-out; }
+    @keyframes freshsettle { from { background: var(--taught-soft); } to { background: var(--card); } }
+  }
 </style>
 </head>
 <body>
@@ -632,18 +704,22 @@ ${THEME_TOKENS_CSS}
         <p class="mapnote">dots = terms &middot; click to refocus &middot; dim = filtered out</p>
       </div>
       <h2>ingestion</h2>
-      <div class="mapwrap sparkwrap">
+      <div class="mapwrap sparkwrap" id="sparkWrap">
         ${sparklineSvg(stats)}
-        <p class="mapnote">${sparkCaption}</p>
+        <p class="mapnote">${sparkCaptionHtml(stats)}</p>
       </div>
     </aside>
   </div>
 </main>
 <script>
-const LEDGER = ${ledgerJson};
+// let, not const: a successful live teach reassigns this wholesale
+// (applyLedgerData, in the script below) so the page re-renders the graph
+// it actually holds, not the snapshot from the moment the page loaded.
+let LEDGER = ${ledgerJson};
 const PAYLOAD = ${payloadJson};
 </script>
 ${hasMemChat ? `<script>\n${bundleStr}\n</script>` : ""}
+${ledgerBundleAvailable ? `<script src="./ledger-browser.bundle.js"></script>` : ""}
 <script>
 (function () {
   "use strict";
@@ -651,15 +727,39 @@ ${hasMemChat ? `<script>\n${bundleStr}\n</script>` : ""}
   const facetCounts = ${facetCounts.toString()};
   const el = (id) => document.getElementById(id);
   const esc = ${escapeHtml.toString()};
+  // Aliased so the dashboard/sparkline builders below (toString-embedded
+  // verbatim from ledger-viz.mjs's own Node-side source, which calls
+  // escapeHtml/pct by their real names) resolve without a second copy.
+  const escapeHtml = esc;
+  const pct = ${pct.toString()};
+  const tierTileHtml = ${tierTileHtml.toString()};
+  const microbarsHtml = ${microbarsHtml.toString()};
+  const dashboardHtml = ${dashboardHtml.toString()};
+  const sparklineSvg = ${sparklineSvg.toString()};
+  const sparkCaptionHtml = ${sparkCaptionHtml.toString()};
   const FAMS = ["is-a", "has", "can", "used-for", "rests-on", "role", "other"];
   const FAM_LABEL = { "is-a": "is a kind of", has: "has", can: "can", "used-for": "used for", "rests-on": "rests on", role: "role / property", other: "other" };
   const PROVS = [["taught", "you taught"], ["corpus", "corpus"], ["entail", "entailed"]];
   const RECS = ["today", "this week", "older"];
   const provKey = (p) => (p === "entailed" ? "entail" : p); // css class key
-  const termIndex = new Map(LEDGER.terms.map((t) => [t.term, t]));
-  const rowById = new Map(LEDGER.rows.map((r) => [r.id, r]));
-  const contraById = new Map();
-  LEDGER.contradictions.forEach((ids, gi) => ids.forEach((id) => contraById.set(id, gi)));
+
+  // LEDGER (declared "let" in the embed script above this one — a classic,
+  // non-module script's top-level bindings are reachable as bare identifiers
+  // by every later script tag in the document, never as window.LEDGER; see
+  // e2e/pages-ledger.test.mjs's own note on this) and its indexes start as
+  // the server-rendered snapshot but are REASSIGNED wholesale after a live
+  // teach (applyLedgerData, below) — a successful teach through the dock
+  // changes the underlying graph, and the page has to show that, not keep
+  // rendering the page-load snapshot next to a chat log that merely SAYS
+  // something new was learned.
+  let termIndex, rowById, contraById;
+  function rebuildIndexes() {
+    termIndex = new Map(LEDGER.terms.map((t) => [t.term, t]));
+    rowById = new Map(LEDGER.rows.map((r) => [r.id, r]));
+    contraById = new Map();
+    LEDGER.contradictions.forEach((ids, gi) => ids.forEach((id) => contraById.set(id, gi)));
+  }
+  rebuildIndexes();
 
   let focus = LEDGER.focus;
   let trail = focus ? [{ term: focus, label: null }] : [];
@@ -845,10 +945,133 @@ ${hasMemChat ? `<script>\n${bundleStr}\n</script>` : ""}
     else el("qmiss").textContent = "no such term";
   });
 
-  // ---- the chat dock: the SAME engine + payload the CLI answers from ------
+  // A successful live teach re-derives the WHOLE ledger (computeLedgerDataFromPayload,
+  // the sibling bundle's own re-export of the exact function this page's build
+  // step called) and re-mounts it here — the same view a fresh page load
+  // would render, never a stale snapshot next to a chat log that only SAYS
+  // something new was learned. The dashboard/sparkline sections are replaced
+  // wholesale (dashboardHtml/sparklineSvg, toString-embedded above, are the
+  // SAME functions the server used for the very first paint) rather than
+  // patched, so they can never drift from what a fresh render would produce.
+  function applyLedgerData(freshData) {
+    LEDGER = {
+      rows: freshData.rows, terms: freshData.terms, edges: freshData.edges,
+      focus: freshData.focus, contradictions: freshData.contradictions,
+      worthALook: freshData.worthALook, meta: freshData.meta,
+    };
+    rebuildIndexes();
+    el("dash").outerHTML = dashboardHtml(freshData.stats, { fresh: true });
+    el("sparkWrap").innerHTML = sparklineSvg(freshData.stats) + '<p class="mapnote">' + sparkCaptionHtml(freshData.stats) + "</p>";
+    // computeLedgerDataFromPayload resolves an unset focus to the newest
+    // taught row's own subject — passing no explicit term (below) means every
+    // successful teach naturally jumps the view to what was just learned.
+    if (freshData.focus) refocusWithLabel(freshData.focus, null);
+    else render();
+  }
+
+  // ---- the chat dock: LIVE teach+ask over the sibling ledger-browser.bundle.js
+  // (window.tmctLedger) when the demo build offered it AND it actually
+  // loaded; falls back to the read-only tmctMemoryAsk engine below —
+  // unchanged from before this page could teach at all — otherwise.
+  // bin/tmct.mjs's own \`tmct viz\` output never offers the live bundle
+  // (renderLedgerHtml's own ledgerBundleAvailable defaults false there), so
+  // this branch is simply never reachable on a CLI-generated page.
   const resolveAnsweredTerm = ${resolveAnsweredTerm.toString()};
   const chatForm = el("chatform");
-  if (chatForm && typeof tmctMemoryAsk !== "undefined") {
+  if (chatForm && typeof tmctLedger !== "undefined" && typeof tmctLedger.createLedgerSession === "function") {
+    const log = el("chatlog");
+    const chatqEl = el("chatq");
+    chatqEl.placeholder = 'ask or teach the graph\\u2026 e.g. "blue is a peg"';
+    const addLine = (cls, html) => {
+      const d = document.createElement("div");
+      d.className = cls; d.innerHTML = html;
+      log.appendChild(d); log.scrollTop = log.scrollHeight;
+      return d;
+    };
+
+    let session = null;
+    // Serializes every engine-touching call through this one dock — the same
+    // posture plan-viz.mjs's own chat-assert dock takes with its withLock,
+    // so a fast double-submit can never race two turns over one session.
+    let lock = Promise.resolve();
+    const withLock = (fn) => { const run = lock.then(fn, fn); lock = run.catch(() => {}); return run; };
+
+    // The SAME bounded-race wink-nlp CDN load plan-viz.mjs's own chat-assert
+    // dock uses: a cross-origin dynamic import() can neither resolve nor
+    // reject on some failures, so an unbounded await would leave a session
+    // stuck forever. Best-effort — a teach sentence that needs the lemma tier
+    // just declines honestly without it, same as a checkout missing the
+    // optional deps.
+    const WINK_LOAD_TIMEOUT_MS = 8000;
+    const winkTimeout = (ms, reason) => new Promise((_, reject) => setTimeout(() => reject(new Error(reason)), ms));
+    let winkReady = null;
+    function tryLoadWink() {
+      if (winkReady) return winkReady;
+      winkReady = (async () => {
+        try {
+          const mods = await Promise.race([
+            Promise.all([import("wink-nlp"), import("wink-eng-lite-web-model")]),
+            winkTimeout(WINK_LOAD_TIMEOUT_MS, "wink-nlp CDN load timed out"),
+          ]);
+          const winkNLP = mods[0].default;
+          const model = mods[1].default;
+          tmctLedger.registerWinkModel(() => ({ winkNLP: winkNLP, model: model }));
+        } catch (err) {
+          // eslint-disable-next-line no-console
+          console.warn("tmct ledger: wink-nlp CDN load failed, continuing without the lemma/POS tier", err);
+        }
+      })();
+      return winkReady;
+    }
+    tryLoadWink(); // fire eagerly at load, so it is likely settled by the first interaction
+
+    async function ensureSession() {
+      if (session) return session;
+      await tryLoadWink();
+      session = await tmctLedger.createLedgerSession({ seedPayload: PAYLOAD });
+      return session;
+    }
+
+    chatForm.addEventListener("submit", (e) => {
+      e.preventDefault();
+      const q = chatqEl.value.trim();
+      if (!q) return;
+      chatqEl.value = "";
+      addLine("u", esc(q));
+      const pending = addLine("a pending", "computing\\u2026");
+      chatqEl.disabled = true;
+      withLock(async () => {
+        try {
+          const s = await ensureSession();
+          const result = await s.turn(q);
+          const record = result.record;
+          const taught = !!record && record.miss === false && (record.via === "assert" || record.via === "retract");
+          const body = esc(result.answer).replace(/\\n/g, "<br>");
+          pending.className = "a" + (taught ? " taught" : (record && record.miss ? " miss" : ""));
+          pending.innerHTML = taught ? '<span class="tag">taught</span>' + body : body;
+          if (taught) {
+            const fresh = tmctLedger.computeLedgerDataFromPayload(s.memoryDir.payload, {});
+            applyLedgerData(fresh);
+          } else if (!(record && record.miss)) {
+            // Only a genuine answer (never a miss) tries to resolve a
+            // refocus target — the honest-miss cascade's own boilerplate
+            // ("Run \`tmct init\`…") can contain a real term as an
+            // ordinary English word (e.g. "run", if the graph happens to
+            // hold it), and resolveAnsweredTerm has no way to tell that
+            // apart from the term genuinely being discussed.
+            const hit = resolveAnsweredTerm(result.answer, q, LEDGER.terms, tmctLedger.normFactTerm);
+            if (hit) refocusWithLabel(hit, q);
+          }
+        } catch {
+          pending.className = "a miss";
+          pending.textContent = "Something went wrong answering that. Try rephrasing, or reload the page.";
+        } finally {
+          chatqEl.disabled = false;
+          chatqEl.focus();
+        }
+      });
+    });
+  } else if (chatForm && typeof tmctMemoryAsk !== "undefined") {
     const memHandle = tmctMemoryAsk.createInMemoryStore();
     memHandle.payload = PAYLOAD;
     const log = el("chatlog");

package/src/services/plan-viz.mjs

@@ -296,13 +296,13 @@ export function renderPlanHtml({ plan, rendersAs = {}, sizeOrder = [], title } =
 <!--
   Import map: resolves the "wink-nlp"/"wink-eng-lite-web-model" bare specifiers the
   live re-solve session's own dynamic import() needs (pinned to the exact versions
-  package.json depends on) to esm.sh CDN builds — the same seam index.html's own
-  import map wires up for the embedded chat, mirrored here because this page can be
-  opened standalone (no import map inherited from a host document). The bundle
-  itself (./plan-browser.bundle.js) never touches wink-nlp directly — wink-model.mjs's
-  own header explains why a static import would drag the ~1 MB model into every
-  bundle; only the page's own inline script performs this CDN import, exactly like
-  public/chat-ui.mjs's own tryLoadWink().
+  package.json depends on) to esm.sh CDN builds — the same seam chat.html and
+  ledger.html each wire up for their own live sessions, mirrored here because this
+  page can be opened standalone (no import map inherited from a host document). The
+  bundle itself (./plan-browser.bundle.js) never touches wink-nlp directly —
+  wink-model.mjs's own header explains why a static import would drag the ~1 MB
+  model into every bundle; only the page's own inline script performs this CDN
+  import, the same bounded-race tryLoadWink() pattern public/tmct-browser.mjs uses.
 -->
 <script type="importmap">
 {
@@ -636,9 +636,9 @@ const PLAN = ${embedded};
     // "moving" to "move" — without it that one teach sentence honestly
     // declines and every position fact taught after it fails in turn. Load
     // wink from the CDN and register it, the SAME bounded-race pattern
-    // public/chat-ui.mjs and public/tmct-browser.mjs both use: a cross-
-    // origin dynamic import() can neither resolve nor reject on some
-    // failures, so an unbounded await would leave a resolve stuck forever.
+    // public/tmct-browser.mjs uses: a cross-origin dynamic import() can
+    // neither resolve nor reject on some failures, so an unbounded await
+    // would leave a resolve stuck forever.
     // Awaited before EVERY session creation below (idempotent — a second
     // await after the first attempt already settled resolves immediately).
     const WINK_LOAD_TIMEOUT_MS = 8000;

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

@@ -1,5 +1,5 @@
-// chat-browser-entry.mjs — the esbuild entry for the home page's embedded
-// chat (public/chat-ui.mjs, built by scripts/build-chat-bundle.mjs).
+// chat-browser-entry.mjs — the esbuild entry for chat.html's embedded chat
+// (built by scripts/build-chat-bundle.mjs).
 //
 // Unlike memory-ask-browser-entry.mjs (factAnswer/factReadBack only), this
 // exposes the FULL turn engine: createChatSession wraps chat.mjs's runTurn
@@ -17,7 +17,8 @@
 //     Web Crypto API instead, with a Date.now fallback for contexts
 //     without it.
 import { runTurn, vocabExampleHint } from "../../services/chat.mjs";
-import { createInMemoryStore, normFactTerm } from "../../adapters/memory/core.mjs";
+import { createInMemoryStore, normFactTerm, loadMemory, readFactRows } from "../../adapters/memory/core.mjs";
+import { provenanceTagToSource } from "../../domain/memory/trust.mjs";
 import { parseEntities } from "../../domain/codegraph.mjs";
 import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
 import { registerWinkModel } from "../../adapters/wink-model.mjs";
@@ -84,4 +85,51 @@ export function createChatSession({ seedPayload = null, vocabSeeded = false } =
   };
 }
 
-globalThis.tmctChat = { createChatSession, registerWinkModel, registerReferencePackProvider, normFactTerm, vocabExampleHint };
+/**
+ * The memory a running session holds, broken down by where each fact came
+ * from: the seed corpus bands it booted with (keyed by the SAME band name
+ * build-chat-seed.mjs/extensions.mjs seed under — "human", "seon",
+ * "conceptnet" today, whichever bands a future seed adds tomorrow) plus
+ * whatever has been taught THIS session over chat. Reuses memory/trust.mjs's
+ * own `provenanceTagToSource` against each fact's already-stored provenance
+ * tag(s) (readFactRows' `provenance`, the ' | '-joined compat string) rather
+ * than inventing a second provenance parse — the same tag chat.mjs's own
+ * "(source: ...)" citation already carries, so this panel and a turn's
+ * citation always agree on where a fact came from.
+ *
+ * Returns { total, bandCounts, taught }: `bandCounts` maps a band label to
+ * its fact count ("taught this session" for a teach/operator-sourced fact
+ * with no corpus band, "other" for anything provenance can't place);
+ * `taught` lists every session-taught fact (subject/predicate/object + its
+ * own provenance tag), most-recently-taught last — a stats panel's
+ * provenance column reads straight off this, no further lookup needed.
+ */
+export async function memoryStats(memoryDir) {
+  const memory = await loadMemory(memoryDir);
+  const rows = readFactRows(memory);
+  const bandCounts = {};
+  const taught = [];
+  for (const row of rows) {
+    const tags = String(row.provenance || "").split(" | ").filter(Boolean);
+    let band = null;
+    let isTaught = false;
+    let taughtTag = "";
+    for (const tag of tags) {
+      const src = provenanceTagToSource(tag);
+      if (!src) continue;
+      // corpusWeak (a /r/RelatedTo-strength triple, e.g. ConceptNet's or
+      // SEON's own weaker associations) names the SAME band as corpus (a
+      // /r/IsA-strength one) — both carry `src.name`, and a band count that
+      // dropped the weak tier would undercount a corpus by exactly its
+      // weak-relation facts (SEON: 19 of them, all `corpus-weak:seon`).
+      if ((src.kind === "corpus" || src.kind === "corpusWeak") && src.name) band = src.name;
+      if (src.kind === "teach" || src.kind === "operator") { isTaught = true; taughtTag = tag; }
+    }
+    const label = band || (isTaught ? "taught this session" : "other");
+    bandCounts[label] = (bandCounts[label] || 0) + 1;
+    if (isTaught) taught.push({ subject: row.subject, predicate: row.predicate, object: row.object, tag: taughtTag });
+  }
+  return { total: rows.length, bandCounts, taught };
+}
+
+globalThis.tmctChat = { createChatSession, registerWinkModel, registerReferencePackProvider, normFactTerm, vocabExampleHint, memoryStats };

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

@@ -0,0 +1,85 @@
+// ledger-browser-entry.mjs — the esbuild entry for the memory-ledger page's
+// LIVE chat dock (public/ledger-browser.bundle.js, built by
+// scripts/build-ledger-bundle.mjs), mirroring chat-browser-entry.mjs's own
+// createChatSession shape exactly. The ledger dock is general free-text
+// teach+ask, the same shape chat.html's own dock is — not board-game
+// specific like plan-browser-entry.mjs's createPlanSession, which has to
+// teach and solve a puzzle up front.
+//
+// Gitignored, Pages-demo-site-only output (scripts/build-demo-site.mjs
+// builds it fresh on every deploy, never committed) — see
+// memory-ask-browser-entry.mjs's own header for the contrast: THAT bundle
+// (factAnswer/factReadBack only, ~1.0MB) is the one COMMITTED under src/ and
+// packed by `npm publish`, because `tmct viz` is a real CLI command run
+// against a user's own local .tmct store and must ship with the package.
+// This bundle carries the FULL runTurn engine (~1.5MB, the same weight
+// class as chat/spider-fly/adventure/plan's own browser bundles) and is
+// never published — only the hosted demo site's public/ledger.html links to
+// it, as an optional sibling script the page degrades honestly without.
+import { runTurn, vocabExampleHint } from "../../services/chat.mjs";
+import { createInMemoryStore, normFactTerm } from "../../adapters/memory/core.mjs";
+import { parseEntities } from "../../domain/codegraph.mjs";
+import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
+import { registerWinkModel } from "../../adapters/wink-model.mjs";
+import { computeLedgerDataFromPayload } from "../../services/ledger-viz.mjs";
+
+/**
+ * A browser ledger-dock session over the real turn engine — createChatSession's
+ * exact shape, seeded from the ledger page's own embedded PAYLOAD (the same
+ * loadMemory()-shaped object renderLedgerHtml embeds as `const PAYLOAD`), so
+ * 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.
+ * 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
+ * re-derive the page's rows/terms/edges/stats and re-mount the same view a
+ * fresh page load would have rendered — a plain query never re-derives.
+ */
+export function createLedgerSession({ seedPayload = null, vocabSeeded = false } = {}) {
+  const memoryDir = createInMemoryStore();
+  // Spread onto the store's own empty payload so a partial seed still
+  // carries the classes/prefixes scaffolding the write path recounts —
+  // teach turns must work regardless of what the seed payload carries.
+  if (seedPayload) memoryDir.payload = { ...memoryDir.payload, ...seedPayload };
+
+  const graph = parseEntities({ individuals: [], objectProperties: [] });
+  const lexicon = loadLexicon();
+  const vocabHint = vocabExampleHint(vocabSeeded);
+  const sessionId = globalThis.crypto?.randomUUID?.() ?? String(Date.now());
+
+  let focus = null;
+  let last = null;
+  let planState = null;
+
+  return {
+    memoryDir,
+    sessionId,
+
+    /** One dispatched turn. A throwing runTurn must never kill the session —
+     *  the page has no other chance to show this turn's answer. */
+    async turn(line) {
+      let result;
+      try {
+        result = await runTurn(line, {
+          config: null, source: null, graph, focus, last, memoryDir, sessionId,
+          env: {}, lexicon, vocabHint, planState,
+        });
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return { answer: `Something went wrong answering that (${message}). Try rephrasing, or /help.`, end: false, record: null };
+      }
+      focus = result.focus;
+      last = result.last;
+      if ("planState" in result) planState = result.planState;
+      return { answer: result.answer, end: Boolean(result.end), record: result.record ?? null };
+    },
+  };
+}
+
+// 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.
+globalThis.tmctLedger = { createLedgerSession, computeLedgerDataFromPayload, normFactTerm, registerWinkModel };

package/src/surfaces/web/memory-ask-browser.bundle.js

@@ -9268,6 +9268,7 @@ ${bodyText}` : graphText, tier });
     findContradictions: () => findContradictions,
     findRuleByName: () => findRuleByName,
     findRulesByName: () => findRulesByName,
+    isMemoryOrSqliteHandle: () => isMemoryOrSqliteHandle,
     loadMemory: () => loadMemory,
     loadSyllogiseState: () => loadSyllogiseState,
     normFactPredicate: () => normFactPredicate,
@@ -22059,6 +22060,7 @@ ${codeblock}`, options);
       init_prose();
       init_text_stats();
       init_trust();
+      init_core();
       BLOCKS_DIR_REL = join(".tmct", "memory", "blocks");
     }
   });