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

package/src/services/adventure-viz.mjs

@@ -42,17 +42,17 @@
 //
 // Four further pure helpers are exported for testing but NOT spliced,
 // because each calls another module's export — the in-page script instead
-// reaches through the browser bundle's own `tmctAdventure` global (mirroring
-// how the inline script calls `tmctSpiderFly.*` rather than re-importing
+// reaches through the browser bundle's own `tmct` surface (mirroring
+// how the spider-fly page's inline script calls it rather than re-importing
 // spider-fly-world.mjs): `roomCaptionText` (calls `worldDigestRows`; the
-// in-page `captionFor` mirrors it against `tmctAdventure.worldDigestRows`),
+// in-page `captionFor` mirrors it against `tmct.page.worldDigestRows`),
 // `pillsForRoom` (a thin wrapper over adventure.mjs's own exported
 // `roomAffordances`, whose header explains why its list can never promise an
 // action one of take/open/talk/examine would then refuse; the in-page
-// `pillsFor` mirrors it against `tmctAdventure.roomAffordances`),
+// `pillsFor` mirrors it against `tmct.page.roomAffordances`),
 // `goalStatusLines` (calls `foldWorldState` and adventure-autoplay.mjs's own
 // `exposedFacts`; the in-page `goalStatusLinesFor` mirrors both against the
-// `tmctAdventure` global too), and `visitedRoomGraph` (a directions-only
+// `tmct` surface too), and `visitedRoomGraph` (a directions-only
 // layout of the rooms a session has actually visited, now a thin wrapper over
 // viz-room-graph.mjs's shared `directedGridLayout` — mud-viz.mjs's own
 // burrowGraph wrote the same BFS-grid layout a second time under its own
@@ -60,7 +60,7 @@
 // header for the algorithm and what `hints`/disconnected components mean).
 // The in-page script never splices `directedGridLayout`/`roomGraphSvg`
 // either, for the same not-self-contained reason: it calls
-// `tmctAdventure.directedGridLayout`/`tmctAdventure.roomGraphSvg` straight
+// `tmct.page.directedGridLayout`/`tmct.page.roomGraphSvg` straight
 // through the bundle instead of re-implementing the room map a second time.
 //
 // The chat dock (chatlog/chatform/chatq/pills, below) mirrors
@@ -479,8 +479,8 @@ export function groundedPlaceholder(actions, fallback) {
  *  row. `[]` on an honest miss (neither lookup returns anything) — never a
  *  fabricated suggestion. NOT .toString()-splice-safe (it calls two other
  *  modules' exports) — the in-page script mirrors this same combination
- *  against the browser bundle's own `tmctAdventure.relatedForTerm`/
- *  `tmctAdventure.classAncestorChain`, the same reach-through-the-global
+ *  against the browser bundle's own `tmct.page.relatedForTerm`/
+ *  `tmct.page.classAncestorChain`, the same reach-through-the-global
  *  pattern `pillsFor`/`captionFor` already use for their own adventure.mjs
  *  calls (see this module's header). */
 export function suggestionsForTerm(rows, term) {
@@ -1199,7 +1199,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   let allStoreRows = [];
 
   // ---- persistence — the manor remembers your visit, on this device -------
-  // Best-effort IndexedDB (tmctAdventure.openPersistedStore): after any
+  // Best-effort IndexedDB (tmct.page.openPersistedStore): after any
   // state-changing redraw, the whole Backend-B payload plus the visited-room
   // exposure set snapshots under the "adventure" key, debounced. Restored on
   // boot; reset clears it and starts the world over. The home page's preview
@@ -1208,6 +1208,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   let persist = null;
   let persistSaveTimer = null;
   window.tmctAdventureLastSave = null;
+  window.tmct.lastSave = null;
 
   // The deploy's own version, read off the service worker file the build
   // already stamps (its cache name embeds package.json's version) — the only
@@ -1238,7 +1239,10 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
       }
       const visitedRoomIds = lastSnapshot ? lastSnapshot.visitedRoomIds : [];
       persist.save({ memoryPayload: memoryPayload, visitedRoomIds: visitedRoomIds }).then((saved) => {
-        if (saved) window.tmctAdventureLastSave = { at: Date.now(), ms: Math.round(performance.now() - started) };
+        if (saved) {
+          window.tmctAdventureLastSave = { at: Date.now(), ms: Math.round(performance.now() - started) };
+          window.tmct.lastSave = window.tmctAdventureLastSave;
+        }
       });
     }, 500);
   }
@@ -1297,22 +1301,22 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
 
   function captionFor(rows, state, here) {
     const hereCased = here.charAt(0).toUpperCase() + here.slice(1);
-    const lines = tmctAdventure.worldDigestRows(rows, state)
+    const lines = tmct.page.worldDigestRows(rows, state)
       .filter((row) => row.subject !== "Player" && (row.object === here || row.subject === hereCased))
       .map((row) => row.subject + " " + row.predicate + " " + row.object + ".");
     return lines.length ? lines.join(" ") : "Nothing more about the " + here + " is written down yet.";
   }
 
   // ---- goal status — mirrors adventure-viz.mjs's own goalStatusLines
-  // against tmctAdventure.foldWorldState/tmctAdventure.exposedFacts (the
+  // against tmct.page.foldWorldState/tmct.page.exposedFacts (the
   // same mirroring captionFor/pillsFor already do against their own
   // adventure.mjs exports), so a location is never claimed before the room
   // holding it has actually been visited this session.
   function goalStatusLinesFor(rows, state, visitedRoomIds) {
     const ids = Array.from(new Set(rows.filter((r) => r.predicate === "mgx:is-objective" && r.object === "true").map((r) => r.subject)));
     const carriedIds = new Set(carriedItems(rows, state, ACTING_SUBJECT).map((o) => o.subject));
-    const exposedRows = tmctAdventure.exposedFacts(rows, visitedRoomIds);
-    const exposedState = tmctAdventure.foldWorldState(exposedRows);
+    const exposedRows = tmct.page.exposedFacts(rows, visitedRoomIds);
+    const exposedState = tmct.page.foldWorldState(exposedRows);
     return ids.map((id) => {
       if (carriedIds.has(id)) return { subject: id, status: "carried", text: "carrying the " + id + " \\u2014 the adventure is won." };
       const room = visibleRoomOf(exposedRows, exposedState, id, ACTING_SUBJECT);
@@ -1340,21 +1344,21 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   // cursor per node; play mode's own map stays purely informational.
   // roomGraphSvgFor mirrors the OLD inline roomMapSvg's own board-game sizing
   // (a 64px square cell, 56x26px room footprints) through the shared
-  // viz-room-graph.mjs renderer, reached via the tmctAdventure global the
+  // viz-room-graph.mjs renderer, reached via the tmct surface the
   // same way captionFor/pillsFor already reach their own adventure.mjs
   // calls: roomGraphSvg needs escapeHtml and a module-level exit-delta table
   // this splice-safe script carries neither of, so it runs through the
   // bundle rather than being spliced as text (see this page's own module
   // header). visitedRoomGraphFor is the same posture for the layout half.
   function roomGraphSvgFor(graph, clickable) {
-    return tmctAdventure.roomGraphSvg(graph, {
+    return tmct.page.roomGraphSvg(graph, {
       cellX: 64, cellY: 64, roomW: 56, roomH: 26,
       clickable, selectedRoomId,
       label: clickable ? "the whole manor \\u2014 click a room to inspect it" : "the rooms visited so far",
     });
   }
   function visitedRoomGraphFor(state, visitedIds) {
-    return tmctAdventure.directedGridLayout(state, visitedIds, { actingSubject: ACTING_SUBJECT });
+    return tmct.page.directedGridLayout(state, visitedIds, { actingSubject: ACTING_SUBJECT });
   }
   function renderRoomMap(rows, state, visitedRoomIds) {
     mapWrapEl.innerHTML = roomGraphSvgFor(visitedRoomGraphFor(state, visitedRoomIds), false) || '<span class="empty-note">nowhere yet</span>';
@@ -1417,7 +1421,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
     addChatLine("u", esc(line));
     addObjDockLine("u", esc(line));
     return withLock(async () => {
-      const result = await session.turn(line);
+      const result = await tmct.turn(line);
       addChatLine("a", esc(result.answer).replace(/\\n/g, "<br>"));
       addObjDockLine("a", esc(result.answer).replace(/\\n/g, "<br>"));
       const snap = await session.snapshot();
@@ -1442,7 +1446,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
     // nothing, so it needs no main-transcript echo — it IS the board's own
     // content); pill/typed turns below do echo, since they can change state.
     await withLock(async () => {
-      const result = await session.turn("look " + subject);
+      const result = await tmct.turn("look " + subject);
       objLookEl.textContent = result.answer;
     });
   }
@@ -1505,8 +1509,8 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
 
   // ---- contextual pills — refreshed every redraw from the CURRENT room's
   // own roomAffordances-derived list (mirroring pillsForRoom against
-  // tmctAdventure.roomAffordances, the same way captionFor above mirrors
-  // roomCaptionText against tmctAdventure.worldDigestRows), so a pill for a
+  // tmct.page.roomAffordances, the same way captionFor above mirrors
+  // roomCaptionText against tmct.page.worldDigestRows), so a pill for a
   // room the player has left, or an object already taken, never lingers.
   // Clicking one inserts its exact command text into the input and focuses
   // it; it never auto-submits, so free typing still works and a clicked
@@ -1517,7 +1521,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   // ever wants to edit before running, and drawing it in both places would
   // make one control a suggestion and its twin an action.
   function pillsFor(rows, state, here) {
-    return tmctAdventure.roomAffordances(rows, state, here);
+    return tmct.page.roomAffordances(rows, state, here);
   }
   function renderPills(rows, state, here) {
     const actions = pillsFor(rows, state, here).filter((a) => a.indexOf("go ") !== 0);
@@ -1560,10 +1564,10 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   const ROOT_FALLBACK_BY_CLASS = { adventurer: "person", person: "person", room: "room" };
   const rootFallbackFor = (cls) => ROOT_FALLBACK_BY_CLASS[cls] || "portable";
   function resolveObjectSprite(rows, s) {
-    if (s.subject === "you") return tmctAdventure.resolveSpriteAsset("adventurer", [], [], activeSpriteTemplates, tmctAdventure.SPRITE_REGISTRY, { rootFallback: "person", instanceKey: "you" });
-    return tmctAdventure.resolveSpriteAsset(
+    if (s.subject === "you") return tmct.page.resolveSpriteAsset("adventurer", [], [], activeSpriteTemplates, tmct.page.SPRITE_REGISTRY, { rootFallback: "person", instanceKey: "you" });
+    return tmct.page.resolveSpriteAsset(
       s.subject, spriteAncestryRows(rows, s.subject), factsForSubject(rows, s.subject),
-      activeSpriteTemplates, tmctAdventure.SPRITE_REGISTRY,
+      activeSpriteTemplates, tmct.page.SPRITE_REGISTRY,
       { rootFallback: rootFallbackFor(s.spriteClass), instanceKey: s.subject },
     );
   }
@@ -1574,9 +1578,9 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   // everything else falls back through room's own ancestor chain to the
   // generic room icon.
   function roomKindIconSvg(rows, here) {
-    return tmctAdventure.resolveSpriteAsset(
+    return tmct.page.resolveSpriteAsset(
       here, spriteAncestryRows(rows, here), factsForSubject(rows, here),
-      activeSpriteTemplates, tmctAdventure.SPRITE_REGISTRY,
+      activeSpriteTemplates, tmct.page.SPRITE_REGISTRY,
       { rootFallback: "room", instanceKey: "roomkind-" + here },
     );
   }
@@ -1641,7 +1645,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
     ticker.pause();
     addChatLine("u", esc(line));
     return withLock(async () => {
-      const result = await session.turn(line);
+      const result = await tmct.turn(line);
       addChatLine("a", esc(result.answer).replace(/\\n/g, "<br>"));
       const snap = await session.snapshot();
       redraw(snap);
@@ -1703,9 +1707,9 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
     const classes = new Set(["adventurer"]);
     subjects.forEach((s) => { if (s !== ACTING_SUBJECT) classes.add(spriteClassForObject(rows, s)); });
     legendListEl.innerHTML = Array.from(classes).sort().map((cls) => {
-      const svg = tmctAdventure.resolveSpriteAsset(
+      const svg = tmct.page.resolveSpriteAsset(
         cls, spriteAncestryRows(rows, cls), factsForSubject(rows, cls),
-        activeSpriteTemplates, tmctAdventure.SPRITE_REGISTRY,
+        activeSpriteTemplates, tmct.page.SPRITE_REGISTRY,
         { rootFallback: rootFallbackFor(cls), instanceKey: "legend-" + cls },
       );
       return spriteCardHtml(cls, cls, svg);
@@ -1724,8 +1728,8 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   }
 
   // ---- cursor-driven suggestion pills — the lateral SKOS neighbourhood
-  // (tmctAdventure.relatedForTerm) plus the vertical is-a ancestor chain
-  // (tmctAdventure.classAncestorChain), mirroring adventure-viz.mjs's own
+  // (tmct.page.relatedForTerm) plus the vertical is-a ancestor chain
+  // (tmct.page.classAncestorChain), mirroring adventure-viz.mjs's own
   // suggestionsForTerm against the browser bundle's global (the same
   // reach-through-the-global pattern captionFor/pillsFor already use).
   // Reads the FULL store (allStoreRows), not worldOnlyRows — a term's
@@ -1734,8 +1738,8 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   function renderSuggestionPills() {
     const term = wordBeforeCursor(editorTextEl.value, editorTextEl.selectionStart);
     if (!term) { editorPillsEl.innerHTML = ""; return; }
-    const related = tmctAdventure.relatedForTerm(allStoreRows, term);
-    const chain = tmctAdventure.classAncestorChain(term, allStoreRows);
+    const related = tmct.page.relatedForTerm(allStoreRows, term);
+    const chain = tmct.page.classAncestorChain(term, allStoreRows);
     const seen = new Set([term]);
     const out = [];
     const push = (label) => { if (label && !seen.has(label)) { seen.add(label); out.push(label); } };
@@ -1766,7 +1770,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
     const snap = await session.snapshot();
     allStoreRows = snap.rows;
     editRows = worldOnlyRows(snap.rows);
-    editState = tmctAdventure.foldWorldState(editRows);
+    editState = tmct.page.foldWorldState(editRows);
     if (result.unrecognized.length) {
       const lines = result.unrecognized.map((u) => u.line).join(", ");
       editorStatusEl.className = "edit-status pending";
@@ -1797,7 +1801,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
     const snap = await session.snapshot();
     allStoreRows = snap.rows;
     editRows = worldOnlyRows(snap.rows);
-    editState = tmctAdventure.foldWorldState(editRows);
+    editState = tmct.page.foldWorldState(editRows);
     editorTextEl.value = renderWorldEditorText(editRows, editState);
     editorStatusEl.className = "edit-status";
     editorStatusEl.textContent = "";
@@ -1818,7 +1822,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
 
   async function boot({ fresh = false } = {}) {
     const saved = !fresh && persist ? await persist.load() : null;
-    session = await tmctAdventure.createAdventureSession(
+    session = await tmct.open(
       world(),
       saved && saved.payload && saved.payload.memoryPayload
         ? { restoredPayload: saved.payload.memoryPayload, restoredVisitedRoomIds: saved.payload.visitedRoomIds }
@@ -1877,9 +1881,9 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   // to. Without that, one world's snapshot would restore into another's graph.
   let siteVersion = "";
   async function openPersistFor(worldName) {
-    if (preview || !tmctAdventure.openPersistedStore) return;
+    if (preview || !tmct.page.openPersistedStore) return;
     if (!siteVersion) siteVersion = await fetchSiteVersion();
-    persist = tmctAdventure.openPersistedStore({ storeKey: "adventure", stamp: siteVersion + ":" + worldName });
+    persist = tmct.page.openPersistedStore({ storeKey: "adventure", stamp: siteVersion + ":" + worldName });
   }
 
   if (scenarioSelectEl) {

package/src/services/adventure.mjs

@@ -652,76 +652,101 @@ async function writeWorldTurn(memoryDir, world, k, facts, cache) {
 
 const VOIDED_TESTIMONY_SUFFIX = ":gone";
 
-const characterTestimonyTag = (character, k, voided = false) =>
-  `mud:${character}:turn${k}${voided ? VOIDED_TESTIMONY_SUFFIX : ""}`;
-
-async function appendTestimony(memoryDir, { knower, source, thing, k, voided = false, cache }) {
+/** The provenance tag one character's claim carries: who said it, which run of
+ *  the world it was said in, the turn it was said on, and whether it says the
+ *  thing has gone. The epoch segment follows snapshotSubject's convention —
+ *  written only once a recast has moved the world past epoch 0, so an unrecast
+ *  store and every tag written before epochs existed keep the bare form and
+ *  read back as epoch 0. */
+export function characterTestimonyTag(character, k, { epoch = 0, voided = false } = {}) {
+  const when = epoch > 0 ? `epoch${epoch}:turn${k}` : `turn${k}`;
+  return `mud:${character}:${when}${voided ? VOIDED_TESTIMONY_SUFFIX : ""}`;
+}
+
+async function appendTestimony(memoryDir, { knower, source, thing, k, epoch = 0, voided = false, cache }) {
   await appendFacts(memoryDir, [{
     subject: knower, predicate: KNOWS_ABOUT_PREDICATE, object: thing,
-    provenance: characterTestimonyTag(source, k, voided),
+    provenance: characterTestimonyTag(source, k, { epoch, voided }),
   }]);
   if (cache) cache.rows = null;
 }
 
-/** Record that `teller` told `asker` about `thing` on turn `k`. The asker is
- *  the subject — it is the one who now knows — and the teller is named in the
- *  provenance, so the claim corroborates the teller's Source, not the asker's. */
-export async function recordTold(memoryDir, { asker, teller, thing, k, cache = null }) {
-  return appendTestimony(memoryDir, { knower: asker, source: teller, thing, k, cache });
+/** Record that `teller` told `asker` about `thing` on turn `k` of `epoch`. The
+ *  asker is the subject — it is the one who now knows — and the teller is named
+ *  in the provenance, so the claim corroborates the teller's Source, not the
+ *  asker's. */
+export async function recordTold(memoryDir, { asker, teller, thing, k, epoch = 0, cache = null }) {
+  return appendTestimony(memoryDir, { knower: asker, source: teller, thing, k, epoch, cache });
 }
 
-/** Record that `observer` examined `thing` on turn `k`. The observer is both
- *  the subject and the provenance's character: it learned this by looking, so
- *  it is its own source for it. */
-export async function recordExamined(memoryDir, { observer, thing, k, cache = null }) {
-  return appendTestimony(memoryDir, { knower: observer, source: observer, thing, k, cache });
+/** Record that `observer` examined `thing` on turn `k` of `epoch`. The observer
+ *  is both the subject and the provenance's character: it learned this by
+ *  looking, so it is its own source for it. */
+export async function recordExamined(memoryDir, { observer, thing, k, epoch = 0, cache = null }) {
+  return appendTestimony(memoryDir, { knower: observer, source: observer, thing, k, epoch, cache });
 }
 
-/** Record that `observer` saw `thing` leave the world on turn `k` — it ate the
- *  last of it. Written as a fresh claim on the SAME edge an older one already
- *  sits on, so the older claim stands untouched and stops being the one that
- *  rules. The observer is its own source, the way examining is. */
-export async function recordGone(memoryDir, { observer, thing, k, cache = null }) {
-  return appendTestimony(memoryDir, { knower: observer, source: observer, thing, k, voided: true, cache });
+/** Record that `observer` saw `thing` leave the world on turn `k` of `epoch` —
+ *  it ate the last of it. Written as a fresh claim on the SAME edge an older one
+ *  already sits on, so the older claim stands untouched and stops being the one
+ *  that rules. The observer is its own source, the way examining is. */
+export async function recordGone(memoryDir, { observer, thing, k, epoch = 0, cache = null }) {
+  return appendTestimony(memoryDir, { knower: observer, source: observer, thing, k, epoch, voided: true, cache });
 }
 
-const TESTIMONY_TAG_RE = /^mud:([^:\s]+):turn(\d+)(:gone)?$/;
+const TESTIMONY_TAG_RE = /^mud:([^:\s]+):(?:epoch(\d+):)?turn(\d+)(:gone)?$/;
 const TURN_STAMP_RE = /:turn(\d+)\b/;
 
 /** How one provenance segment on a knows-about edge stands as a claim about
- *  what `knower` knows: whether the knower vouches for it itself, the turn it
- *  was asserted on, and whether it says the thing is gone. A tag that is no
- *  character's testimony — a world's own seed fact, a dig spawn — reads as
- *  hearsay stamped with whatever turn it carries. */
-function testimonyClaim(segment, knower) {
+ *  what `knower` knows: which run of the world it was made in, whether the
+ *  knower vouches for it itself, the turn it was asserted on, and whether it
+ *  says the thing is gone. A tag that is no character's testimony — a world's
+ *  own seed fact, a dig spawn — reads as hearsay stamped with whatever turn it
+ *  carries.
+ *
+ *  Epoch reads the same way foldWorldState reads a row's: a stamped tag names
+ *  its own run, a tag stamped with a turn but no epoch was written on epoch 0
+ *  (or before epochs existed), and a tag with no turn at all is a seed the
+ *  world lays down fresh on every recast, so it belongs to the run being read
+ *  now. */
+function testimonyClaim(segment, knower, currentEpoch = 0) {
   const mine = TESTIMONY_TAG_RE.exec(segment);
-  const stamp = Number(mine ? mine[2] : (TURN_STAMP_RE.exec(segment)?.[1] ?? 0));
+  const turnStamp = mine ? mine[3] : TURN_STAMP_RE.exec(segment)?.[1];
+  const stamp = Number(turnStamp ?? 0);
+  const epochStamp = mine?.[2];
   return {
+    epoch: epochStamp ? Number(epochStamp) : (turnStamp === undefined ? currentEpoch : 0),
     firsthand: !!mine && mine[1] === knower,
     turn: Number.isFinite(stamp) ? stamp : 0,
-    voided: !!(mine && mine[3]),
+    voided: !!(mine && mine[4]),
   };
 }
 
-/** Firsthand beats hearsay outright, then the later turn wins, then "gone"
- *  takes the tie — an animal that examined a carrot and ate it on one turn ate
- *  it second. Tier ABOVE recency is what stops an animal being talked back into
- *  a meal it ate itself: a room-mate can tell it about that carrot the turn
- *  after, and its own eyes still hold. */
+/** The later epoch beats everything, then firsthand beats hearsay, then the
+ *  later turn wins, then "gone" takes the tie — an animal that examined a carrot
+ *  and ate it on one turn ate it second.
+ *
+ *  Epoch on top mirrors the world-state fold: a recast starts the world over, so
+ *  nothing said in the run it replaced can rule over what a character has seen
+ *  since, however late in that old run it was said or however firsthand. Within
+ *  one run, firsthand sits above recency, and that is what stops an animal being
+ *  talked back into a meal it ate itself: a room-mate can tell it about that
+ *  carrot the turn after, and its own eyes still hold. */
 const outranksClaim = (claim, best) => (
-  claim.firsthand !== best.firsthand ? claim.firsthand
-    : claim.turn !== best.turn ? claim.turn > best.turn
-      : claim.voided && !best.voided
+  claim.epoch !== best.epoch ? claim.epoch > best.epoch
+    : claim.firsthand !== best.firsthand ? claim.firsthand
+      : claim.turn !== best.turn ? claim.turn > best.turn
+        : claim.voided && !best.voided
 );
 
 /** The claim that rules on one knows-about edge, across every segment its
  *  provenance carries. */
-function rulingTestimonyClaim(provenance, knower) {
+function rulingTestimonyClaim(provenance, knower, currentEpoch = 0) {
   let best = null;
   for (const segment of String(provenance || "").split(" | ")) {
     const tag = segment.trim();
     if (!tag) continue;
-    const claim = testimonyClaim(tag, knower);
+    const claim = testimonyClaim(tag, knower, currentEpoch);
     if (!best || outranksClaim(claim, best)) best = claim;
   }
   return best;
@@ -730,12 +755,13 @@ function rulingTestimonyClaim(provenance, knower) {
 /** What `person` knows about NOW: the object of every knows-about edge whose
  *  ruling claim still stands, in the order the edges were first written.
  *  Nothing is deleted — an edge whose newest claim says the thing is gone just
- *  stops reading back. */
-function currentKnowsAboutTopics(rows, person) {
+ *  stops reading back. `currentEpoch` is the run the reader is on, so a claim a
+ *  recast has left behind cannot decide what a character knows today. */
+function currentKnowsAboutTopics(rows, person, currentEpoch = 0) {
   const topics = [];
   for (const row of rows || []) {
     if (row.subject !== person || row.predicate !== KNOWS_ABOUT_PREDICATE) continue;
-    if (rulingTestimonyClaim(row.provenance, person)?.voided) continue;
+    if (rulingTestimonyClaim(row.provenance, person, currentEpoch)?.voided) continue;
     topics.push(row.object);
   }
   return topics;
@@ -1291,7 +1317,7 @@ export function personKnowledgeLines(rows, state, person) {
       ? `you'll find the ${thing} in the ${place.object}.`
       : `the ${thing} is in the ${place.object}.`);
   }
-  return { lines, aboutTopics: currentKnowsAboutTopics(rows, person) };
+  return { lines, aboutTopics: currentKnowsAboutTopics(rows, person, state?.epoch ?? 0) };
 }
 
 /** The FOOD_CLASS things `person` durably knows about — from being told, or
@@ -1302,7 +1328,7 @@ export function personKnowledgeLines(rows, state, person) {
  *  food query has no per-topic sub-digest to hand back, so this returns the
  *  plain list of known food things rather than a {lines, topics} pair. Pure. */
 export function personKnownFoodLines(rows, state, person) {
-  return currentKnowsAboutTopics(rows, person)
+  return currentKnowsAboutTopics(rows, person, state?.epoch ?? 0)
     .filter((thing) => objectClassChain(rows, thing).includes(FOOD_CLASS));
 }