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

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

@@ -107,6 +107,107 @@ export function computeCodeExplorerData(payload, opts = {}) {
   return { payload, ledger, hints, focus: ledger.focus || focus, meta: { title: opts.title || "code graph" } };
 }
 
+// ---- client script pieces, spliced into CLIENT_JS below -------------------
+// Named module functions so the page's own source reads as a list of calls
+// into real, unit-tested code rather than an inlined block. Each is written
+// to survive a `.toString()` round trip into a browser `<script>` tag: no
+// closure over this module's own scope, only its parameters and whichever
+// sibling below it is also spliced into the same page script.
+
+/** One line naming the loaded graph's own size: individual/edge counts, then
+ *  up to four of its most common classes. */
+export function statsSummaryLine(ledgerStats) {
+  var parts = [ledgerStats.individuals + " individuals", ledgerStats.edges + " edges"];
+  var cls = ledgerStats.classes.slice(0, 4).map(function (c) { return c[1] + " " + c[0]; });
+  return parts.concat(cls).join("  ·  ");
+}
+
+/** Every fact the chat can draw on: the graph's own edges plus whatever the
+ *  general-knowledge seed has counted so far. */
+export function factTotalText(edges, seedFacts) {
+  return (edges + seedFacts).toLocaleString();
+}
+
+export function rowKey(row) { return JSON.stringify([row.s, row.kind, row.o]); }
+
+/** The sidebar's rows: the engine's own answer about the focus when it
+ *  grounded one, the row list's plain filter otherwise, then whatever
+ *  neither named — a fold over the rest of the graph. */
+export function focusRowsHtml(data, related) {
+  var focus = data.focus;
+  var rows = data.ledger.rows;
+  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; });
+  var rest = rows.filter(function (r) { return !nearKeys[rowKey(r)]; });
+  var ordered = near.concat(rest);
+  return ordered.map(function (r) {
+    var hot = (r.s === focus || r.o === focus) ? " row-focus" : "";
+    return '<li class="row' + hot + '">'
+      + '<button class="term" data-term="' + escapeHtml(r.s) + '">' + escapeHtml(r.s) + '</button> '
+      + '<span class="verb">' + escapeHtml(r.phrase) + '</span> '
+      + '<button class="term" data-term="' + escapeHtml(r.o) + '">' + escapeHtml(r.o) + '</button>'
+      + '</li>';
+  }).join("") || (grounded
+    ? '<li class="row muted">nothing in this graph relates to ' + escapeHtml(focus) + '.</li>'
+    : '<li class="row muted">no edges in this graph.</li>');
+}
+
+export function hintsHtml(hints) {
+  return hints.map(function (h) {
+    return '<button class="hint" data-q="' + escapeHtml(h.text) + '" title="' + escapeHtml(h.rationale) + '">'
+      + escapeHtml(h.text) + '</button>';
+  }).join("") || '<span class="muted">nothing to suggest for this graph.</span>';
+}
+
+export function turnHtml(role, text) {
+  return '<span class="who">' + (role === "you" ? "you" : "tmct") + '</span><span class="said">' + escapeHtml(text) + '</span>';
+}
+
+export function chatEmptyStateHtml(hasEngine) {
+  return hasEngine
+    ? '<p class="chat-empty-head">Ask the graph, or ask it anything</p>'
+      + '<p>Ask about the code graph on the left, or about anything its general knowledge covers, like “what is a queue”.</p>'
+      + '<p class="chat-empty-hint">Try one of the questions below, or type your own.</p>'
+    : '<p class="chat-empty-head">Static view</p>'
+      + '<p>This page shows a fixed snapshot of the graph. The live chat is not available here.</p>';
+}
+
+export function mbText(n) { return (n / 1048576).toFixed(1); }
+
+/** How many of the seed's own individuals are facts — the general-knowledge
+ *  half of the fact-total pill. */
+export function seedFactsFromPayload(payload) {
+  return (payload.individuals || []).filter(function (i) { return i.class === "Fact"; }).length;
+}
+
+export function seedLoadingNote(loadedBytes, totalBytes) {
+  return "loading general knowledge… " + mbText(loadedBytes) + (totalBytes ? " of " + mbText(totalBytes) : "") + " MB";
+}
+
+/** One retry with a cache-busting query param, fetch side only: a CDN edge
+ *  can serve a corrupted or truncated precompressed response (a transient
+ *  bad cache entry, not a code defect — real bytes decompress fine, and the
+ *  same URL fetched moments later is clean), and JSON.parse throwing is the
+ *  only signal of that. `fetcher` is `fetchWithProgress` (or a stand-in for
+ *  a test); `baseUrl` already carries the build's own content-hash query
+ *  string, if any, so the bust param joins with `&` or `?` accordingly. */
+export async function fetchSeedPayloadWithRetry(fetcher, baseUrl, seedQuery, onProgress) {
+  var lastErr = null;
+  for (var attempt = 1; attempt <= 2; attempt++) {
+    try {
+      var bust = attempt === 1 ? "" : (seedQuery ? "&" : "?") + "retry=1";
+      var seedBlob = await fetcher(baseUrl + seedQuery + bust, onProgress);
+      var text = await seedBlob.text();
+      return JSON.parse(text); // throwing here is the corrupted/truncated-response retry signal
+    } catch (e) {
+      lastErr = e;
+    }
+  }
+  throw lastErr;
+}
+
 const CLIENT_JS = String.raw`
 (function () {
   var DATA = window.__CODE_EXPLORER__;
@@ -126,13 +227,17 @@ const CLIENT_JS = String.raw`
   };
   var session = null;
 
-  var esc = ${escapeHtml.toString()};
+  var escapeHtml = ${escapeHtml.toString()};
+  var rowKey = ${rowKey.toString()};
+  var statsSummaryLine = ${statsSummaryLine.toString()};
+  var factTotalText = ${factTotalText.toString()};
+  var focusRowsHtml = ${focusRowsHtml.toString()};
+  var hintsHtml = ${hintsHtml.toString()};
+  var turnHtml = ${turnHtml.toString()};
+  var chatEmptyStateHtml = ${chatEmptyStateHtml.toString()};
 
   function renderStats(data) {
-    var s = data.ledger.stats;
-    var parts = [s.individuals + " individuals", s.edges + " edges"];
-    var cls = s.classes.slice(0, 4).map(function (c) { return c[1] + " " + c[0]; });
-    els.stats.textContent = parts.concat(cls).join("  ·  ");
+    els.stats.textContent = statsSummaryLine(data.ledger.stats);
     renderFactTotal(data);
   }
 
@@ -141,7 +246,7 @@ const CLIENT_JS = String.raw`
   function renderFactTotal(data) {
     if (!els.factTotal) return;
     var edges = (data && data.ledger && data.ledger.stats && data.ledger.stats.edges) || 0;
-    els.factTotal.textContent = (edges + seedState.facts).toLocaleString();
+    els.factTotal.textContent = factTotalText(edges, seedState.facts);
   }
 
   // "What relates to the focus", put to the engine. askRelatedFacts asks
@@ -159,41 +264,19 @@ const CLIENT_JS = String.raw`
     }
   }
 
-  function rowKey(r) { return JSON.stringify([r.s, r.kind, r.o]); }
-
+  // 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. Whatever the
+  // neighbourhood did not already name follows, in degree order: a bulk view
+  // of the rest of the graph, which is a fold and not a question.
   function renderFocusRows(data, related) {
-    var focus = data.focus;
-    var rows = data.ledger.rows;
-    // 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" : "";
-      return '<li class="row' + hot + '">'
-        + '<button class="term" data-term="' + esc(r.s) + '">' + esc(r.s) + '</button> '
-        + '<span class="verb">' + esc(r.phrase) + '</span> '
-        + '<button class="term" data-term="' + esc(r.o) + '">' + esc(r.o) + '</button>'
-        + '</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 || "—";
+    els.ledger.innerHTML = focusRowsHtml(data, related);
+    els.focus.textContent = data.focus || "—";
   }
 
   function renderHints(data) {
-    els.hints.innerHTML = data.hints.map(function (h) {
-      return '<button class="hint" data-q="' + esc(h.text) + '" title="' + esc(h.rationale) + '">'
-        + esc(h.text) + '</button>';
-    }).join("") || '<span class="muted">nothing to suggest for this graph.</span>';
+    els.hints.innerHTML = hintsHtml(data.hints);
   }
 
   function focusOn(term) {
@@ -218,7 +301,7 @@ const CLIENT_JS = String.raw`
     clearEmptyState();
     var div = document.createElement("div");
     div.className = "turn turn-" + role;
-    div.innerHTML = '<span class="who">' + (role === "you" ? "you" : "tmct") + '</span><span class="said">' + esc(text) + '</span>';
+    div.innerHTML = turnHtml(role, text);
     els.log.appendChild(div);
     els.log.scrollTop = els.log.scrollHeight;
   }
@@ -227,12 +310,7 @@ const CLIENT_JS = String.raw`
     var div = document.createElement("div");
     div.className = "chat-empty";
     div.id = "chat-empty";
-    div.innerHTML = api
-      ? '<p class="chat-empty-head">Ask the graph, or ask it anything</p>'
-        + '<p>Ask about the code graph on the left, or about anything its general knowledge covers, like “what is a queue”.</p>'
-        + '<p class="chat-empty-hint">Try one of the questions below, or type your own.</p>'
-      : '<p class="chat-empty-head">Static view</p>'
-        + '<p>This page shows a fixed snapshot of the graph. The live chat is not available here.</p>';
+    div.innerHTML = chatEmptyStateHtml(Boolean(api));
     els.log.appendChild(div);
   }
 
@@ -248,25 +326,34 @@ const CLIENT_JS = String.raw`
   var SEED_QUERY = DATA.seedStamp ? "?b=" + DATA.seedStamp : "";
   var seedState = { status: api ? "loading" : "absent", payload: null, facts: 0 };
   function seedNote(text) { if (els.seedStatus) els.seedStatus.textContent = text; }
-  function mbText(n) { return (n / 1048576).toFixed(1); }
 
+  var mbText = ${mbText.toString()};
   var fetchWithProgress = ${fetchWithProgress.toString()};
+  var seedFactsFromPayload = ${seedFactsFromPayload.toString()};
+  var seedLoadingNote = ${seedLoadingNote.toString()};
+  var fetchSeedPayloadWithRetry = ${fetchSeedPayloadWithRetry.toString()};
+
+  // The desktop shell's readSeed() reads off local disk, not a CDN, so it
+  // keeps its single attempt in loadSeed() below; only this fetch path retries.
+  function fetchSeedPayload() {
+    return fetchSeedPayloadWithRetry(fetchWithProgress, "./chat-seed.json", SEED_QUERY, function (loaded, total) {
+      seedNote(seedLoadingNote(loaded, total));
+    });
+  }
 
   async function loadSeed() {
     try {
-      var text = null;
+      var payload = null;
       if (window.tmctDesktop && typeof window.tmctDesktop.readSeed === "function") {
         seedNote("loading general knowledge…");
-        text = await window.tmctDesktop.readSeed();
+        var text = await window.tmctDesktop.readSeed();
+        if (text) payload = JSON.parse(text);
       } else {
-        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();
+        payload = await fetchSeedPayload();
       }
-      if (text) {
-        seedState.payload = JSON.parse(text);
-        seedState.facts = (seedState.payload.individuals || []).filter(function (i) { return i.class === "Fact"; }).length;
+      if (payload) {
+        seedState.payload = payload;
+        seedState.facts = seedFactsFromPayload(seedState.payload);
         seedState.status = "ready";
         seedNote("general knowledge: " + seedState.facts + " facts");
         renderFactTotal(DATA);

package/src/services/index.mjs

@@ -39,7 +39,7 @@ export { relationKind, impactClosure } from "../domain/codegraph.mjs";
 export { createGraphService } from "../adapters/providers/graph-service.mjs";
 
 // Tool dispatch (slash-commands and CLI tool calls route through here).
-export { dispatchTool } from "../tools/server.mjs";
+export { dispatchTool, dispatchToolStructured } from "../tools/server.mjs";
 
 // Conversational memory — tmct's OWN OWL-labelled graph under
 // .tmct/memory/, distinct from any provider-supplied code graph.

package/src/services/ingest-viz.mjs

@@ -113,7 +113,8 @@ ${THEME_TOKENS_CSS}
   .browse { font-family: ${MONO_STACK}; font-size: .68rem; color: var(--muted); border: 1px solid var(--line); border-radius: 4px; padding: .16rem .55rem; background: var(--card); }
   .browse:hover { color: var(--ink); }
 
-  /* right: the canonical facts, on the soft panel background. */
+  /* right: the canonical facts, on the soft panel background, with the ask
+     dock pinned under them — you read what landed, then question it in place. */
   .outPane { background: var(--card); }
   #facts { flex: 1 1 auto; overflow-y: auto; padding: .6rem .9rem 1rem; font-family: ${MONO_STACK}; font-size: .8rem; }
   #facts .fact { display: grid; grid-template-columns: 1fr auto 1fr; gap: .5rem; align-items: baseline; padding: .3rem 0; border-bottom: 1px solid var(--line); }
@@ -123,6 +124,24 @@ ${THEME_TOKENS_CSS}
   #facts .fact .prov { grid-column: 1 / -1; color: var(--muted); font-size: .66rem; }
   #facts .empty { color: var(--muted); text-align: center; max-width: 24rem; line-height: 1.6; margin: 3rem auto 0; }
 
+  /* the ask dock: one line in, one answer out, against the graph this session
+     projects from what it has ingested. */
+  .askDock { flex: 0 0 auto; border-top: 1px solid var(--line); display: flex; flex-direction: column; }
+  #askLog { max-height: 11rem; overflow-y: auto; padding: .5rem .9rem 0; font-family: ${MONO_STACK}; font-size: .78rem; }
+  #askLog:empty { display: none; }
+  .askLine { margin: 0 0 .35rem; white-space: pre-wrap; word-break: break-word; }
+  .askLine.q { color: var(--muted); }
+  .askLine.q::before { content: "> "; }
+  .askLine.a { color: var(--ink); }
+  .askLine.detail { color: var(--muted); font-size: .68rem; }
+  .askLine.miss { color: var(--muted); font-style: italic; }
+  .askRow { display: flex; align-items: center; gap: .5rem; padding: .5rem .9rem .6rem; }
+  #askq { flex: 1 1 auto; min-width: 0; border: 1px solid var(--line); border-radius: 6px; background: var(--bg); color: var(--ink); font-family: ${MONO_STACK}; font-size: .78rem; padding: .35rem .6rem; }
+  #askq::placeholder { color: var(--muted); }
+  #askq:disabled { opacity: .55; }
+  .askGo { font-family: ${MONO_STACK}; font-size: .72rem; color: var(--ink); border: 1px solid var(--line); border-radius: 6px; padding: .32rem .85rem; background: var(--card); }
+  .askGo:disabled { opacity: .45; cursor: default; }
+
   .actions { flex: 0 0 auto; display: flex; align-items: center; gap: .6rem; padding: .6rem 1.1rem; border-top: 1px solid var(--line); flex-wrap: wrap; }
   .actions .btn { font-family: ${MONO_STACK}; font-size: .74rem; color: var(--ink); border: 1px solid var(--line); border-radius: 6px; padding: .35rem .9rem; background: var(--card); }
   .actions .btn.primary { background: var(--ink); color: var(--bg); border-color: var(--ink); }
@@ -203,6 +222,14 @@ ${THEME_TOKENS_CSS}
           <span id="factCount" class="mono"></span>
         </div>
         <div id="facts"><p class="empty">Nothing ingested yet. The facts it grounds will appear here as it reads.</p></div>
+        <form class="askDock" id="askForm" autocomplete="off">
+          <div id="askLog" aria-live="polite"></div>
+          <div class="askRow">
+            <input type="text" id="askq" aria-label="Ask about what you have ingested"
+              placeholder="ask about what you&rsquo;ve ingested&hellip;" disabled>
+            <button type="submit" class="askGo" id="askGo" disabled>ask</button>
+          </div>
+        </form>
       </section>
     </main>
     <div class="actions">
@@ -248,6 +275,10 @@ ${THEME_TOKENS_CSS}
   const fuzzyToggleEl = el("fuzzyToggle");
   const statsPanelEl = el("statsPanel");
   const factPillValueEl = el("factPillValue");
+  const askFormEl = el("askForm");
+  const askInputEl = el("askq");
+  const askGoBtn = el("askGo");
+  const askLogEl = el("askLog");
 
   let session = null;
   let grounded = 0; // facts on show in the right pane, from the CURRENT ingest only
@@ -356,6 +387,81 @@ ${THEME_TOKENS_CSS}
     factsEl.scrollTop = factsEl.scrollHeight;
   }
 
+  // ---- the ask dock: one question, put to what this session has ingested ---
+  // Two real routes, tried in order, and neither one guesses. window.tmct.ask
+  // puts the question to the graph this session projects from its OWN grounded
+  // rows (ingest-facts.mjs), which is what answers a listing — "list dogs"
+  // reads the beagles actually on record. On a miss, window.tmct.turn runs the
+  // full chat turn engine over the same store, which reads a term's own facts
+  // back ("what is a beagle") and takes a taught line ("remember: …") the
+  // graph shape has no lane for. Both missing is the honest wall, and the note
+  // there names the kinds this memory really holds instead of inventing an
+  // example question.
+  let asking = false;
+
+  function updateAskEnabled() {
+    const ready = Boolean(session) && !asking;
+    askInputEl.disabled = !ready;
+    askGoBtn.disabled = !ready || !askInputEl.value.trim();
+  }
+
+  function addAskLine(cls, text) {
+    const line = document.createElement("div");
+    line.className = "askLine " + cls;
+    line.textContent = text;
+    askLogEl.appendChild(line);
+    askLogEl.scrollTop = askLogEl.scrollHeight;
+  }
+
+  // The engine writes its answer first and its reasoning trailers ("Goal
+  // (inferred): …", "Canonical: …") after a blank line. The answer leads; the
+  // trailers stay, quieter, because they are how a reader audits it.
+  function addAskAnswer(answer) {
+    const blocks = String(answer).split(/\\n{2,}/).map(function (b) { return b.trim(); }).filter(Boolean);
+    if (!blocks.length) return;
+    addAskLine("a", blocks[0]);
+    for (const block of blocks.slice(1)) addAskLine("detail", block);
+  }
+
+  function askMissNote() {
+    const kinds = session && session.askableClasses ? session.askableClasses() : [];
+    if (!kinds.length) return "Nothing of your own is in this session's memory yet. Ingest some text first.";
+    return "I can't ground that in what you've ingested. The kinds it holds: " + kinds.slice(0, 8).join(", ") + ".";
+  }
+
+  askInputEl.addEventListener("input", updateAskEnabled);
+  askFormEl.addEventListener("submit", async (e) => {
+    e.preventDefault();
+    const q = askInputEl.value.trim();
+    if (!q || asking || !session) return;
+    asking = true;
+    askInputEl.value = "";
+    updateAskEnabled();
+    addAskLine("q", q);
+    try {
+      let asked = null;
+      try { asked = await window.tmct.ask(q); } catch { asked = null; }
+      if (asked && asked.answer && !asked.miss) { addAskAnswer(asked.answer); return; }
+      let turned = null;
+      try { turned = await window.tmct.turn(q); } catch { turned = null; }
+      if (turned && turned.answer && !(turned.record && turned.record.miss)) {
+        addAskAnswer(turned.answer);
+        // A taught line writes to the same store an ingest does, so it earns
+        // the same debounced save and the same panel refresh.
+        if (turned.record && turned.record.via === "assert") {
+          scheduleSave();
+          await renderStatsPanel();
+        }
+        return;
+      }
+      addAskLine("miss", askMissNote());
+    } finally {
+      asking = false;
+      updateAskEnabled();
+      askInputEl.focus();
+    }
+  });
+
   // ---- memory stats: the docked panel, same convention as chat.html --------
   async function renderStatsPanel(stats) {
     if (!stats) {
@@ -402,16 +508,28 @@ ${THEME_TOKENS_CSS}
   // The one branch this page's seed choice makes: checked, fetch and parse
   // the same chat-seed.json chat.html embeds; unchecked, skip the request
   // outright and stay on the previous empty-store fast path.
+  //
+  // One retry with a cache-busting query param: a CDN edge can serve a
+  // corrupted or truncated precompressed response (a transient bad cache
+  // entry, not a code defect — real bytes decompress fine, and the same URL
+  // fetched moments later is clean), and JSON.parse throwing is the only
+  // signal of that. The bust param forces a fresh fetch past that one entry.
   async function fetchSeedIfWanted() {
     if (!seedToggleEl.checked) { seedPayload = null; seedFacts = 0; return; }
-    try {
-      const blob = await fetchWithProgress("./chat-seed.json" + SEED_QUERY, (loaded, total) => noteProgress("seed", loaded, total));
-      seedPayload = JSON.parse(await blob.text());
-      seedFacts = (seedPayload.individuals || []).filter((i) => i.class === "Fact").length;
-    } catch (err) {
-      seedPayload = null;
-      seedFacts = 0;
-      console.warn("tmct ingest: chat-seed.json unavailable — starting unseeded", err);
+    for (let attempt = 1; attempt <= 2; attempt++) {
+      try {
+        const bust = attempt === 1 ? "" : (SEED_QUERY ? "&" : "?") + "retry=1";
+        const blob = await fetchWithProgress("./chat-seed.json" + SEED_QUERY + bust, (loaded, total) => noteProgress("seed", loaded, total));
+        seedPayload = JSON.parse(await blob.text());
+        seedFacts = (seedPayload.individuals || []).filter((i) => i.class === "Fact").length;
+        return;
+      } catch (err) {
+        if (attempt === 2) {
+          seedPayload = null;
+          seedFacts = 0;
+          console.warn("tmct ingest: chat-seed.json unavailable — starting unseeded", err);
+        }
+      }
     }
   }
   const cloneMemoryPayload = ${cloneMemoryPayload.toString()};
@@ -469,7 +587,9 @@ ${THEME_TOKENS_CSS}
     if (persist) await persist.clear();
     session = await newSession();
     clearFactsPane();
+    askLogEl.textContent = "";
     updateIngestEnabled();
+    updateAskEnabled();
     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);
@@ -488,10 +608,12 @@ ${THEME_TOKENS_CSS}
     saveTimer = null;
     session = await newSession();
     clearFactsPane();
+    askLogEl.textContent = "";
     const stats = await window.tmct.page.memoryStats(session.memoryDir);
     statusEl.textContent = statsSummaryLine(stats, bandLabelFor) + ". Ready.";
     await renderStatsPanel(stats);
     updateIngestEnabled();
+    updateAskEnabled();
     sourceEl.focus();
   });
 
@@ -516,6 +638,7 @@ ${THEME_TOKENS_CSS}
       : await newSession();
     setMode(false);
     updateIngestEnabled();
+    updateAskEnabled();
     const stats = await window.tmct.page.memoryStats(session.memoryDir);
     const winkPart = winkStatus === "loaded"
       ? "wink-nlp: loaded"
@@ -609,6 +732,7 @@ ${THEME_TOKENS_CSS}
     sourceTag = "pasted text";
     srcLabel.textContent = modeDocBtn.getAttribute("aria-pressed") === "true" ? "drop or browse for a file" : "pasted text";
     clearFactsPane();
+    askLogEl.textContent = "";
     statusEl.textContent = "cleared";
     updateIngestEnabled();
     sourceEl.focus();
@@ -618,6 +742,7 @@ ${THEME_TOKENS_CSS}
     console.error("tmct ingest failed to boot", err);
     statusEl.textContent = "the ingest page failed to start (" + (err && err.message ? err.message : err) + ")";
   });
+  window.tmct.ready = window.tmctIngestReady;
 })();
 </script>
 </body>

package/src/services/ledger-viz.mjs

@@ -145,13 +145,16 @@ const trustTierFor = (trust) => (trust >= 0.85 ? 3 : trust >= 0.5 ? 2 : 1);
  *  build-demo-site.mjs consumes directly). Returns
  *  { rows, terms, edges, focus, contradictions, worthALook, payload, meta }. */
 export function computeLedgerDataFromPayload(payload, { focus, term, rowLimit = LEDGER_ROW_LIMIT_DEFAULT } = {}) {
-  const individuals = payload?.individuals || [];
-  const indById = new Map(individuals.map((i) => [i?.id, i]));
   const factRows = readFactRows(payload);
 
   const rows = factRows.map((r) => {
-    const ind = indById.get(r.id);
-    const createdAt = (ind?.attributes || []).find((a) => a?.key === "createdAt")?.value || "";
+    // A row is now a GROUP of one-or-more per-source assertion records
+    // (PLAN_FACT.md's re-key), so there is no single individual to join
+    // against by r.id any more — r.id is the group's own id, distinct from
+    // every member record's id. The newest assertion's own createdAt is what
+    // "when was this learned" means for a row the ledger already sorts
+    // newest-first.
+    const createdAt = (r.assertions || []).reduce((newest, a) => (a.createdAt > newest ? a.createdAt : newest), "");
     return {
       id: r.id, s: r.subject, p: r.predicate, o: r.object,
       phrase: phraseFor(r.predicate),

package/src/services/memory-panel-viz.mjs

@@ -75,12 +75,17 @@ export async function clearSiteAssetCaches() {
 
 /** Fetch `url` reading the body as a stream, reporting (loadedBytes,
  *  totalBytes) after every chunk — total is 0 when the response carries no
- *  Content-Length. Resolves to a Blob of the whole body. Falls back to a
- *  single-shot blob() read when the runtime has no streaming body reader. */
+ *  Content-Length, OR when Content-Encoding is set: the stream this function
+ *  reads is always the DECOMPRESSED body (the browser decompresses before
+ *  handing it to a reader), but Content-Length names the compressed wire
+ *  size — reporting that as "total" against decompressed "loaded" bytes
+ *  makes progress read as over 100% almost immediately. Resolves to a Blob
+ *  of the whole body. Falls back to a single-shot blob() read when the
+ *  runtime has no streaming body reader. */
 export async function fetchWithProgress(url, onProgress) {
   const res = await fetch(url);
   if (!res.ok) throw new Error("HTTP " + res.status);
-  const total = Number(res.headers.get("content-length")) || 0;
+  const total = res.headers.get("content-encoding") ? 0 : Number(res.headers.get("content-length")) || 0;
   if (!res.body || !res.body.getReader) {
     const blob = await res.blob();
     onProgress(blob.size, total || blob.size);

package/src/services/mud-turn.mjs

@@ -55,7 +55,7 @@ import {
   foldWorldState, worldActionRows, runWorldCommand, recordTold, recordExamined,
   recordMassDrain, personKnowledgeLines, objectClassChain, diggableDirections,
   isOutOfPlay, outOfPlayReasonOf, outOfPlayPhrase, massDrainPerTurnOf,
-  parseSnapshotSubject,
+  parseSnapshotSubject, characterTestimonyTag,
 } from "./adventure.mjs";
 
 const FOOD_CLASS = "food";
@@ -267,6 +267,9 @@ export async function runMudTurn(character, {
   const opened = await readWorld(memoryDir);
   const room = opened.state.placements.get(character)?.object ?? null;
   const turn = k ?? opened.state.turnCount + 1;
+  // The run this turn belongs to, stamped onto the testimony it writes so a
+  // recast's first turns outrank whatever the replaced run had to say.
+  const epoch = opened.state.epoch;
   const actions = [];
   const notes = [];
   const learnedBefore = knownTopics(opened.rows, opened.state, character);
@@ -300,7 +303,7 @@ export async function runMudTurn(character, {
     notes.push(`MUD — ${step}: ${reason}`);
   };
 
-  await investigateRoom({ character, turn, room, memoryDir, cache, actions, notes, runCommand, recordSkip });
+  await investigateRoom({ character, turn, epoch, room, memoryDir, cache, actions, notes, runCommand, recordSkip });
 
   const walked = await readWorld(memoryDir);
   const walkedRoom = walked.state.placements.get(character)?.object ?? room;
@@ -397,7 +400,7 @@ async function exploreUnvisited({ character, memoryDir, runCommand, recordSkip }
  *  same empty greeting every turn for the rest of the run. The talk and the
  *  examine write testimony, which never folds into the playable state; only
  *  the manipulation touches the world. */
-async function investigateRoom({ character, turn, room, memoryDir, cache, recordSkip, runCommand, actions, notes }) {
+async function investigateRoom({ character, turn, epoch = 0, room, memoryDir, cache, recordSkip, runCommand, actions, notes }) {
   const { rows, state } = await readWorld(memoryDir);
   const roomMates = castIn(state, room, character);
   const alreadyKnown = knownTopics(rows, state, character);
@@ -420,7 +423,7 @@ async function investigateRoom({ character, turn, room, memoryDir, cache, record
     // drops out of worthSpeakingTo, and drops back in the moment either side
     // learns a food the other has not heard of.
     if (!alreadyKnown.has(teller)) {
-      await recordExamined(memoryDir, { observer: character, thing: teller, k: turn, cache });
+      await recordExamined(memoryDir, { observer: character, thing: teller, k: turn, epoch, cache });
       alreadyKnown.add(teller);
     }
     if (!told) {
@@ -433,13 +436,13 @@ async function investigateRoom({ character, turn, room, memoryDir, cache, record
       });
       notes.push(`MUD — talk: ${character} greeted ${teller}; ${teller} knows of no food to share`);
     } else {
-      await recordTold(memoryDir, { asker: character, teller, thing: told, k: turn, cache });
+      await recordTold(memoryDir, { asker: character, teller, thing: told, k: turn, epoch, cache });
       alreadyKnown.add(told);
       actions.push({
         step: "investigate", kind: "ask", teller, thing: told, miss: false,
         text: `the ${character} asks the ${teller} about food, and hears about the ${told}.`,
       });
-      notes.push(`MUD — ask: ${teller} told ${character} about ${told}; written as mud:${teller}:turn${turn}`);
+      notes.push(`MUD — ask: ${teller} told ${character} about ${told}; written as ${characterTestimonyTag(teller, turn, { epoch })}`);
     }
   }
 
@@ -452,13 +455,13 @@ async function investigateRoom({ character, turn, room, memoryDir, cache, record
   if (!examined) {
     recordSkip("investigate", "nothing unexamined stands here", "");
   } else {
-    await recordExamined(memoryDir, { observer: character, thing: examined, k: turn, cache });
+    await recordExamined(memoryDir, { observer: character, thing: examined, k: turn, epoch, cache });
     alreadyKnown.add(examined);
     actions.push({
       step: "investigate", kind: "examine", thing: examined, miss: false,
       text: `the ${character} examines the ${examined}.`,
     });
-    notes.push(`MUD — examine: ${character} looked at ${examined}; written as mud:${character}:turn${turn}`);
+    notes.push(`MUD — examine: ${character} looked at ${examined}; written as ${characterTestimonyTag(character, turn, { epoch })}`);
   }
 
   await manipulateSomething({ character, turn, room, memoryDir, runCommand, recordSkip });