@polycode-projects/the-mechanical-code-talker 5.0.2 → 5.0.3

package/src/services/adventure-autoplay.mjs

@@ -11,7 +11,7 @@
 // actually seen. `exposedRoomIds` is the set of rooms this auto-play run has
 // itself moved into (the opening room included from turn 0) — it is the sole
 // caller making every move, so it always knows this, and threads the set
-// forward turn to turn exactly like spider-fly.mjs threads its own agents
+// forward turn to turn exactly like predator-prey.mjs threads its own agents
 // shape. `exposedFacts` turns that set into the actual filtered view: a fact
 // is exposed when its subject's CURRENT placement resolves into an exposed
 // room, when the subject is the player, or when the fact IS the world's
@@ -130,7 +130,7 @@ async function stepTowardThenAct({
  * and execute exactly the one move that goal implies through `adventureTurn`
  * — the same public entry point a real chat turn calls. Returns
  * `{ turn, goal, plan, done, stalled, exposedRoomIds }`, mirroring
- * spider-fly.mjs's own tick shape: `plan` is the remaining multi-step route a
+ * predator-prey.mjs's own tick shape: `plan` is the remaining multi-step route a
  * `findActionPath` search found this tick (or null when the move was a
  * single, immediate step — an adjacent unexposed exit, or a take), `goal` is
  * a short line describing what this tick did, `done` means the objective is

package/src/services/adventure-viz.mjs

@@ -944,6 +944,8 @@ ${THEME_TOKENS_CSS}
      onto further lines, staying right-anchored rather than dropping the
      whole pill row under the heading. */
   .command-head .pills { flex: 1 1 auto; min-width: 0; justify-content: flex-end; margin-bottom: 0; }
+  .teach-toggle { display: flex; align-items: center; gap: .35rem; font-family: ${MONO_STACK}; font-size: .72rem; color: var(--muted); margin: 0 0 .4rem; cursor: pointer; }
+  .teach-toggle input { accent-color: var(--gilt); }
   .chatask { display: flex; align-items: center; gap: .5rem; border-top: 1px solid var(--line); padding-top: .5rem; }
   .chatask .prompt { color: var(--taught); font-size: .78rem; font-family: ${MONO_STACK}; }
   .chatask input { flex: 1; font-family: ${MONO_STACK}; font-size: .78rem; background: var(--bg); color: var(--ink); border: 1px solid var(--line); padding: .32rem .55rem; min-width: 0; }
@@ -1042,6 +1044,10 @@ ${scenarioList.map((s, i) => `          <option value="${i}"${i === 0 ? " select
           <h2>What would you like to do</h2>
           <div class="pills" id="pills"></div>
         </div>
+        <label class="teach-toggle" title="With this on, a sentence like &quot;Candle is in the study.&quot; writes a fact into the world instead of running as a command.">
+          <input type="checkbox" id="teachToggle">
+          teach mode
+        </label>
         <form class="chatask" id="chatform">
           <span class="prompt mono">tmct&gt;</span>
           <input id="chatq" type="text" placeholder="go north" aria-label="Type a command, or ask a question" disabled>
@@ -1151,6 +1157,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   const pillsEl = el("pills");
   const chatformEl = el("chatform");
   const chatqEl = el("chatq");
+  const teachToggleEl = el("teachToggle");
   const carryListEl = el("carryList");
   const mapWrapEl = el("mapWrap");
   const mapViewportEl = el("mapViewport");
@@ -1525,7 +1532,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   }
   function renderPills(rows, state, here) {
     const actions = pillsFor(rows, state, here).filter((a) => a.indexOf("go ") !== 0);
-    pillsEl.innerHTML = actions.map((a) => '<button type="button" class="pill">' + esc(a) + "</button>").join("");
+    pillsEl.innerHTML = actions.map((a) => '<button type="button" class="pill" data-command="' + esc(a) + '">' + esc(a) + "</button>").join("");
     // The empty input teaches the grounded noun form off the same affordance
     // list the pills read — real props from THIS room, so a first-time player
     // types "examine lamp", not a pronoun with nothing to bind to yet.
@@ -1822,12 +1829,10 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
 
   async function boot({ fresh = false } = {}) {
     const saved = !fresh && persist ? await persist.load() : null;
-    session = await tmct.open(
-      world(),
-      saved && saved.payload && saved.payload.memoryPayload
-        ? { restoredPayload: saved.payload.memoryPayload, restoredVisitedRoomIds: saved.payload.visitedRoomIds }
-        : {},
-    );
+    const restoreOptions = saved && saved.payload && saved.payload.memoryPayload
+      ? { restoredPayload: saved.payload.memoryPayload, restoredVisitedRoomIds: saved.payload.visitedRoomIds }
+      : {};
+    session = await tmct.open(world(), { ...restoreOptions, getTeachEnabled: () => teachToggleEl.checked });
     lastTicks = 0;
     const snap = await session.snapshot();
     redraw(snap);

package/src/services/chat.mjs

@@ -40,7 +40,7 @@ import {
   stripTrailingScopeFiller, stripTrailingDiscourseTag, EDGE_NOUN_TO_METRIC, RELATIONS, LIST_TRIGGERS,
   locativePreposition,
 } from "../domain/ask-vocab.mjs";
-import { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames, expandContractions, normalizeQuery, stripFillerWords, escapeRegex, kindNounAnaphoraHint, datedTeachSuffix } from "../domain/interpret/normalize.mjs";
+import { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames, expandContractions, normalizeQuery, stripFillerWords, escapeRegex, kindNounAnaphoraHint, datedTeachSuffix, QUESTION_LEAD_RE } from "../domain/interpret/normalize.mjs";
 import { setDefaultNlpAdapter } from "../domain/interpret/nlp-registry.mjs";
 import { setConstructionBanks } from "../domain/interpret/strategies/constructions.mjs";
 import { nlpAdapter } from "../adapters/ask-nlp.mjs";
@@ -2366,9 +2366,6 @@ const COMPARATIVE_ASK_RE = new RegExp(`^(?:is|are)\\s+(.+?)\\s+(${COMPARATIVE_SR
  *  preposition into a minted predicate (the general-verb teach/query lanes
  *  and the action-rule frames) — a single source so the set never forks. */
 const PREP_SRC = "on|in|at|onto|upon|under|over|beside|near|behind|above|below|inside|outside";
-/** Interrogative / auxiliary leads that make an "X is a Y"-shaped line a QUESTION
- *  ("what is a cache", "is a module a component"), never a teach declarative. */
-const QUESTION_LEAD_RE = /^(?:what|who|which|where|when|why|how|is|are|do|does|did|can|could|should|would|will|has|have)\b/i;
 /** A plain declarative "X is a kind of Y" / "X is a Y" shape (subject-first, no
  *  question lead — paired with QUESTION_LEAD_RE at every call site), tolerating
  *  an infix "kind of"/"type of" (teachLane's own stripKindOf handles this same
@@ -4794,23 +4791,54 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
 
     // RETRACTION — "forget that X is a Y": wires the data-layer retraction
     // primitive (retractSubClassOf, src/domain/syllogise.mjs) up to chat-level
-    // phrasing.
+    // phrasing. Scoped to THIS session's own assertion (sourceTags below) —
+    // the same tags teachFact/assertSentence write under — so retracting
+    // never erases a fact another source taught, only this session's own copy.
     //
     // TRIGGER, never itself the authority: RETRACT_FORGET_RE only recognizes
     // the SHAPE of a retraction sentence — it says nothing about whether
-    // subject⊑object was ever actually taught. retractSubClassOf is asked for
-    // real and is the only thing that decides:
-    //   - found:true  → a real stored (or entailed) fact existed and was
-    //     retracted (with its dependency-directed cascade) — confirmed here.
-    //   - found:false → subject⊑object was never a stored fact, and this falls
-    //     through to the rest of teachLane's ordinary cascade below rather than
-    //     claiming a specific, possibly-wrong reason.
+    // subject⊑object was ever actually taught, or taught by THIS session.
+    // retractSubClassOf is asked for real and is the only thing that decides:
+    //   - found:false  → subject⊑object was never a stored fact, and this
+    //     falls through to the rest of teachLane's ordinary cascade below
+    //     rather than claiming a specific, possibly-wrong reason.
+    //   - found:true, ownRecord:false → some OTHER source taught it; this
+    //     session has nothing of its own to withdraw.
+    //   - found:true, stillStands:true → this session's own record is gone,
+    //     but another source's record keeps the fact standing (no cascade —
+    //     its premise never actually broke).
+    //   - found:true, stillStands:false → this session held the only record;
+    //     the fact and its dependency-directed cascade are both gone.
     if (retractForgetMatch) {
       const { retractSubClassOf } = await import("../domain/syllogise.mjs");
-      const { loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts, appendFacts: appendFactsForRetract } = await import("../adapters/memory/core.mjs");
+      const { provenanceTag: aceProvenanceTag } = await import("../domain/grammar/assert.mjs");
+      const {
+        loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts,
+        appendFacts: appendFactsForRetract, factRecordIdForTag,
+      } = await import("../adapters/memory/core.mjs");
       const result = await retractSubClassOf(memoryDir, retractSubject, retractObject, {
-        store: { loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts, appendFacts: appendFactsForRetract },
+        // A session's own positive assertion of subject⊑object can have
+        // landed under either lane: the free-form teach lane (teachFact) or
+        // the ACE-parsed assert lane (assertSentence) — both tags name here.
+        sourceTags: [teachProvenanceTag(sessionId), aceProvenanceTag({ sessionId })],
+        store: {
+          loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts,
+          appendFacts: appendFactsForRetract, factRecordIdForTag,
+        },
       });
+      if (result.found && !result.ownRecord) {
+        return {
+          text: `"${retractSubject} is a kind of ${retractObject}" isn't something you taught me — it's on record from elsewhere, so there's nothing of yours to forget.`,
+          via: "retract", miss: false,
+        };
+      }
+      if (result.found && result.stillStands) {
+        return {
+          text: `noted — forgotten your own record of "${retractSubject} is a kind of ${retractObject}", `
+            + "but it's still stored, told to me by someone else.",
+          via: "retract", miss: false,
+        };
+      }
       if (result.found) {
         const extra = result.count - 1; // beyond the target fact itself
         return {

package/src/services/mud-turn.mjs

@@ -1,7 +1,7 @@
 // mud-turn.mjs — one acting character's whole turn in a mud world: investigate
 // the room it stands in, walk toward food it actually knows about, roll for
 // digging out of the room's frontier, and (when none of that came to anything)
-// set off for a room it has never stood in. The split mirrors spider-fly.mjs /
+// set off for a room it has never stood in. The split mirrors predator-prey.mjs /
 // spider-fly-turn.mjs: adventure.mjs owns the read/fold/write primitives, this
 // file owns the per-tick decisions that drive them. Nothing here writes a fact
 // of its own — every change goes out through runWorldCommand, recordTold,

package/src/services/mud-viz.mjs

@@ -411,6 +411,10 @@ ${scenarioList.length > 1 ? `        <select id="scenarioSelect" class="deck-sel
 ${scenarioList.map((s, i) => `          <option value="${i}"${i === 0 ? " selected" : ""}>${escapeHtml(s.label || scenarioLabel(s.worldPayload?.name))}</option>`).join("\n")}
         </select>` : ""}
         <button type="button" id="editModeBtn" aria-pressed="false">edit</button>
+        <label class="deck-teach" title="With this on, a sentence like &quot;Candle is in the study.&quot; writes a fact into the world instead of running as a command.">
+          <input type="checkbox" id="teachToggle">
+          teach
+        </label>
         <button type="button" class="deck-info-btn" id="deckInfoBtn" aria-expanded="false" aria-controls="deckInfoPopup" aria-label="about this demo">?</button>
         <span class="mono deck-turns" id="globalTurnCount">turns: 0</span>
       </div>
@@ -634,6 +638,8 @@ const MUD_STYLE = `
     background: rgba(255,255,255,.5); color: var(--mud-ink);
   }
   .deck-select:hover { border-color: var(--burrow-glow); }
+  .deck-teach { display: flex; align-items: center; gap: .3rem; font-family: ${MONO_STACK}; font-size: .72rem; text-transform: uppercase; letter-spacing: .05em; color: var(--soil-mid); cursor: pointer; }
+  .deck-teach input[type="checkbox"] { accent-color: var(--burrow-glow); }
   .deck-play { background: var(--mud-ink) !important; color: var(--parchment); border-color: var(--mud-ink) !important; padding: .38rem 1.1rem !important; }
   .deck-play[aria-pressed="true"] { background: var(--burrow-glow) !important; border-color: var(--burrow-glow) !important; color: var(--mud-ink); }
   .deck-turns { margin-left: auto; font-size: .74rem; color: var(--soil-mid); }
@@ -1006,7 +1012,7 @@ const MUD_STYLE = `
     --lem-readout: var(--burrow-glow); --lem-readout-bg: var(--soil-deep);
     --lem-chalk: var(--soil-mid);
   }
-  .deck-slider, .deck h3 { color: var(--lem-chalk); }
+  .deck-slider, .deck h3, .deck-teach { color: var(--lem-chalk); }
   .deck-slider input[type="range"] { accent-color: var(--burrow-glow); }
   .deck button, .pane-controls button {
     background: var(--lem-face); color: var(--mud-ink); border: 1px solid var(--soil-mid); border-radius: 3px;
@@ -3052,7 +3058,10 @@ function pageScript() {
     // scenario's cast paired with the LAST scenario's pane ids, which is what
     // a null pane-element lookup in renderAll means when it happens.
     for (let i = 0; i < cast.length; i += 1) slotOf[cast[i]] = slots[i];
-    const opened = await window.tmct.open(scenario().worldPayload, { characters: everyone(), epoch: nextEpoch });
+    const opened = await window.tmct.open(scenario().worldPayload, {
+      characters: everyone(), epoch: nextEpoch,
+      getTeachEnabled: function () { return el("teachToggle").checked; },
+    });
     if (seq !== bootSeq) return;
     session = opened;
     if (liveRoom) {

package/src/services/mudiii-scene.mjs

@@ -130,16 +130,14 @@ export function chebyshevDistanceBetweenCells(a, b) {
   return Math.max(Math.abs(Number(ma[1]) - Number(mb[1])), Math.abs(Number(ma[2]) - Number(mb[2])));
 }
 
-/** A facing word to a Y rotation in radians, `south` (the world's own
- *  `defaultFacing`) at zero — matches `cameraRigFor`'s own FACING_VECTOR
- *  convention (`south: {x:0,z:1}`, `north: {x:0,z:-1}`, `east: {x:1,z:0}`,
- *  `west: {x:-1,z:0}`) so an agent mesh turns to face the same way its own
- *  follow/pov camera rig would sit behind it. A rig's own forward axis may
- *  need a per-model offset once real assets are in place; this is the
- *  world-facing convention, not a guarantee about any one GLB's neutral
- *  pose. Pure. */
+/** A facing word to a Y rotation in radians. Assumes a model's own local
+ *  forward is +Z (true for fox and goblin, the two rigs in the current
+ *  manifest, checked by walking each GLB's own bind-pose bone chain) so a
+ *  rotated mesh matches `cameraRigFor`'s own FACING_VECTOR table exactly for
+ *  all four cardinals — a model with a -Z neutral pose would need its own
+ *  offset. Pure. */
 export function yawForFacing(facing) {
-  const YAW = { south: 0, north: Math.PI, east: -Math.PI / 2, west: Math.PI / 2 };
+  const YAW = { south: 0, north: Math.PI, east: Math.PI / 2, west: -Math.PI / 2 };
   return YAW[facing] ?? YAW.south;
 }
 
@@ -352,7 +350,7 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
 
   var loadThreeVendor = createThreeVendorLoader();
   var THREE = null, GLTFLoaderCtor = null, OrbitControlsCtor = null, MeshoptDecoderRef = null;
-  var gltfLoader = null, loadQueue = createConcurrencyQueue(4), rawLoader = null;
+  var gltfLoader = null, loadQueue = createConcurrencyQueue(4);
   var scene = null, camera3 = null, renderer = null, orbitControls = null, groundMesh = null, raycaster = null;
   var agentGroups = {};
   var itemMeshes = {};
@@ -366,10 +364,24 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
   var lastFrameTs = null;
   var booted = false;
 
+  // Cache the fetched BYTES, not the parsed scene: one network request per
+  // model URL, however many agents share that kind, then a GLTFLoader.parse
+  // per caller off the shared ArrayBuffer. Each caller still ends up owning
+  // its own object graph, so normalizeToHeight's own guards still hold.
+  function fetchGlbBytes(url) {
+    return fetch(url).then(function (res) {
+      if (!res.ok) throw new Error("model fetch failed with status " + res.status + ": " + url);
+      return res.arrayBuffer();
+    });
+  }
+  var glbBytesCache = createCachedLoader(fetchGlbBytes);
+
   function loadGlbRaw(url) {
-    return loadQueue.run(function () {
-      return new Promise(function (resolve, reject) {
-        gltfLoader.load(url, resolve, undefined, reject);
+    return glbBytesCache.load(url).then(function (buffer) {
+      return loadQueue.run(function () {
+        return new Promise(function (resolve, reject) {
+          gltfLoader.parse(buffer, THREE.LoaderUtils.extractUrlBase(url), resolve, reject);
+        });
       });
     });
   }
@@ -473,15 +485,32 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
   }
 
   // ---- props ---------------------------------------------------------------
+  // Box3.setFromObject reads through a parent's world matrix, so measuring a
+  // parented object reads whatever that parent's spawn flourish is doing in
+  // that frame and applies a scale that depends on the frame. The guards make
+  // both misuses fail loudly rather than render a wrong size silently. Keep
+  // no backtick in this block: the function's source sits inside the module's
+  // own template literal.
   function normalizeToHeight(object3D, targetHeight) {
+    if (object3D.parent) {
+      throw new Error("normalizeToHeight refused an object that already has a parent: " + (object3D.name || object3D.uuid));
+    }
+    if (object3D.userData.tmctNormalized) {
+      throw new Error("normalizeToHeight refused a second call on the same object: " + (object3D.name || object3D.uuid));
+    }
     var box = new THREE.Box3().setFromObject(object3D);
     var size = new THREE.Vector3();
     box.getSize(size);
-    var height = size.y || 1;
-    var scale = targetHeight && height ? targetHeight / height : 1;
+    if (!size.y) {
+      // Substituting 1 here invented a scale from an unmeasurable height, and
+      // that is what produced the house-height mesh.
+      throw new Error("normalizeToHeight found no measurable height on: " + (object3D.name || object3D.uuid));
+    }
+    var scale = targetHeight ? targetHeight / size.y : 1;
     object3D.scale.setScalar(scale);
     var seated = new THREE.Box3().setFromObject(object3D);
     object3D.position.y -= seated.min.y;
+    object3D.userData.tmctNormalized = true;
   }
 
   async function loadPropTemplate(asset) {
@@ -516,7 +545,9 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
   }
 
   // ---- items: crumbs and morsels, primitive geometry ------------------------
-  var CRUMB_RADIUS = 0.08, MORSEL_RADIUS = 0.18;
+  // Doubled from 0.08/0.18: against the fox's own 1m targetHeight and a 1-unit
+  // cell, the old radii read as barely-visible dots on the board.
+  var CRUMB_RADIUS = 0.16, MORSEL_RADIUS = 0.36;
   function itemGeometryFor(kind) { return new THREE.SphereGeometry(kind === "morsel" ? MORSEL_RADIUS : CRUMB_RADIUS, 10, 8); }
   function itemMaterialFor(kind) { return new THREE.MeshStandardMaterial({ color: kind === "morsel" ? 0xd98a2b : 0x8c6a3f }); }
   function itemHeightFor(kind) { return kind === "morsel" ? MORSEL_RADIUS : CRUMB_RADIUS; }
@@ -579,7 +610,7 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
     agentGroups[id] = entry;
     var asset = manifestByKind[kind];
     if (asset) {
-      loadGlb(modelUrlFor(asset.destPath)).then(function (gltf) {
+      loadGlbRaw(modelUrlFor(asset.destPath)).then(function (gltf) {
         normalizeToHeight(gltf.scene, asset.targetHeight);
         entry.group.add(gltf.scene);
         entry.group.visible = true;
@@ -760,6 +791,27 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
       if (itemMeshes[id]) return itemMeshes[id].cell;
       return null;
     },
+    // The live agent group's own applied Y rotation, in radians -- an e2e
+    // assertion's read, so it can compare the yaw actually applied against
+    // the direction an agent travelled between two cells rather than trusting
+    // yawForFacing's own output in isolation.
+    yawOf: function (id) {
+      var entry = agentGroups[id];
+      return entry ? entry.group.rotation.y : null;
+    },
+    // The live agent mesh's world-space height and lowest point, plus the
+    // manifest's own targetHeight to compare it against — an e2e assertion's
+    // read, so it goes through the group actually in the scene rather than a
+    // second, locally invented measurement.
+    meshHeightOf: function (id) {
+      var entry = agentGroups[id];
+      if (!entry || !entry.group || entry.group.children.length === 0) return null;
+      var box = new THREE.Box3().setFromObject(entry.group);
+      var size = new THREE.Vector3();
+      box.getSize(size);
+      var asset = manifestByKind[entry.kind];
+      return { height: size.y, minY: box.min.y, targetHeight: asset ? asset.targetHeight : null };
+    },
     ready: function () { return booted; },
   };
 })();`;

package/src/services/mudiii-viz.mjs

@@ -82,7 +82,7 @@ const NPC_COUNT_MIN = 1;
 const NPC_COUNT_MAX = 10;
 const NPC_COUNT_LABELLED = [1, 5, 10];
 const DEFAULT_NPC_COUNT = 2;
-const DEFAULT_DELAY_MS = 650;
+const DEFAULT_DELAY_MS = 220;
 const DEFAULT_MAX_TURNS = 400;
 // test/fixtures/mudiii-ticks.json's own board size — the fallback for a
 // scenario that names no gridSize of its own.
@@ -1216,7 +1216,7 @@ function pageScript() {
     agentsById = {};
     itemsById = {};
     el("chatInput").disabled = false;
-    callScene("boot", { propPlacements: props, assetManifest: DATA.assetManifest, gridSize: DATA.gridSize, cellSize: 1 });
+    await callScene("boot", { propPlacements: props, assetManifest: DATA.assetManifest, gridSize: DATA.gridSize, cellSize: 1 });
 
     // The opening board, drawn through the very path a tick takes. Without
     // this the page's first sight of where anything stands is the first tick,

package/src/services/p2p-room.mjs

@@ -30,7 +30,13 @@ import {
   WAVED_PREDICATE,
 } from "../domain/p2p/facts.mjs";
 import { generateNodeId } from "../domain/p2p/peer-id.mjs";
-import { appendFacts, loadMemory, loadNodeId, saveNodeId, readFactRows, normFactTerm, FACT_CLASS } from "../adapters/memory/core.mjs";
+import {
+  RETRACTION_PREDICATE, encodeRetractionValue, decodeRetractionValue,
+} from "../domain/memory/retraction.mjs";
+import {
+  appendFacts, appendRetractions, loadMemory, loadNodeId, saveNodeId,
+  readFactRows, readRetractions, normFactTerm, factGroupId, factRecordIdForTag, FACT_CLASS,
+} from "../adapters/memory/core.mjs";
 
 export const ROOM_IDLE = "idle";
 export const ROOM_SHARING = "sharing";
@@ -156,6 +162,40 @@ const toWireFacts = (row, identity, fallbackTimestamp) => {
     }));
 };
 
+/** The record ids one provenance string keys once its tags have been relabelled
+ *  for the wire. Two stores file one assertion under two ids — here under the
+ *  chat session that taught it, at the peer under the node that sent it — so a
+ *  retraction that named only the ids it sees locally would bite on one store
+ *  and miss the other. Naming both is what makes it land either way. */
+function broadcastRecordIds(groupId, provenance, identity, fallbackTimestamp) {
+  const ids = [];
+  for (const { tag } of wireProvenanceTags(provenance, identity, fallbackTimestamp)) {
+    if (tag) ids.push(factRecordIdForTag(groupId, tag));
+  }
+  return ids;
+}
+
+/** A retraction goes out as ONE fact carrying every tag, not one per tag. The
+ *  per-tag split exists because appendFacts unions an incoming tag against the
+ *  ones it stores; a retraction merges through its own union instead, and the
+ *  tags it carries are already relabel fixpoints. */
+const toWireRetraction = (record, identity, fallbackTimestamp) => {
+  const groupId = factGroupId(record.subject);
+  const { retractedAt, ids } = decodeRetractionValue(record.object);
+  const tags = wireProvenanceTags(record.provenance, identity, fallbackTimestamp)
+    .map(({ tag }) => tag)
+    .filter(Boolean);
+  return {
+    subject: record.subject,
+    predicate: RETRACTION_PREDICATE,
+    object: encodeRetractionValue(retractedAt, [
+      ...ids,
+      ...broadcastRecordIds(groupId, record.provenance, identity, fallbackTimestamp),
+    ]),
+    provenance: tags.join(" | "),
+  };
+};
+
 /** A room: one shared world, one local fact store, and however many direct
  *  peer connections have been made into it.
  *
@@ -219,6 +259,14 @@ export function createP2pRoom({
   // fact that arrived from a peer being re-broadcast as if we had authored it.
   const seenProvenanceById = new Map();
   let cachedRows = [];
+  // A retraction is not a fact row — readFactRows can never return one, because
+  // the whole point of the record is that the rows it names are gone. So it
+  // gets its own cache and its own diff, keyed on what it actually carries: the
+  // ids it suppressed. Those grow by union as peers merge, and a grown record
+  // is a change worth broadcasting even though its provenance never moved.
+  let cachedRetractions = [];
+  const seenRetractionValueById = new Map();
+  const retractionDiffValue = (fact) => `${fact.provenance}${fact.object}`;
 
   // Store-touching work runs one job at a time, in arrival order. Every path
   // that reads or writes memoryDir/seenProvenanceById/cachedRows crosses at
@@ -263,10 +311,53 @@ export function createP2pRoom({
   }
 
   async function refreshRows() {
-    cachedRows = readFactRows(await loadMemory(memoryDir));
+    const memory = await loadMemory(memoryDir);
+    cachedRows = readFactRows(memory);
+    cachedRetractions = readRetractions(memory);
     return cachedRows;
   }
 
+  const toWire = (row, identity, timestamp) => (row.predicate === RETRACTION_PREDICATE
+    ? [toWireRetraction(row, identity, timestamp)]
+    : toWireFacts(row, identity, timestamp));
+
+  /** Fold the broadcast form of this node's own retractions back into the store.
+   *  A retraction made here names the ids this store files the assertion under;
+   *  a peer relaying that same assertion back sends it under the id the RELABEL
+   *  produces. Merging the broadcast form in is what makes the local refusal
+   *  cover it, and it is a union, so it settles after one pass. */
+  async function alignOwnRetractions() {
+    if (!cachedRetractions.length) return;
+    const identity = wireIdentity();
+    const timestamp = now();
+    const expanded = cachedRetractions.map((record) => toWireRetraction(record, identity, timestamp));
+    if (expanded.every((wire, i) => wire.object === cachedRetractions[i].object)) return;
+    await appendRetractions(memoryDir, expanded);
+    await refreshRows();
+  }
+
+  /** The other side of the same re-keying: a retraction that names this node's
+   *  broadcast id for an assertion also names whatever id this store files that
+   *  same assertion under. Without it a peer could retract a fact it learned
+   *  from here and the origin would keep reading its own copy. */
+  function localiseRetraction(fact) {
+    const groupId = factGroupId(fact.subject);
+    const { retractedAt, ids } = decodeRetractionValue(fact.object);
+    const named = new Set(ids);
+    const row = cachedRows.find((r) => r.id === groupId);
+    if (!row) return fact;
+    const identity = wireIdentity();
+    const timestamp = now();
+    const alsoNamed = [];
+    for (const assertion of row.assertions || []) {
+      if (named.has(assertion.id)) continue;
+      const asBroadcast = broadcastRecordIds(groupId, assertion.provenance, identity, timestamp);
+      if (asBroadcast.some((id) => named.has(id))) alsoNamed.push(assertion.id);
+    }
+    if (!alsoNamed.length) return fact;
+    return { ...fact, object: encodeRetractionValue(retractedAt, [...ids, ...alsoNamed]) };
+  }
+
   /** readFactRows walks `individuals` in array order and the fold reads them in
    *  that order, so two peers holding an identical fact set can still fold it
    *  differently while their arrival orders differ. Sorting the Fact
@@ -293,6 +384,7 @@ export function createP2pRoom({
   async function baselineSeen() {
     await refreshRows();
     for (const row of cachedRows) seenProvenanceById.set(row.id, row.provenance);
+    for (const fact of cachedRetractions) seenRetractionValueById.set(fact.id, retractionDiffValue(fact));
   }
 
   async function ensureStarted() {
@@ -322,17 +414,24 @@ export function createP2pRoom({
   async function flushLocalChange() {
     await ensureStarted();
     await refreshRows();
+    await alignOwnRetractions();
     const changed = [];
     for (const row of cachedRows) {
       if (seenProvenanceById.get(row.id) === row.provenance) continue;
       seenProvenanceById.set(row.id, row.provenance);
       changed.push(row);
     }
+    for (const fact of cachedRetractions) {
+      const value = retractionDiffValue(fact);
+      if (seenRetractionValueById.get(fact.id) === value) continue;
+      seenRetractionValueById.set(fact.id, value);
+      changed.push(fact);
+    }
     if (!changed.length) return { broadcast: 0 };
     const targets = connectedPeers();
     if (!targets.length) return { broadcast: 0 };
     const timestamp = now();
-    const facts = changed.flatMap((row) => toWireFacts(row, wireIdentity(), timestamp));
+    const facts = changed.flatMap((row) => toWire(row, wireIdentity(), timestamp));
     broadcast(opMessage({ from: myPeerId, facts }));
     return { broadcast: changed.length };
   }
@@ -343,7 +442,17 @@ export function createP2pRoom({
     // Flush first: a local fact still waiting to be diffed would otherwise be
     // recorded as merged below and never leave this browser.
     await flushLocalChange();
-    const { ids } = await appendFacts(memoryDir, accepted.map((f) => ({
+    // Retractions land BEFORE the assertions in the same batch, so a peer
+    // sending both the fact and the record that suppresses it lands them in the
+    // order that leaves the fact out. Either order converges — the read fold
+    // strips a record a retraction covers however late the retraction arrives —
+    // but doing it this way keeps a suppressed record from being written at all.
+    const retractions = accepted.filter((f) => f.predicate === RETRACTION_PREDICATE);
+    if (retractions.length) await appendRetractions(memoryDir, retractions.map(localiseRetraction));
+    const assertions = retractions.length
+      ? accepted.filter((f) => f.predicate !== RETRACTION_PREDICATE)
+      : accepted;
+    const { ids } = assertions.length ? await appendFacts(memoryDir, assertions.map((f) => ({
       subject: f.subject,
       predicate: f.predicate,
       object: f.object,
@@ -353,15 +462,21 @@ export function createP2pRoom({
       // this is the passthrough that lets a dated taught fact's wire fact
       // reach it at all.
       ...(typeof f.observedAt === "string" && f.observedAt ? { observedAt: f.observedAt } : {}),
-    })));
+    }))) : { ids: [] };
     await sortFactIndividualsById();
     await refreshRows();
     const mergedIds = new Set(ids);
     for (const row of cachedRows) {
       if (mergedIds.has(row.id)) seenProvenanceById.set(row.id, row.provenance);
     }
-    emit(factsListeners, { merged: ids.length, rows: cachedRows });
-    return { merged: ids.length };
+    // Same reason the fact baseline above exists: a retraction that arrived
+    // from a peer must not go back out as though this node had authored it.
+    // Every peer broadcasts its OWN record when it makes one, so the union each
+    // peer ends up with is reached from the originals rather than from relays.
+    for (const fact of cachedRetractions) seenRetractionValueById.set(fact.id, retractionDiffValue(fact));
+    const merged = ids.length + retractions.length;
+    emit(factsListeners, { merged, rows: cachedRows });
+    return { merged };
   }
 
   function registerPeer(peerId, peerDisplayName, transport) {
@@ -436,8 +551,10 @@ export function createP2pRoom({
       case "sync-request": {
         const facts = await withStore(async () => {
           await refreshRows();
+          await alignOwnRetractions();
           const timestamp = now();
-          return syncableFacts(cachedRows).flatMap((row) => toWireFacts(row, wireIdentity(), timestamp));
+          return syncableFacts([...cachedRows, ...cachedRetractions])
+            .flatMap((row) => toWire(row, wireIdentity(), timestamp));
         });
         send(transport, syncResponseMessage({ facts }));
         return;
@@ -644,7 +761,9 @@ export function createP2pRoom({
       // from reading to every peer as a brand-new node.
       nodeId = await resolveStoreNodeId(memoryDir, nodeId || myNodeId);
       seenProvenanceById.clear();
+      seenRetractionValueById.clear();
       cachedRows = [];
+      cachedRetractions = [];
       const timestamp = now();
       const identity = [];
       if (worldId && worldName) identity.push(worldNameFact(worldId, worldName, timestamp));
@@ -655,11 +774,13 @@ export function createP2pRoom({
       }
       await refreshRows();
       for (const row of cachedRows) seenProvenanceById.set(row.id, row.provenance);
+      for (const fact of cachedRetractions) seenRetractionValueById.set(fact.id, retractionDiffValue(fact));
       const targets = connectedPeers();
       let pushed = 0;
       if (targets.length) {
         const wireTimestamp = now();
-        const facts = syncableFacts(cachedRows).flatMap((row) => toWireFacts(row, wireIdentity(), wireTimestamp));
+        const facts = syncableFacts([...cachedRows, ...cachedRetractions])
+          .flatMap((row) => toWire(row, wireIdentity(), wireTimestamp));
         pushed = facts.length;
         if (facts.length) broadcast(opMessage({ from: myPeerId, facts }));
         broadcast(syncRequestMessage());