@polycode-projects/the-mechanical-code-talker 2.10.3 → 2.10.5

package/src/services/sessions.mjs

@@ -1,7 +1,7 @@
 // sessions.mjs — chat sessions as first-class temporal graph data, like commits.
 //
 // A `tmct chat` session leaves two artifacts under the target repo:
-//   .tmct/session-<uuidv7>.log            — the human-readable transcript (chat.mjs)
+//   .tmct/session-<uuidv7>.md              — the human-readable transcript (chat-session.mjs, session-log-format.mjs)
 //   .tmct/sessions/session-<uuidv7>.jsonl — the STRUCTURED sidecar this module owns:
 //     {"type":"session", id, started, repo, tmctVersion}        (header line)
 //     {"type":"turn", ts, query, via, resolvedIds, answeredIds, miss}  (one per turn, flushed)
@@ -207,7 +207,7 @@ async function recordSessionMemory(graphFile, record, repoDirOverride = null) {
 
   let answers = new Map();
   try {
-    answers = parseSessionLog(await readFile(join(repoDir, ".tmct", `session-${record.id}.log`), "utf8"));
+    answers = parseSessionLog(await readFile(join(repoDir, ".tmct", `session-${record.id}.md`), "utf8"));
   } catch { /* no transcript (direct API callers) — record the requests alone */ }
 
   const utterances = [];
@@ -294,38 +294,72 @@ export function parseSessionJsonl(text) {
   return { id: String(header.id), started: String(header.started || ""), ended, turns };
 }
 
-// A transcript turn opens with an ISO-8601 ms timestamp line followed by the
-// echoed "> <query>" line (chat.mjs's logLines shape).
-const LOG_TS_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+// A transcript turn heading (session-log-format.mjs's sessionLogTurnMarkdown):
+// "### HH:MM:SS.mmm · turn N" — time of day only, no calendar date (the date
+// lives once, in the header byline). The header byline itself carries that
+// date: "*YYYY-MM-DD · started HH:MM:SS.mmm[ · repo ...]*".
+const MD_TURN_HEADING_RE = /^### (\d{2}:\d{2}:\d{2}\.\d{3}) · turn \d+$/;
+const MD_BYLINE_DATE_RE = /^\*(\d{4}-\d{2}-\d{2}) ·/;
 
 export { turnKey };
 
+/** The calendar date one UTC day after `dateStr` ("YYYY-MM-DD") — used to
+ *  carry the transcript's running date forward across a midnight rollover
+ *  (see parseSessionLog below). */
+function nextUtcDate(dateStr) {
+  const d = new Date(`${dateStr}T00:00:00Z`);
+  d.setUTCDate(d.getUTCDate() + 1);
+  return d.toISOString().slice(0, 10);
+}
+
 /**
- * Parse a human-readable session transcript (.tmct/session-<id>.log) into a
+ * Parse a human-readable session transcript (.tmct/session-<id>.md) into a
  * Map of turnKey(ts, query) → answer text. The transcript is the ONLY session
  * artifact that carries the answer PROSE (the structured sidecar records ids,
- * not text),
+ * not text).
+ *
+ * Each turn heading carries only a TIME of day (see MD_TURN_HEADING_RE above)
+ * — the calendar date is read once from the header byline and carried
+ * forward turn to turn, advancing a day whenever a heading's time reads
+ * EARLIER than the turn before it (a midnight rollover on a long session).
+ * The reconstructed `date + "T" + time + "Z"` is then byte-identical to the
+ * full ISO timestamp session-log-format.mjs's writer sliced the time out of,
+ * so it matches the sidecar's own `record.ts` under turnKey exactly.
  */
 export function parseSessionLog(text) {
   const lines = String(text ?? "").split("\n");
   const answers = new Map();
-  let open = null; // { ts, query, answerLines }
-  const close = () => {
-    if (!open) return;
-    while (open.answerLines.length && !open.answerLines.at(-1).trim()) open.answerLines.pop();
-    answers.set(turnKey(open.ts, open.query), open.answerLines.join("\n"));
-    open = null;
-  };
-  for (let i = 0; i < lines.length; i += 1) {
-    if (LOG_TS_RE.test(lines[i]) && lines[i + 1]?.startsWith("> ")) {
-      close();
-      open = { ts: lines[i], query: lines[i + 1].slice(2), answerLines: [] };
-      i += 1;
-    } else if (open) {
-      open.answerLines.push(lines[i]);
+  let date = null;
+  let lastTime = null;
+  let i = 0;
+  while (i < lines.length) {
+    if (date === null) {
+      const dateMatch = lines[i].match(MD_BYLINE_DATE_RE);
+      if (dateMatch) date = dateMatch[1];
+    }
+    const heading = date && lines[i].match(MD_TURN_HEADING_RE);
+    if (heading) {
+      const time = heading[1];
+      if (lastTime !== null && time < lastTime) date = nextUtcDate(date);
+      lastTime = time;
+      let j = i + 1;
+      if (lines[j] === "") j += 1;
+      const queryLine = lines[j];
+      if (queryLine?.startsWith("> ")) {
+        j += 1;
+        if (lines[j] === "") j += 1;
+        if (lines[j] === "```text") {
+          j += 1;
+          const answerLines = [];
+          while (j < lines.length && lines[j] !== "```") { answerLines.push(lines[j]); j += 1; }
+          answers.set(turnKey(`${date}T${time}Z`, queryLine.slice(2)), answerLines.join("\n"));
+          i = j + 1;
+          continue;
+        }
+      }
     }
+    i += 1;
   }
-  close();
   return answers;
 }
 

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

@@ -18,7 +18,7 @@
 import {
   DIRECTION_DELTA, WORLD_NAME, cellId, parseCellId, inBounds, chebyshevDistance, oneStepDirectionBetween,
 } from "../domain/spider-fly-world.mjs";
-import { foldSpiderFlyState, runSpiderFlyTick, startSpiderFlyGame } from "./spider-fly.mjs";
+import { foldSpiderFlyState, runSpiderFlyTick, startSpiderFlyGame, beliefSnapshotFor } from "./spider-fly.mjs";
 import { worldProvenanceTag } from "../domain/worlds-pack.mjs";
 import { getWorldsPackProvider } from "../adapters/corpus/worlds-pack.mjs";
 import { appendFacts, appendRule, loadMemory, readFactRows } from "../adapters/memory/core.mjs";
@@ -66,6 +66,12 @@ const SPIDER_FLY_TOLD_RE = new RegExp(
   "i",
 );
 
+// The observable-facts read: "what does the fly see?" / "what can the
+// spider see?" — a closed vocabulary shape, styled after the other
+// game-lane regexes above, with the same optional numbered suffix
+// (SPIDER_FLY_ADDRESS_LEAD_RE's own "-<n>") for a board past one of a kind.
+const SPIDER_FLY_SEE_RE = /^what (?:does|can) the (spider|fly)(?:-(\d+))?\s+see[.!?\s]*$/i;
+
 const WORLD_OPENING_FALLBACK =
   "a spider waits in its web; a fly drifts in from the edge of the board. Neither is yours to move — watch, or address one by name in chat.";
 
@@ -342,6 +348,48 @@ async function runTickAndRender({ planHolder, memoryDir, cache, toldFacts = [],
   };
 }
 
+// ---- the observable-facts read: "what does the fly see?" -----------------
+
+/** One `[id, cellId | null]` belief entry as a sentence: `"spider-1 is at
+ *  cell-3-4."` when observed/told, `"fly-2 has not been observed."`
+ *  otherwise — the same wording spider-fly-viz.mjs's own click-expand panel
+ *  (observedFactsHtml) renders, so the chat phrasing and the browser panel
+ *  never disagree about what an agent can see. */
+function observedFactSentence(id, believedCell) {
+  return believedCell ? `${id} is at ${believedCell}.` : `${id} has not been observed.`;
+}
+
+/** "what does the fly see?" / "what does the spider see?" rendered as plain
+ *  text: the same beliefSnapshotFor read spider-fly.mjs's own tick loop and
+ *  the browser panel already use, over the CURRENT board state — read-only,
+ *  no tick runs, nothing is written. Candidates are every OTHER live agent
+ *  of either kind; toldFacts is empty (a told position only ever arrives
+ *  fresh alongside a tick — see runToldFactTurn — so there is none standing
+ *  between ticks to read back here). */
+async function spiderFlyBeliefAnswer(match, { memoryDir, gameConfig = DEFAULT_GAME_CONFIG }) {
+  const kind = match[1].toLowerCase();
+  const num = match[2];
+  const rows = readFactRows(await loadMemory(memoryDir));
+  const state = foldSpiderFlyState(rows);
+  const observerId = resolveAgentId(kind, num, state);
+  if (!observerId) return noSuchAgentAnswer(kind, "addressee");
+  const observerCell = parseCellId(state.placements.get(observerId).cell);
+  const candidateIds = [...liveIdsOfKind("spider", state), ...liveIdsOfKind("fly", state)];
+  const visionRadius = kind === "spider"
+    ? gameConfig?.spiderFly?.spiderVisionRadius
+    : gameConfig?.spiderFly?.flyVisionRadius;
+  const belief = beliefSnapshotFor(observerId, observerCell, candidateIds, state, { visionRadius });
+  const entries = Object.entries(belief);
+  const text = entries.length
+    ? `${observerId} sees: ${entries.map(([id, cell]) => observedFactSentence(id, cell)).join(" ")}`
+    : `${observerId} is alone on the board — nothing else to see.`;
+  return {
+    text,
+    lane: "game-inform",
+    note: `SPIDER-FLY — belief snapshot rendered for ${observerId} via beliefSnapshotFor (read-only, no tick run)`,
+  };
+}
+
 /** The addressed teach-frame turn: resolve the addressee and the belief
  *  subject, resolve the told cell, and run ONE tick with that told-fact fed
  *  in. Told-facts are NOT persisted on the session slot across turns — each
@@ -526,6 +574,11 @@ export async function spiderFlyTurn(line, { planHolder, memoryDir, env, cache =
     return runToldFactTurn(told, { planHolder, memoryDir, cache, gameConfig });
   }
 
+  const seeMatch = String(line).trim().match(SPIDER_FLY_SEE_RE);
+  if (seeMatch) {
+    return spiderFlyBeliefAnswer(seeMatch, { memoryDir, gameConfig });
+  }
+
   if (SPIDER_FLY_TICK_RE.test(line)) {
     return runTickAndRender({ planHolder, memoryDir, cache, toldFacts: [], gameConfig });
   }

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

@@ -346,10 +346,10 @@ ${THEME_TOKENS_CSS}
      negative margin equal to this padding, so it reads as one welded unit,
      not a label floating inside a box. */
   .hud, .chat, .tuning { background: var(--chrome-face); border: 1px solid var(--chrome-edge-lo); box-shadow: var(--chrome-shadow-raised); border-radius: 2px; padding: .6rem .75rem; }
-  /* the tuning strip matches the board's own width (not the wider stage-left
-     column it sits in) so the two line up as one visual stack, the same way
-     the board-frame below it is already centered at a fixed width. */
-  .tuning { width: ${BOARD_PX}px; max-width: 100%; margin: 0 auto; box-sizing: border-box; }
+  /* Both the controls strip above the board and the tuning strip below it
+     match the board's own width (not the wider stage-left column they sit
+     in), so all three line up as one visual stack. */
+  .tuning, .controls-panel { width: ${BOARD_PX}px; max-width: 100%; margin: 0 auto; box-sizing: border-box; }
   .hud h2, .chat h2, .tuning h2 {
     font-family: ${MONO_STACK}; font-size: .68rem; letter-spacing: .1em; text-transform: uppercase; font-weight: 600;
     margin: -.6rem -.75rem .5rem; padding: .42rem .75rem;
@@ -447,7 +447,7 @@ ${THEME_TOKENS_CSS}
   .tuning-col.spider input[type="range"]::-moz-range-thumb { border-color: var(--taught); }
   .tuning-col.fly input[type="range"]::-moz-range-thumb { border-color: var(--fly); }
   .tuning-col input:disabled { opacity: .45; }
-  .controls-row { display: flex; align-items: center; gap: .6rem; margin-top: 1rem; flex-wrap: wrap; }
+  .controls-row { display: flex; align-items: center; gap: .6rem; flex-wrap: wrap; }
   /* Chunky keycaps: raised by default, pressed-in on :active — the one place
      this redesign uses interaction (not animation) to sell "physical
      control panel", and it costs nothing under reduced-motion since neither
@@ -461,7 +461,7 @@ ${THEME_TOKENS_CSS}
      page is remembered by. */
   .controls-row .turn { margin-left: auto; font-family: ${MONO_STACK}; font-size: .82rem; letter-spacing: .05em; text-transform: uppercase; font-variant-numeric: tabular-nums; color: var(--chrome-well-ink); background: var(--chrome-well); border: 1px solid var(--chrome-brass); box-shadow: var(--chrome-shadow-inset); border-radius: 2px; padding: .3rem .7rem; }
   .status { font-family: ${MONO_STACK}; font-size: .74rem; color: var(--muted); margin-top: .5rem; padding-left: .5rem; border-left: 2px solid var(--chrome-brass); }
-  body.preview .side, body.preview .controls-row, body.preview .status, body.preview .tuning { display: none; }
+  body.preview .side, body.preview .controls-panel, body.preview .tuning { display: none; }
   body.preview main { padding: 0; max-width: none; }
   body.preview .stage, body.preview .stage-left { display: block; }
   body.preview .board-frame { margin: 0; }
@@ -474,6 +474,21 @@ ${THEME_TOKENS_CSS}
   <h1>Multiple competing planning agents</h1>
   <div class="stage">
     <div class="stage-left">
+    <div class="controls-panel" id="controlsPanel" aria-label="game controls">
+      <div class="controls-row">
+        <button id="resetBtn" type="button" disabled>reset</button>
+        <button id="playBtn" type="button" disabled>&#9654; play</button>
+        <button id="stepBtn" type="button" disabled>step</button>
+        <span class="turn mono" id="turnLabel">turn: 0</span>
+      </div>
+      <div class="status" id="status">loading the engine&hellip;</div>
+    </div>
+    <div class="board-frame" id="boardFrame">
+      <canvas id="board" width="${BOARD_PX}" height="${BOARD_PX}" aria-label="the 10x10 board"></canvas>
+      <canvas id="pov" width="${BOARD_PX}" height="${BOARD_PX}" aria-hidden="true"></canvas>
+      <div class="sprite-layer" id="spriteLayer"></div>
+      <div class="thread-tip" id="threadTip"></div>
+    </div>
     <div class="tuning" id="tuning">
       <h2>live tuning &mdash; mass loss, spawn rate, vision, per class</h2>
       <div class="tuning-grid">
@@ -497,12 +512,6 @@ ${THEME_TOKENS_CSS}
         </div>
       </div>
     </div>
-    <div class="board-frame" id="boardFrame">
-      <canvas id="board" width="${BOARD_PX}" height="${BOARD_PX}" aria-label="the 10x10 board"></canvas>
-      <canvas id="pov" width="${BOARD_PX}" height="${BOARD_PX}" aria-hidden="true"></canvas>
-      <div class="sprite-layer" id="spriteLayer"></div>
-      <div class="thread-tip" id="threadTip"></div>
-    </div>
     </div>
     <aside class="side" aria-label="Chat and agents">
       <div class="chat">
@@ -528,13 +537,6 @@ ${THEME_TOKENS_CSS}
       </div>
     </aside>
   </div>
-  <div class="controls-row">
-    <button id="resetBtn" type="button" disabled>reset</button>
-    <button id="playBtn" type="button" disabled>&#9654; play</button>
-    <button id="stepBtn" type="button" disabled>step</button>
-    <span class="turn mono" id="turnLabel">turn: 0</span>
-  </div>
-  <div class="status" id="status">loading the engine&hellip;</div>
 </main>
 <script>
 const SPIDERFLY = ${gridData};

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

@@ -19,6 +19,7 @@
 import { runTurn, vocabExampleHint } from "../../services/chat.mjs";
 import { createInMemoryStore, normFactTerm, loadMemory, readFactRows } from "../../adapters/memory/core.mjs";
 import { serializeFactsJsonl } from "../../adapters/memory/export-jsonl.mjs";
+import { splitSentencesPreservingPaths } from "../../services/sentences.mjs";
 import { provenanceTagToSource } from "../../domain/memory/trust.mjs";
 import { parseEntities } from "../../domain/codegraph.mjs";
 import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
@@ -68,15 +69,18 @@ export function createChatSession({ seedPayload = null, vocabSeeded = false, liv
   let focus = null;
   let last = null;
   let planState = null;
-  let liveReferenceOn = Boolean(liveReference);
+  // Tri-state, like the TUI: false (off), true (rescue on a miss), or
+  // "supplement" (also append a cited read-out under every grounded answer).
+  const normLive = (v) => (v === "supplement" ? "supplement" : Boolean(v));
+  let liveReferenceOn = normLive(liveReference);
 
   return {
     memoryDir,
     sessionId,
     get liveReference() { return liveReferenceOn; },
-    /** The page's toggle seam: flip the live Wikipedia supplement for every
-     *  later turn (the `/wiki on|off` command flips the same state). */
-    setLiveReference(v) { liveReferenceOn = Boolean(v); },
+    /** The page's toggle seam: set the live Wikipedia mode for every later turn
+     *  (the `/wiki on|off|supplement` command sets the same state). */
+    setLiveReference(v) { liveReferenceOn = normLive(v); },
 
     /** One dispatched turn. A throwing runTurn must never kill the session —
      *  the page has no other chance to show this turn's answer. */
@@ -95,7 +99,7 @@ export function createChatSession({ seedPayload = null, vocabSeeded = false, liv
       focus = result.focus;
       last = result.last;
       if ("planState" in result) planState = result.planState;
-      if (typeof result.liveReference === "boolean") liveReferenceOn = result.liveReference;
+      if (typeof result.liveReference === "boolean" || result.liveReference === "supplement") liveReferenceOn = result.liveReference;
       return { answer: result.answer, end: Boolean(result.end), record: result.record ?? null, plan: result.plan ?? null };
     },
   };
@@ -158,4 +162,4 @@ export async function exportFactsJsonl(memoryDir) {
   return serializeFactsJsonl(await loadMemory(memoryDir));
 }
 
-globalThis.tmctChat = { createChatSession, registerWinkModel, registerReferencePackProvider, registerLiveReferenceProvider, normFactTerm, vocabExampleHint, memoryStats, openPersistedStore, exportFactsJsonl };
+globalThis.tmctChat = { createChatSession, registerWinkModel, registerReferencePackProvider, registerLiveReferenceProvider, normFactTerm, vocabExampleHint, memoryStats, openPersistedStore, exportFactsJsonl, splitSentences: splitSentencesPreservingPaths };

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

@@ -0,0 +1,126 @@
+// ingest-browser-entry.mjs — the esbuild entry for the ingest page's engine
+// (public/ingest-browser.bundle.js, built by scripts/build-ingest-bundle.mjs),
+// mirroring ledger-browser-entry.mjs's own createLedgerSession shape.
+//
+// The ingest page turns plain pasted/dropped text into stored facts by
+// running each sentence through the SAME deterministic recognizer the chat
+// teach lane already has (runTurn, src/services/chat.mjs) — no new NLU, no
+// LLM, no guessing, exactly as the `tmct extract` CLI does it
+// (src/services/extract-facts.mjs). A sentence the recognizer turns into a
+// stored assertion is kept; every other sentence is honestly skipped.
+//
+// The recognizer is reached through ONE seam — `groundTextToFacts` — so a
+// wider ingest tier (an optimistic fuzzy-match pass, a canonical/graph-linked
+// output) slots in behind this single function without the page changing.
+// Today the seam is the strict recognizer alone.
+//
+// Gitignored, Pages-demo-site-only output (scripts/build-demo-site.mjs builds
+// it fresh on every deploy, never committed) — the same posture
+// ledger-browser-entry.mjs documents for its own bundle. It carries the full
+// runTurn engine, the same weight class as the chat/ledger bundles, and is
+// never published.
+import { runTurn, vocabExampleHint } from "../../services/chat.mjs";
+import { createInMemoryStore, normFactTerm, loadMemory, readFactRows } from "../../adapters/memory/core.mjs";
+import { serializeFactsJsonl } from "../../adapters/memory/export-jsonl.mjs";
+import { splitSentencesPreservingPaths } from "../../services/sentences.mjs";
+import { touchedFactRows } from "../../domain/memory/touched-facts.mjs";
+import { parseEntities } from "../../domain/codegraph.mjs";
+import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
+import { registerWinkModel } from "../../adapters/wink-model.mjs";
+
+/**
+ * The single recognizer seam. Splits `text` into sentences (wink's own
+ * boundary detection, never a regex), runs each through runTurn against
+ * `memoryDir`, and keeps a sentence only when runTurn's own record calls it a
+ * stored assertion (`record.via === "assert"`, `record.miss` false) that
+ * actually touched a Fact row — the identical keep/skip rule
+ * src/services/extract-facts.mjs's own runSentence holds.
+ *
+ * `onFact(fact)` (optional) is awaited after each grounded row so the page can
+ * render the canonical facts LIVE as they land, one at a time.
+ *
+ * Returns { sentences, recognized, skipped, facts } — `facts` an array of
+ * { subject, predicate, object, provenance, quantifier, sentence } in the same
+ * canonical shape `tmct extract` and the JSONL exporter emit.
+ *
+ * A wider ingest tier plugs in HERE, behind this one function: the page calls
+ * it and nothing else.
+ */
+export async function groundTextToFacts(text, { memoryDir, sessionId, graph, lexicon, vocabHint, onFact = null } = {}) {
+  const sentences = splitSentencesPreservingPaths(text);
+  const facts = [];
+  let focus = null;
+  let last = null;
+  let planState = null;
+  let recognized = 0;
+
+  for (const sentence of sentences) {
+    const before = readFactRows(await loadMemory(memoryDir));
+    let record;
+    try {
+      const result = await runTurn(sentence, {
+        config: null, source: null, graph, focus, last, memoryDir, sessionId,
+        env: {}, lexicon, vocabHint, planState,
+      });
+      focus = result.focus;
+      last = result.last;
+      if ("planState" in result) planState = result.planState;
+      record = result.record;
+    } catch {
+      continue; // a throwing sentence is a skip, never a page-killer
+    }
+    if (record?.via !== "assert" || record?.miss) continue;
+    const rows = touchedFactRows(before, readFactRows(await loadMemory(memoryDir)));
+    if (!rows.length) continue; // a Rule teach touches no Fact row — honest skip
+    recognized += 1;
+    for (const row of rows) {
+      const fact = {
+        subject: row.subject, predicate: row.predicate, object: row.object,
+        provenance: row.provenance || "", quantifier: row.quantifier || "", sentence,
+      };
+      facts.push(fact);
+      if (onFact) await onFact(fact);
+    }
+  }
+
+  return { sentences: sentences.length, recognized, skipped: sentences.length - recognized, facts };
+}
+
+/**
+ * A browser ingest session over the real turn engine — a fresh in-memory
+ * Backend-B store, so facts grounded through the page extend one real graph
+ * the page can then export. `seedPayload` (optional) pre-loads a graph the
+ * recognizer can recall and link against.
+ *
+ * Returns { memoryDir, sessionId, ingest }. `ingest(text, { onFact })` is the
+ * one call the page makes; it drives groundTextToFacts against this session's
+ * store and returns its { sentences, recognized, skipped, facts } summary.
+ */
+export function createIngestSession({ seedPayload = null, vocabSeeded = false } = {}) {
+  const memoryDir = createInMemoryStore();
+  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());
+
+  return {
+    memoryDir,
+    sessionId,
+    ingest(text, { onFact = null } = {}) {
+      return groundTextToFacts(text, { memoryDir, sessionId, graph, lexicon, vocabHint, onFact });
+    },
+  };
+}
+
+/**
+ * The session's whole triple store as JSONL — the same
+ * { subject, predicate, object, provenance } shape `tmct extract` and
+ * `tmct memory --export` emit, offered to the page as the canonical download.
+ */
+export async function exportFactsJsonl(memoryDir) {
+  return serializeFactsJsonl(await loadMemory(memoryDir));
+}
+
+globalThis.tmctIngest = { createIngestSession, groundTextToFacts, exportFactsJsonl, registerWinkModel, normFactTerm };

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

@@ -17,7 +17,9 @@
 // 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 { createInMemoryStore, normFactTerm, loadMemory } from "../../adapters/memory/core.mjs";
+import { serializeFactsJsonl } from "../../adapters/memory/export-jsonl.mjs";
+import { splitSentencesPreservingPaths } from "../../services/sentences.mjs";
 import { parseEntities } from "../../domain/codegraph.mjs";
 import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
 import { registerWinkModel } from "../../adapters/wink-model.mjs";
@@ -78,8 +80,19 @@ export function createLedgerSession({ seedPayload = null, vocabSeeded = false }
   };
 }
 
+/** The session's whole triple store as JSONL — the same
+ *  { subject, predicate, object, provenance } shape `tmct extract` and
+ *  `tmct memory --export` emit. The ledger dock's "export facts" control reads
+ *  this and offers it as a download. */
+export async function exportFactsJsonl(memoryDir) {
+  return serializeFactsJsonl(await loadMemory(memoryDir));
+}
+
 // 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 };
+// 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, splitSentences: splitSentencesPreservingPaths, exportFactsJsonl };