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

package/src/services/adventure.mjs

@@ -174,7 +174,43 @@ async function resumedPosition(memoryDir) {
 
 // ---- the world-state fold ----------------------------------------------------
 
-const SNAPSHOT_RE = /^(.+)@turn(\d+)$/;
+// A snapshot subject is `base@turnN`, or `base@epochE@turnN` once a recast has
+// moved the world past epoch 0 — the fold below reads both, and epoch-0 writes
+// keep the bare form so an unrecast store never changes shape.
+const SNAPSHOT_RE = /^(.+?)@(?:epoch(\d+)@)?turn(\d+)$/;
+
+/** Which run of the world a store is on. Recasting a shared world (mud.html's
+ *  RESET, a slider, the scenario dropdown) reopens the same deterministic
+ *  instance ids over a fresh store while peers may still hold the old run's
+ *  snapshots — this marker is how every reader agrees the world has started
+ *  over. It is an ordinary add-only fact: each recast appends a larger value,
+ *  the fold takes the max, and merging two peers' stores converges because max
+ *  is order-free. */
+export const WORLD_EPOCH_PREDICATE = "mgx:world-epoch";
+const WORLD_EPOCH_SUBJECT = "world";
+
+/** The bare triple a recast writes to move the world onto `epoch`. The caller
+ *  supplies provenance the same way it does for the seed facts, so the marker
+ *  travels (and folds) as a world row. */
+export function worldEpochFact(epoch) {
+  return { subject: WORLD_EPOCH_SUBJECT, predicate: WORLD_EPOCH_PREDICATE, object: String(epoch) };
+}
+
+/** `{ base, epoch, turn }` for a snapshot subject, or null for a base subject.
+ *  The one parser every reader outside this file should use — a local
+ *  `@turn(\d+)$` regex reads an epoch-stamped subject's base as
+ *  "mole-1@epoch2", which matches no character. */
+export function parseSnapshotSubject(subject) {
+  const m = SNAPSHOT_RE.exec(String(subject || ""));
+  return m ? { base: m[1], epoch: m[2] ? Number(m[2]) : 0, turn: Number(m[3]) } : null;
+}
+
+/** The snapshot subject a turn writes: bare `@turnN` while the world is on
+ *  epoch 0 (every store that has never been recast, and every fact written
+ *  before epochs existed), the epoch-stamped form after. */
+export function snapshotSubject(base, turn, epoch = 0) {
+  return epoch > 0 ? `${base}@epoch${epoch}@turn${turn}` : `${base}@turn${turn}`;
+}
 const PLACEMENT_PREDICATES = new Set([
   "mgx:currently-in", "mgx:located-in", "mgx:fixed-in", "mgx:stands-locked-in", "mgx:hidden-in",
 ]);
@@ -242,6 +278,9 @@ const MUD_STATE_PREDICATES = new Set([
   KNOWS_ABOUT_PREDICATE,
   DISPLAY_NAME_PREDICATE,
   "rdf:type",
+  // Which run the world is on IS live world state: a peer that misses the
+  // recast marker keeps folding the old run's snapshots as current.
+  WORLD_EPOCH_PREDICATE,
 ]);
 
 /** Whether `predicate` carries live world state — where a thing stands, what
@@ -269,41 +308,61 @@ export function worldIndividualNames(rows) {
 }
 
 /** Fold fact rows into the CURRENT world state: per subject, the newest
- *  placement (base row = turn 0, @turnN snapshots override), the newest
- *  open/closed state, the newest mass, the exit map, and the turn counter (the
- *  largest @turnN suffix written so far — derived, never stored). Pure. */
+ *  placement (base row = turn 0 of the current epoch, snapshots override), the
+ *  newest open/closed state, the newest mass, the exit map, the turn counter
+ *  (the largest snapshot turn written in the current epoch — derived, never
+ *  stored), and the epoch itself.
+ *
+ *  Rows rank by the (epoch, turn) pair, so a recast can never be outranked by
+ *  the run it replaced: a peer's turn-9 snapshot from before the recast loses
+ *  to a turn-1 snapshot written after it. Base rows carry no stamp of their
+ *  own and rank as turn 0 of the CURRENT epoch — a recast re-seeds the same
+ *  deterministic ids, so the shard's own rows are exactly the state the new
+ *  run starts from. A store with no epoch marker and no stamped snapshot is
+ *  wholly on epoch 0 and folds as it always has. Pure. */
 export function foldWorldState(factRows) {
-  const placements = new Map(); // subject -> { predicate, object, turn }
-  const positions = new Map();  // subject -> { predicate, object, turn }
-  const openness = new Map();   // subject -> { open, turn }
-  const masses = new Map();     // subject -> { value, turn }
+  const rows = factRows || [];
+  let epoch = 0;
+  for (const row of rows) {
+    if (row.predicate === WORLD_EPOCH_PREDICATE) {
+      const marked = Number(row.object);
+      if (Number.isInteger(marked) && marked > epoch) epoch = marked;
+      continue;
+    }
+    const m = SNAPSHOT_RE.exec(row.subject);
+    if (m && m[2] && Number(m[2]) > epoch) epoch = Number(m[2]);
+  }
+  const placements = new Map(); // subject -> { predicate, object, turn, epoch }
+  const positions = new Map();  // subject -> { predicate, object, turn, epoch }
+  const openness = new Map();   // subject -> { open, turn, epoch }
+  const masses = new Map();     // subject -> { value, turn, epoch }
   const exits = new Map();      // room -> Map(direction -> room)
   let turnCount = 0;
-  for (const row of factRows || []) {
+  const outranks = (rowEpoch, turn, prior) =>
+    !prior || rowEpoch > prior.epoch || (rowEpoch === prior.epoch && turn >= prior.turn);
+  for (const row of rows) {
+    if (row.predicate === WORLD_EPOCH_PREDICATE) continue;
     const m = SNAPSHOT_RE.exec(row.subject);
     const base = m ? m[1] : row.subject;
-    const turn = m ? Number(m[2]) : 0;
-    if (m) turnCount = Math.max(turnCount, turn);
+    const rowEpoch = m ? (m[2] ? Number(m[2]) : 0) : epoch;
+    const turn = m ? Number(m[3]) : 0;
+    if (m && rowEpoch === epoch) turnCount = Math.max(turnCount, turn);
     if (PLACEMENT_PREDICATES.has(row.predicate)) {
-      const prior = placements.get(base);
-      if (!prior || turn >= prior.turn) placements.set(base, { predicate: row.predicate, object: row.object, turn });
+      if (outranks(rowEpoch, turn, placements.get(base))) placements.set(base, { predicate: row.predicate, object: row.object, turn, epoch: rowEpoch });
       continue;
     }
     if (POSITION_PREDICATES.has(row.predicate)) {
-      const prior = positions.get(base);
-      if (!prior || turn >= prior.turn) positions.set(base, { predicate: row.predicate, object: row.object, turn });
+      if (outranks(rowEpoch, turn, positions.get(base))) positions.set(base, { predicate: row.predicate, object: row.object, turn, epoch: rowEpoch });
       continue;
     }
     if (row.predicate === OPEN_PREDICATE) {
-      const prior = openness.get(base);
-      if (!prior || turn >= prior.turn) openness.set(base, { open: row.object === "true", turn });
+      if (outranks(rowEpoch, turn, openness.get(base))) openness.set(base, { open: row.object === "true", turn, epoch: rowEpoch });
       continue;
     }
     if (row.predicate === MASS_PREDICATE) {
       const value = Number(row.object);
       if (!Number.isFinite(value)) continue; // masses hold numbers; an unparsable one is no mass at all
-      const prior = masses.get(base);
-      if (!prior || turn >= prior.turn) masses.set(base, { value, turn });
+      if (outranks(rowEpoch, turn, masses.get(base))) masses.set(base, { value, turn, epoch: rowEpoch });
       continue;
     }
     const exit = EXIT_PREDICATE_RE.exec(row.predicate);
@@ -312,7 +371,7 @@ export function foldWorldState(factRows) {
       exits.get(row.subject).set(exit[1], row.object);
     }
   }
-  return { placements, positions, openness, masses, exits, turnCount };
+  return { placements, positions, openness, masses, exits, turnCount, epoch };
 }
 
 /** A subject's CURRENT within-room position, or null. A position goes stale
@@ -323,7 +382,7 @@ export function currentPosition(state, subject) {
   const pos = state.positions.get(subject);
   if (!pos) return null;
   const place = state.placements.get(subject);
-  if (place && pos.turn < place.turn) return null;
+  if (place && (pos.epoch < place.epoch || (pos.epoch === place.epoch && pos.turn < place.turn))) return null;
   return pos;
 }
 
@@ -551,7 +610,7 @@ export function runNpcPass({ rows, state, k, families, playerRoomAfter }) {
     if (!covered) continue;
     const linked = [...(state.exits.get(from)?.values() ?? [])].includes(target);
     if (!linked) continue;
-    writes.push({ subject: `${npc}@turn${k}`, predicate: effectPredicate, object: target });
+    writes.push({ subject: snapshotSubject(npc, k, state.epoch), predicate: effectPredicate, object: target });
     if (playerRoomAfter === target) lines.push(`the ${npc} walks in.`);
     else if (playerRoomAfter === from) lines.push(`the ${npc} leaves.`);
   }
@@ -704,8 +763,8 @@ export async function recordMassDrain(memoryDir, { world, subject, drainPerTurn,
   const left = Math.max(0, Math.round((mass - drainPerTurn) * 100) / 100);
   const k = state.turnCount + 1;
   await writeWorldTurn(memoryDir, world, k, [
-    { subject: `${subject}@turn${k}`, predicate: MASS_PREDICATE, object: String(left) },
-    ...(left > 0 ? [] : [{ subject: `${subject}@turn${k}`, predicate: "mgx:currently-in", object: STARVED_PLACE }]),
+    { subject: snapshotSubject(subject, k, state.epoch), predicate: MASS_PREDICATE, object: String(left) },
+    ...(left > 0 ? [] : [{ subject: snapshotSubject(subject, k, state.epoch), predicate: "mgx:currently-in", object: STARVED_PLACE }]),
   ], cache);
   return { mass: left, starved: left <= 0 };
 }
@@ -724,6 +783,9 @@ export async function recordMassDrain(memoryDir, { world, subject, drainPerTurn,
 // schedule) stay out of the view: hidden means hidden.
 
 const VIEW_EXCLUDED_PREDICATES = new Set([
+  // The recast counter is bookkeeping, not scenery — "World mgx:world-epoch 2"
+  // must never read back as room prose.
+  WORLD_EPOCH_PREDICATE,
   "mgx:hidden-in", "mgx:is-open", "mgx:is-npc", "mgx:is-container",
   // A bare number reads as an untranslated triple in room prose ("Mole-1
   // mgx:hasMass 8"). Mass reaches a player through the verbs that change it.
@@ -1293,7 +1355,7 @@ async function handleGoVerb(ctx) {
   const predator = predatorIn(rows, state, target);
   if (predator) {
     await writeWorldTurn(memoryDir, world, k, [
-      { subject: `${actingSubject}@turn${k}`, predicate: "mgx:currently-in", object: CONSUMED_PLACE },
+      { subject: snapshotSubject(actingSubject, k, state.epoch), predicate: "mgx:currently-in", object: CONSUMED_PLACE },
     ], cache);
     return answer(
       `you go ${cmd.direction} into the ${target} — and the ${predator} is waiting. It eats the ${actingSubject}. That's the end of its run.`,
@@ -1302,7 +1364,7 @@ async function handleGoVerb(ctx) {
     );
   }
   return commit(
-    [{ subject: `${actingSubject}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:currently-in", object: target }],
+    [{ subject: snapshotSubject(actingSubject, k, state.epoch), predicate: familyEffectPredicate(family) ?? "mgx:currently-in", object: target }],
     `you go ${cmd.direction}. Now in the ${target}.`,
     `go — the taught "go" family fired; ${actingSubject} moves ${here} -> ${target}`,
     `move through the world (now in the ${target})`,
@@ -1339,7 +1401,7 @@ async function handleTakeVerb(ctx) {
     return answer(`I don't see a ${object} here.`, noteFor(`take — ${object} isn't visible in the ${here}; declined, hidden things stay hidden`), { miss: true });
   }
   return commit(
-    [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: actingSubject }],
+    [{ subject: snapshotSubject(object, k, state.epoch), predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: actingSubject }],
     `you take the ${object}.`,
     `take — the taught "take" family fired; ${object} is now carried`,
     `carry the ${object}`,
@@ -1353,7 +1415,7 @@ async function handleDropOrGiveVerb(ctx) {
   }
   if (cmd.verb === "drop") {
     return commit(
-      [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: here }],
+      [{ subject: snapshotSubject(object, k, state.epoch), predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: here }],
       `you drop the ${object} in the ${here}.`,
       `drop — the taught "drop" family fired; ${object} rests in the ${here}`,
       `set the ${object} down`,
@@ -1364,7 +1426,7 @@ async function handleDropOrGiveVerb(ctx) {
     return answer(`the ${receiver} isn't here.`, noteFor(`give — ${receiver} isn't one of the cast standing in the ${here}; precondition declined by name`), { miss: true });
   }
   return commit(
-    [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: receiver }],
+    [{ subject: snapshotSubject(object, k, state.epoch), predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: receiver }],
     `you give the ${object} to the ${receiver}.`,
     `give — the taught "give" family fired; the ${receiver} holds the ${object}`,
     `hand the ${object} over`,
@@ -1496,8 +1558,8 @@ async function handleEatVerb(ctx) {
   await recordGone(memoryDir, { observer: actingSubject, thing: object, k, cache });
   return commit(
     [
-      { subject: `${actingSubject}@turn${k}`, predicate: MASS_PREDICATE, object: String(grown) },
-      { subject: `${object}@turn${k}`, predicate: "mgx:located-in", object: CONSUMED_PLACE },
+      { subject: snapshotSubject(actingSubject, k, state.epoch), predicate: MASS_PREDICATE, object: String(grown) },
+      { subject: snapshotSubject(object, k, state.epoch), predicate: "mgx:located-in", object: CONSUMED_PLACE },
     ],
     `you eat the ${object}. It adds ${gained} to your mass, so you weigh ${grown} now.`,
     `eat — the ${object}'s ${gained} mass moves onto ${actingSubject} (now ${grown}) and the ${object} leaves the world`,
@@ -1537,7 +1599,7 @@ async function handlePutVerb(ctx) {
     );
   }
   return commit(
-    [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: container }],
+    [{ subject: snapshotSubject(object, k, state.epoch), predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: container }],
     `you put the ${object} in the ${container}.`,
     `put — the taught "put" family fired; the ${object} now sits in the ${container}`,
     `put the ${object} in the ${container}`,
@@ -1585,7 +1647,7 @@ async function handleContainerVerb(ctx) {
       return answer(text, noteFor(`${cmd.verb} — the taught "${cmd.verb}" family's ${failed.predicate} precondition declined by name`), { miss: true });
     }
     const effSubject = roleBinding(effect.subjectRole, ctx.actingSubject, object, domain);
-    const writeIsOpen = { subject: `${effSubject}@turn${k}`, predicate: effect.predicate, object: effect.value };
+    const writeIsOpen = { subject: snapshotSubject(effSubject, k, state.epoch), predicate: effect.predicate, object: effect.value };
 
     if (cmd.verb === "open") {
       const revealed = [...state.placements]
@@ -1595,7 +1657,7 @@ async function handleContainerVerb(ctx) {
       return commit(
         [
           writeIsOpen,
-          ...revealed.map((thing) => ({ subject: `${thing}@turn${k}`, predicate: "mgx:located-in", object })),
+          ...revealed.map((thing) => ({ subject: snapshotSubject(thing, k, state.epoch), predicate: "mgx:located-in", object })),
         ],
         revealed.length
           ? `you open the ${object} — inside: the ${revealed.join(", the ")}.`
@@ -1646,7 +1708,7 @@ async function handleContainerVerb(ctx) {
     );
   }
   return commit(
-    [{ subject: `${object}@turn${k}`, predicate: "mgx:fixed-in", object: here }],
+    [{ subject: snapshotSubject(object, k, state.epoch), predicate: "mgx:fixed-in", object: here }],
     `you unlock the ${object} with the ${required}.`,
     `unlock — the lock releases; ${object} now stands unlocked (still fixed) in the ${here}`,
     `unlock the ${object}`,

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

@@ -2,7 +2,7 @@
 // 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,
+// (chat-browser.bundle.js's globalThis.tmct, 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
@@ -185,6 +185,18 @@ export function tapeRowFor(direction, message) {
   return { type: type, direction: direction, detail: detail, family: FAMILIES[type] || "link" };
 }
 
+/**
+ * The wire tape's own clock stamp for a message as it arrives —
+ * `HH:MM:SS.mmm`, local time, zero-padded.
+ *
+ * Self-contained (no outer refs), `.toString()`-splice safe.
+ */
+export function tapeClock() {
+  const at = new Date();
+  const pad = (n, width) => String(n).padStart(width, "0");
+  return pad(at.getHours(), 2) + ":" + pad(at.getMinutes(), 2) + ":" + pad(at.getSeconds(), 2) + "." + pad(at.getMilliseconds(), 3);
+}
+
 /**
  * The node list: every peer this graph knows about, each with the node name it
  * chose and the timestamp of the most recent fact it contributed, most
@@ -256,6 +268,24 @@ export function nodeInitials(name) {
   return "??";
 }
 
+/**
+ * How long ago a node's most recent fact landed, relative to `nowMs`: "now"
+ * under 5s, otherwise the whole seconds/minutes/hours/days, coarsest unit
+ * that still reads as one number. `at` null/undefined (a peer with no
+ * activity yet) reads as an em dash rather than a bogus duration.
+ *
+ * Self-contained (no outer refs), `.toString()`-splice safe.
+ */
+export function relativeWhen(at, nowMs) {
+  if (at === null || at === undefined) return "—";
+  const seconds = Math.max(0, Math.round((nowMs - at) / 1000));
+  if (seconds < 5) return "now";
+  if (seconds < 60) return seconds + "s";
+  if (seconds < 3600) return Math.round(seconds / 60) + "m";
+  if (seconds < 86400) return Math.round(seconds / 3600) + "h";
+  return Math.round(seconds / 86400) + "d";
+}
+
 /**
  * The invite link: this page's own address carrying the offer blob, the world
  * id and the world's name. Any query or fragment the current address already
@@ -509,7 +539,7 @@ ${THEME_TOKENS_CSS}
 
   /* 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
+     re-rendered after boot and after every turn from window.tmct'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; }
@@ -524,7 +554,7 @@ ${THEME_TOKENS_CSS}
   .statsPanel .persist-note { color: var(--muted); font-size: .64rem; margin: .4rem 0 0; }
 
   /* the "researched this session" panel: its own section under the memory
-     stats, filled from window.tmctChat.researchedFactRows() plus each
+     stats, filled from window.tmct.page.researchedFactRows() plus each
      settled research turn's own answer text — the passage tmct actually
      read, the article it read it from, and the facts that passage grounded.
      A sibling section, not folded into #statsPanelStats — that div's own
@@ -902,6 +932,8 @@ ${THEME_TOKENS_CSS}
   const nodeInitials = ${nodeInitials.toString()};
   const inviteLinkFor = ${inviteLinkFor.toString()};
   const inviteParamsFrom = ${inviteParamsFrom.toString()};
+  const tapeClock = ${tapeClock.toString()};
+  const relativeWhen = ${relativeWhen.toString()};
   const DIGEST_STRUCTURES = ${digestStructuresJson};
   const el = (id) => document.getElementById(id);
 
@@ -1092,7 +1124,7 @@ ${THEME_TOKENS_CSS}
         })(),
         stallGuard(),
       ]);
-      window.tmctChat.registerWinkModel(() => ({ winkNLP: mod.winkNLP, model: mod.model }));
+      window.tmct.page.registerWinkModel(() => ({ winkNLP: mod.winkNLP, model: mod.model }));
       winkStatus = "loaded";
     } catch (err) {
       winkStatus = "unavailable";
@@ -1138,8 +1170,8 @@ ${THEME_TOKENS_CSS}
     if (!seedPayload) return null;
     try { return structuredClone(seedPayload); } catch { return JSON.parse(JSON.stringify(seedPayload)); }
   };
-  function newSession() {
-    return window.tmctChat.createChatSession({
+  async function newSession() {
+    return window.tmct.open({
       seedPayload: cloneSeed(),
       vocabSeeded: Boolean(seedPayload),
       liveReference: liveReferenceForMode(checkedWikiMode()),
@@ -1173,7 +1205,7 @@ ${THEME_TOKENS_CSS}
   };
 
   // ---- persistence: what you taught it survives a reload, on this device -
-  // Best-effort IndexedDB (window.tmctChat.openPersistedStore): the whole
+  // Best-effort IndexedDB (window.tmct.page.openPersistedStore): the whole
   // Backend-B payload snapshots after each teach turn, debounced so a burst
   // of teaching costs one multi-MB write, not one per fact. The stamp ties a
   // snapshot to this deploy (site version) AND this seed (its fact count and
@@ -1214,14 +1246,14 @@ ${THEME_TOKENS_CSS}
     // it would keep merging peers' facts into a store nothing reads any more.
     // Rejoining is a fresh invite, which is what a dropped node needs anyway.
     dropRoom();
-    window.tmctChatSession = newSession();
-    const stats = await window.tmctChat.memoryStats(window.tmctChatSession.memoryDir);
+    window.tmctChatSession = await newSession();
+    const stats = await window.tmct.page.memoryStats(window.tmctChatSession.memoryDir);
     addSystemLine("forgot everything taught on this device \\u2014 back to the fresh seed (" + statsSummaryLine(stats, bandLabelFor) + ").");
     await renderStatsPanel(stats);
   }
 
   // ---- memory stats: the boot message's own numbers, and the docked panel -
-  // Both read window.tmctChat.memoryStats(memoryDir) (chat-browser-entry.mjs)
+  // Both read window.tmct.page.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.
   // bandLabelFor/statsSummaryLine/renderStatsPanelInto are the shared
@@ -1234,8 +1266,8 @@ ${THEME_TOKENS_CSS}
    *  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); }
+      if (!window.tmctChatSession || !window.tmct.page.memoryStats) return;
+      try { stats = await window.tmct.page.memoryStats(window.tmctChatSession.memoryDir); }
       catch { return; }
     }
     factPillValueEl.textContent = Number(stats.total || 0).toLocaleString();
@@ -1250,7 +1282,7 @@ ${THEME_TOKENS_CSS}
   // and grounded so far — each entry pairs the passage a settled research
   // turn's own answer cites (parseResearchAnswer, off the SAME "(source:
   // research article ...)" text the chat bubble already shows) with the real
-  // facts that turn stored, read back through window.tmctChat.
+  // facts that turn stored, read back through window.tmct.
   // researchedFactRows(memoryDir) rather than re-deriving them from the
   // answer text — the citation names WHERE tmct read, the fact rows name
   // WHAT it kept, and this panel never invents either from the other.
@@ -1316,9 +1348,9 @@ ${THEME_TOKENS_CSS}
    *  own entry — the passage was still read, even where nothing new stuck. */
   async function noteResearchLearned(result) {
     if (result.research === undefined || !result.record || result.record.miss) return;
-    if (!window.tmctChat.researchedFactRows || !window.tmctChatSession) return;
+    if (!window.tmct.page.researchedFactRows || !window.tmctChatSession) return;
     let rows;
-    try { rows = await window.tmctChat.researchedFactRows(window.tmctChatSession.memoryDir); }
+    try { rows = await window.tmct.page.researchedFactRows(window.tmctChatSession.memoryDir); }
     catch { return; }
     const newFacts = [];
     for (const row of rows) {
@@ -1414,7 +1446,7 @@ ${THEME_TOKENS_CSS}
     setBusy(true);
     let result = null;
     try {
-      result = await window.tmctChatSession.turn(q);
+      result = await window.tmct.turn(q);
       settleAssistantBubble(pendingRow, result.answer, result.record);
       // Persist on ANY store write, not just a teach turn: a learn-on-miss
       // load (a child pack, a reference or live-Wikipedia article, a
@@ -1555,10 +1587,10 @@ ${THEME_TOKENS_CSS}
   // CLI paths emit), so what you taught leaves in the standard shape.
   el("exportFacts").addEventListener("click", async () => {
     const session = window.tmctChatSession;
-    if (!session || !window.tmctChat.exportFactsJsonl) return;
+    if (!session || !window.tmct.page.exportFactsJsonl) return;
     let jsonl;
     try {
-      jsonl = await window.tmctChat.exportFactsJsonl(session.memoryDir);
+      jsonl = await window.tmct.page.exportFactsJsonl(session.memoryDir);
     } catch (err) {
       statusEl.textContent = "couldn't export the facts (" + (err && err.message ? err.message : err) + ")";
       return;
@@ -1575,7 +1607,7 @@ ${THEME_TOKENS_CSS}
   });
 
   // "ingest file" feeds a whole .txt/.md through the SAME session, one
-  // sentence at a time (window.tmctChat.splitSentences, then session.turn),
+  // sentence at a time (window.tmct.page.splitSentences, then session.turn),
   // teaching every sentence the recognizer grounds and skipping the rest
   // honestly — the same pipeline the ingest page runs, reaching the chat's own
   // memory so the taught facts answer questions straight away.
@@ -1584,7 +1616,7 @@ ${THEME_TOKENS_CSS}
     const file = e.target.files && e.target.files[0];
     e.target.value = "";
     const session = window.tmctChatSession;
-    if (!file || busy || !session || !window.tmctChat.splitSentences) return;
+    if (!file || busy || !session || !window.tmct.page.splitSentences) return;
     let text;
     try {
       text = await file.text();
@@ -1592,14 +1624,14 @@ ${THEME_TOKENS_CSS}
       addSystemLine("couldn't read that file (" + (err && err.message ? err.message : err) + ").");
       return;
     }
-    const sentences = window.tmctChat.splitSentences(text);
+    const sentences = window.tmct.page.splitSentences(text);
     if (!sentences.length) { addSystemLine("nothing to ingest in " + file.name + "."); return; }
     setBusy(true);
     statusEl.textContent = "ingesting " + file.name + "\\u2026";
     let grounded = 0;
     try {
       for (const sentence of sentences) {
-        const result = await session.turn(sentence);
+        const result = await tmct.turn(sentence);
         if (result.record && result.record.via === "assert" && !result.record.miss) grounded += 1;
       }
     } catch (err) {
@@ -1827,12 +1859,6 @@ ${THEME_TOKENS_CSS}
   const tapeCounts = new Map();
   let wireMessageCount = 0;
 
-  function tapeClock() {
-    const at = new Date();
-    const pad = function (n, width) { return String(n).padStart(width, "0"); };
-    return pad(at.getHours(), 2) + ":" + pad(at.getMinutes(), 2) + ":" + pad(at.getSeconds(), 2) + "." + pad(at.getMilliseconds(), 3);
-  }
-
   function pushTape(entry) {
     // The meter counts real wire messages only; the tape below shows those
     // plus the local notes (state changes, a channel opening) that explain
@@ -1913,16 +1939,6 @@ ${THEME_TOKENS_CSS}
     answerPanelEl.hidden = !replyOutEl.value || (room && room.state === "connected");
   }
 
-  function relativeWhen(at, nowMs) {
-    if (at === null || at === undefined) return "—";
-    const seconds = Math.max(0, Math.round((nowMs - at) / 1000));
-    if (seconds < 5) return "now";
-    if (seconds < 60) return seconds + "s";
-    if (seconds < 3600) return Math.round(seconds / 60) + "m";
-    if (seconds < 86400) return Math.round(seconds / 3600) + "h";
-    return Math.round(seconds / 86400) + "d";
-  }
-
   function renderNodes() {
     if (!room || !p2p) {
       nodeCountEl.textContent = "";
@@ -2205,16 +2221,16 @@ ${THEME_TOKENS_CSS}
   }
 
   async function boot() {
-    if (!window.tmctChat) {
+    if (!window.tmct) {
       statusEl.textContent = "the chat engine didn't load \\u2014 this page needs its build step (npm run demo:build)";
       inputEl.placeholder = "chat engine unavailable";
       return;
     }
     await Promise.all([fetchSeed(), tryLoadWink(), fetchSiteVersion().then((v) => { siteVersion = v; })]);
     progressActive = false;
-    window.tmctChat.registerReferencePackProvider(fetchPackProvider);
-    if (window.tmctChat.openPersistedStore) {
-      persist = window.tmctChat.openPersistedStore({ storeKey: "chat", stamp: siteVersion + ":" + seedFacts + ":" + SEED_STAMP });
+    window.tmct.page.registerReferencePackProvider(fetchPackProvider);
+    if (window.tmct.page.openPersistedStore) {
+      persist = window.tmct.page.openPersistedStore({ storeKey: "chat", stamp: siteVersion + ":" + seedFacts + ":" + SEED_STAMP });
     }
     const savedRecord = persist ? await persist.load() : null;
     const initialMode = readWikiMode();
@@ -2223,7 +2239,7 @@ ${THEME_TOKENS_CSS}
     synthSliderEl.value = String(readSynthBudget());
     synthValueEl.textContent = synthSliderEl.value;
     if (savedRecord && savedRecord.payload) {
-      window.tmctChatSession = window.tmctChat.createChatSession({
+      window.tmctChatSession = await window.tmct.open({
         seedPayload: savedRecord.payload,
         vocabSeeded: true,
         liveReference: liveReferenceForMode(initialMode),
@@ -2232,9 +2248,9 @@ ${THEME_TOKENS_CSS}
         digestStructures: DIGEST_STRUCTURES,
       });
     } else {
-      window.tmctChatSession = newSession();
+      window.tmctChatSession = await newSession();
     }
-    const stats = await window.tmctChat.memoryStats(window.tmctChatSession.memoryDir);
+    const stats = await window.tmct.page.memoryStats(window.tmctChatSession.memoryDir);
     if (savedRecord) restoredCount = stats.taught.length;
     const restoredNote = savedRecord
       ? " Restored " + restoredCount + " taught fact" + (restoredCount === 1 ? "" : "s")
@@ -2248,14 +2264,14 @@ ${THEME_TOKENS_CSS}
     // seen-set from them so a later research turn only reports what's
     // actually new, without fabricating passages for a visit this page
     // was never open to read.
-    if (window.tmctChat.researchedFactRows) {
+    if (window.tmct.page.researchedFactRows) {
       try {
-        const existingResearch = await window.tmctChat.researchedFactRows(window.tmctChatSession.memoryDir);
+        const existingResearch = await window.tmct.page.researchedFactRows(window.tmctChatSession.memoryDir);
         for (const row of existingResearch) researchedFactKeysSeen.add(row.subject + "|" + row.predicate + "|" + row.object);
       } catch { /* best-effort seeding only — a fresh session has none to seed */ }
     }
     renderResearchedPanel();
-    inputEl.placeholder = seedPayload ? 'try "what is a dog" or "list facts"' : window.tmctChat.vocabExampleHint(false);
+    inputEl.placeholder = seedPayload ? 'try "what is a dog" or "list facts"' : window.tmct.page.vocabExampleHint(false);
     renderStatus();
     setBusy(false);
     inputEl.focus();