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

package/data/mudiii-assets.json

@@ -5,7 +5,8 @@
     "Every GLB listed here uses EXT_meshopt_compression and KHR_mesh_quantization (verified by parsing each file's JSON chunk directly, not by trusting docs). Three additionally use EXT_texture_webp: creatures/goblin.glb, foliage/oak_1.glb, foliage/bush.glb. three.js's GLTFLoader decodes KHR_mesh_quantization and EXT_texture_webp natively, so nobody needs to hunt for a decoder for either of those. EXT_meshopt_compression is the one exception and needs exactly one line: loader.setMeshoptDecoder(MeshoptDecoder). See commands.vendorMeshoptDecoderLine below, and commands.fallbackTranscodeToPlainGlb if vendoring the decoder turns out to be undesirable.",
     "Food markers (cheese, apples, apple crate) are primitive geometry in v1, not models. The KayKit food props (food_cheese, food_apple_*, food_crate_large_apples) are almost certainly CC0 at source, but no CREDITS.md row names a KayKit resource pack, so they're unrecorded rather than free to take and are excluded here. Fetching the genuine KayKit Resource Bits pack from source (https://kaykit.itch.io) and adding a CREDITS.md row for it is a clean later upgrade, not a wall.",
     "The predator is creatures/fox.glb, not creatures/wolf_basic.glb. wolf_basic.glb looks like the obvious predator model and is close in name to the CREDITS 'Animated creatures' row, but wolf_basic.glb itself is an unrecorded custom Tripo-generated project asset, not the CC0 Quaternius wolf. fox.glb is covered by the CC0 Quaternius creatures row by name, shares the same quadruped rig (Idle/Walk/Gallop/Attack/hit-react/Death via manifest.ts's animal() clip map), and additionally ships an 'Eating' clip verified in the GLB itself -- useful for an eaten-flourish. goblin.glb is the prey/scavenger, matching world-of-claudecraft's own mob_kobold casting (Idle/Walk/Run/Attack/HitRecieve/Death) -- note HitRecieve is misspelled in the asset itself and is reproduced verbatim below, not corrected.",
-    "targetHeight is the model's own measured bounding-box height in metres (computed from each GLB's POSITION accessor bounds through its node transform chain, dequantizing normalized SHORT/BYTE components first), not an arbitrary guess -- these packs already ship in a consistent real-world scale, so no further per-item normalization judgment call was needed for the static props. The two character rigs (fox, goblin) use world-of-claudecraft's own manifest.ts height values instead, since their POSITION accessors are in skinned bind-pose space and a plain node-transform bbox walk (as used for the static props) does not account for joint transforms."
+    "targetHeight is the model's own measured bounding-box height in metres (computed from each GLB's POSITION accessor bounds through its node transform chain, dequantizing normalized SHORT/BYTE components first), not an arbitrary guess -- these packs already ship in a consistent real-world scale, so no further per-item normalization judgment call was needed for the static props. The two character rigs (fox, goblin) use world-of-claudecraft's own manifest.ts height values instead, since their POSITION accessors are in skinned bind-pose space and a plain node-transform bbox walk (as used for the static props) does not account for joint transforms.",
+    "food-crumb and food-morsel both reuse haybale.glb (measured bbox height 1.09m, a full-size bale) rather than the raw bbox height, because the render layer always rescales a loaded GLB to targetHeight (mudiii-scene.mjs's normalizeToHeight) regardless of the model's authored size. Their targetHeight values instead match the primitive spheres they replace (CRUMB_RADIUS 0.08, MORSEL_RADIUS 0.18 in mudiii-scene.mjs, doubled to a diameter) so the swap keeps the same on-ground footprint a fox already reads correctly against."
   ],
   "commands": {
     "verifyBytes": "stat -f '%z' <file>   # BSD/macOS; use `stat -c '%s' <file>` on GNU/Linux",
@@ -196,6 +197,30 @@
       "sha256": "614172ada35fc6048487a6af6d77059a5c031e0a93eff9d58036649ea0d16c12",
       "targetHeight": 1.57,
       "clips": null
+    },
+    {
+      "key": "food-crumb",
+      "sourcePath": "public/models/dungeon/haybale.glb",
+      "destPath": "public/models/props/haybale.glb",
+      "licence": "CC0-1.0",
+      "author": "Kay Lousberg (KayKit)",
+      "source": "https://github.com/KayKit-Game-Assets/KayKit-Dungeon-Remastered-1.0",
+      "bytes": 14004,
+      "sha256": "8b340af18ea1325d5a9bd4a967d3ef37bb90838ca2d90927b123e23877f7ddad",
+      "targetHeight": 0.16,
+      "clips": null
+    },
+    {
+      "key": "food-morsel",
+      "sourcePath": "public/models/dungeon/haybale.glb",
+      "destPath": "public/models/props/haybale.glb",
+      "licence": "CC0-1.0",
+      "author": "Kay Lousberg (KayKit)",
+      "source": "https://github.com/KayKit-Game-Assets/KayKit-Dungeon-Remastered-1.0",
+      "bytes": 14004,
+      "sha256": "8b340af18ea1325d5a9bd4a967d3ef37bb90838ca2d90927b123e23877f7ddad",
+      "targetHeight": 0.36,
+      "clips": null
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "5.0.2",
+  "version": "5.0.3",
   "private": false,
   "type": "module",
   "description": "The Mechanical Code Talker (tmct) — a tolerant, offline, $0 chat surface that guides you toward precision queries about a software repository. ELIZA/PARRY-style but domain-obsessed with code. No model calls; indexes a repo on request (tmct index) or reads any producer's graph.",

package/src/adapters/memory/core.mjs

@@ -46,6 +46,10 @@ import {
   ROLLUP_PRIOR_PROP, ROLLUP_EARLIEST_PROP, ROLLUP_LATEST_PROP, ROLLUP_COUNT_PROP,
   CHAIN_ROLLUP_THRESHOLD,
 } from "../../domain/memory/compaction.mjs";
+import {
+  planRetraction, mergeRetractions, retractionFromWire, retractionWireFact,
+  isRetractedRecord, RETRACTION_CLASS,
+} from "../../domain/memory/retraction.mjs";
 import { assertIndividualValid } from "./shacl.mjs";
 
 // The rollup vocabulary and its tuning constants live with the compaction
@@ -57,6 +61,15 @@ export {
   headRollupIdFor, chainRollupIdFor, isHeadRollupId, isChainRollupId, isRollupId,
 } from "../../domain/memory/compaction.mjs";
 
+// Same reasoning for the retraction vocabulary: the tombstone shape is the
+// domain layer's, and store consumers reach it through this one import site.
+export {
+  RETRACTION_CLASS, RETRACTION_PREDICATE,
+  RETRACTED_RECORD_IDS_PROP, RETRACTED_AT_PROP, RETRACTED_COUNT_PROP,
+  retractionIdFor, isRetractionId, retractionScopeOf,
+  retractedRecordIds, retractedAtOf, retractionWireFact, retractionFromWire,
+} from "../../domain/memory/retraction.mjs";
+
 export const MEMORY_DIR_REL = join(".tmct", "memory");
 export const MEMORY_GRAPH_REL = join(MEMORY_DIR_REL, "graph.json");
 
@@ -316,6 +329,16 @@ export function factGroupId(recordId) {
   return at < 0 ? id : id.slice(0, at);
 }
 
+/** The record id one provenance tag keys for a triple. A store files an
+ *  assertion under the Source its OWN tag derives, and a broadcast relabel
+ *  changes that Source — locally a chat session, at the peer the node that
+ *  sent it. So two stores hold one assertion under two ids, and anything that
+ *  has to name a record ACROSS the wire (a retraction does) resolves the id
+ *  through the tag rather than assuming both ends agree. */
+export function factRecordIdForTag(groupId, tag) {
+  return `${groupId}@${assertionSourceFor(tag).id}`;
+}
+
 /** The assertion key one provenance tag derives — the SAME closed derivation
  *  Source individuals already use, with the `src:none` singleton standing in
  *  for a tag that parses to no Source at all. Under this model every record
@@ -1354,10 +1377,15 @@ function buildMemoryIndex(payload) {
   // anyone asserting this yet" and an edge can resolve a group id to the real
   // nodes behind it, both without a scan.
   const factRecordsByGroup = new Map();
+  // groupId -> the retraction records standing over that triple, so the write
+  // path can ask "was this source's assertion retracted" without a scan. Almost
+  // always empty, which is why it is read before anything more expensive.
+  const retractionsByGroup = new Map();
   for (const ind of payload.individuals || []) {
     if (!ind?.id) continue;
     individualsById.set(ind.id, ind);
     if (ind.class === SOURCE_CLASS) sourcesById.set(ind.id, ind);
+    if (ind.class === RETRACTION_CLASS) indexRetraction(retractionsByGroup, ind);
     if (ind.class === FACT_CLASS) {
       const groupId = factGroupId(ind.id);
       const held = factRecordsByGroup.get(groupId);
@@ -1372,10 +1400,29 @@ function buildMemoryIndex(payload) {
     if (list) list.push(e.object);
     else statedByBySubject.set(e.subject, [e.object]);
   }
-  payload[MEMORY_INDEX] = { individualsById, sourcesById, statedByBySubject, factRecordsByGroup };
+  payload[MEMORY_INDEX] = { individualsById, sourcesById, statedByBySubject, factRecordsByGroup, retractionsByGroup };
   return payload[MEMORY_INDEX];
 }
 
+/** File one retraction record under the triple it stands over, replacing any
+ *  earlier reference to the same id — upsertIndividual merges in place, so the
+ *  index must hold the record the payload holds, not a stale copy of it. */
+function indexRetraction(retractionsByGroup, record) {
+  const groupId = factGroupId(record.id);
+  const held = (retractionsByGroup.get(groupId) || []).filter((r) => r.id !== record.id);
+  held.push(record);
+  retractionsByGroup.set(groupId, held);
+}
+
+/** Every retraction record standing over one triple. Reads the index when there
+ *  is one and falls back to a scan for a hand-built fixture, exactly as the
+ *  rollup lookup beside it does. */
+function retractionsFor(payload, groupId) {
+  const idx = memoryIndexOf(payload);
+  if (idx) return idx.retractionsByGroup.get(groupId) || [];
+  return (payload?.individuals || []).filter((i) => i?.class === RETRACTION_CLASS && factGroupId(i.id) === groupId);
+}
+
 /** The active lookup index for this payload, or null when this payload wasn't
  *  built by mutateMemory (a bare test fixture) — callers fall back to a
  *  linear scan in that case. */
@@ -1673,16 +1720,26 @@ function joinIfRollup(payload, prior, incoming) {
   return mergeRollups(prior, incoming, { priorFor: (sid) => assertionPrior(sourceType, sources[sid]) });
 }
 
+/** A retraction record joins the same way a summary does, by union of the ids
+ *  it carries — the difference is only which ids they are and what the reader
+ *  does with them. Everything that is neither keeps plain last-write-wins. */
+function joinIfReplicatedRecord(payload, prior, incoming) {
+  if (incoming?.class === RETRACTION_CLASS) return mergeRetractions(prior, incoming);
+  return joinIfRollup(payload, prior, incoming);
+}
+
 function upsertIndividual(payload, ind) {
   const idx = memoryIndexOf(payload);
   if (idx) {
     const prior = idx.individualsById.get(ind.id);
     if (prior) {
-      Object.assign(prior, joinIfRollup(payload, prior, ind));
+      Object.assign(prior, joinIfReplicatedRecord(payload, prior, ind));
+      if (prior.class === RETRACTION_CLASS) indexRetraction(idx.retractionsByGroup, prior);
       return prior;
     }
     payload.individuals.push(ind);
     idx.individualsById.set(ind.id, ind);
+    if (ind.class === RETRACTION_CLASS) indexRetraction(idx.retractionsByGroup, ind);
     if (ind.class === FACT_CLASS) {
       const groupId = factGroupId(ind.id);
       const held = idx.factRecordsByGroup.get(groupId);
@@ -1693,7 +1750,7 @@ function upsertIndividual(payload, ind) {
   }
   const i = payload.individuals.findIndex((x) => x?.id === ind.id);
   if (i >= 0) {
-    payload.individuals[i] = joinIfRollup(payload, payload.individuals[i], ind);
+    payload.individuals[i] = joinIfReplicatedRecord(payload, payload.individuals[i], ind);
     return payload.individuals[i];
   }
   payload.individuals.push(ind);
@@ -1884,16 +1941,28 @@ export function factRecordIdsFor(payload, groupId) {
  *  provenance-less write onto an already-asserted triple names no new source,
  *  so it files no second, unattributable sibling beside the real ones — its
  *  triple-level payload lands through restateFactGroup instead. */
-function assertionGroupsFor(payload, groupId, provenance) {
-  const groups = groupTagsBySource(provenance);
+function assertionGroupsFor(payload, groupId, provenance, createdAt = "") {
+  let groups = groupTagsBySource(provenance);
   if (groups.length === 1 && groups[0].sourceId === NO_SOURCE_ID) {
     if (factRecordIdsFor(payload, groupId).length) return [];
   }
-  // A source this group has already compacted away stays compacted. Every
-  // delivery path for a fact lands here, so this is where a late or re-synced
-  // copy of an absorbed assertion is recognized and dropped rather than
-  // inserted — without it the next sync resurrects everything compaction just
-  // folded, which is what makes deleting from a replicated set hard at all.
+  // A source whose assertion was retracted here does not come back on the next
+  // sync. This is the ingest half of the enforcement: every delivery path for a
+  // fact lands in this function, so a re-sent copy of a retracted assertion is
+  // recognized and dropped rather than re-materialized. The comparison is
+  // against the assertion's OWN embedded instant, so the same source saying the
+  // thing again — a fresh tag, a later moment — still lands.
+  const retractions = retractionsFor(payload, groupId);
+  if (retractions.length) {
+    groups = groups.filter((group) => !isRetractedRecord(
+      retractions,
+      `${groupId}@${group.sourceId}`,
+      assertionTimestampFor(group.tags, createdAt),
+    ));
+    if (!groups.length) return groups;
+  }
+  // A source this group has already compacted away stays compacted, for the
+  // same reason and at the same point.
   const rollups = headRollupsFor(payload, groupId);
   if (!rollups.length) return groups;
   return groups.filter((group) => !isAbsorbedSource(rollups, group.sourceId));
@@ -2226,7 +2295,7 @@ export async function appendFact(dir, { subject, predicate, object, provenance =
   const tokens = proseTokensFor({ doc: text });
   const q = normText(quantifier);
   await mutateMemory(dir, async (payload) => {
-    const groups = assertionGroupsFor(payload, groupId, normText(provenance));
+    const groups = assertionGroupsFor(payload, groupId, normText(provenance), createdAt);
     for (const id of groups.length ? [] : restateFactGroup(payload, groupId, { quantifier: q })) {
       syncFactSources(payload, storedIndividual(payload, id), undefined, { premiseTrusts, ruleConfidence });
     }
@@ -2311,7 +2380,7 @@ export async function appendFacts(dir, facts) {
     const seen = new Set();
     const trustOptsById = new Map();
     for (const f of prepared) {
-      const groups = assertionGroupsFor(payload, f.id, f.provenance);
+      const groups = assertionGroupsFor(payload, f.id, f.provenance, f.createdAt);
       // Naming no source, this write asserts nothing new — but its premise
       // environments and quantifier still belong on the records already there.
       for (const id of groups.length ? [] : restateFactGroup(payload, f.id, { quantifier: f.quantifier, environments: f.environments })) {
@@ -2799,7 +2868,15 @@ function factFoldContext(memory) {
   }
 
   const groups = new Map();
+  const retractionsByGroup = new Map();
   for (const ind of individuals) {
+    if (ind?.class === RETRACTION_CLASS) {
+      const groupId = factGroupId(ind.id);
+      const held = retractionsByGroup.get(groupId);
+      if (held) held.push(ind);
+      else retractionsByGroup.set(groupId, [ind]);
+      continue;
+    }
     if (ind?.class !== FACT_CLASS) continue;
     if ((ind.attributes || []).some((a) => a?.prop === SUPERSEDED_BY_PROP)) continue; // a demoted leaf, not a head
     if (isChainRollupId(ind.id)) continue; // a summary of one source's demoted history, which was never a vote
@@ -2809,6 +2886,24 @@ function factFoldContext(memory) {
     else groups.set(groupId, [ind]);
   }
 
+  // The read half of retraction enforcement. A record a peer re-delivered before
+  // its retraction arrived is still sitting in the payload, and this is what
+  // keeps it out of the answer: the fold is a pure function of the fact set, so
+  // both peers read the same row whichever order the two arrived in. Only a
+  // group that actually carries a retraction pays anything for the check.
+  for (const [groupId, retractions] of retractionsByGroup) {
+    const members = groups.get(groupId);
+    if (!members) continue;
+    const standing = members.filter((ind) => !isRetractedRecord(
+      retractions,
+      ind.id,
+      assertionTimestampFor(individualAttr(ind, "mgx:factProvenance").split(" | ").filter(Boolean), individualAttr(ind, CREATED_AT_PROP)),
+    ));
+    if (standing.length === members.length) continue;
+    if (standing.length) groups.set(groupId, standing);
+    else groups.delete(groupId);
+  }
+
   const groupsByPair = new Map();
   for (const [groupId, members] of groups) {
     // Codepoint order on the record id, which sorts by source key — the same
@@ -2935,21 +3030,48 @@ function foldFactGroup(id, heads, ctx) {
   };
 }
 
+/** The source key one record id belongs to: what sits between the `@` and any
+ *  chain or summary suffix. A record's own stored key wins when it has one; the
+ *  parse covers a demoted leaf and a summary, which carry the same key in their
+ *  id but do not all store it. */
+function recordSourceIdOf(record) {
+  const stored = individualAttr(record, SOURCE_ID_PROP);
+  if (stored) return stored;
+  const id = String(record?.id || "");
+  const at = id.indexOf("@");
+  if (at < 0) return "";
+  const rest = id.slice(at + 1);
+  const hash = rest.indexOf("#");
+  return hash < 0 ? rest : rest.slice(0, hash);
+}
+
 /** Retract facts by id — a real DELETE (syllogise.mjs's retractability
  *  mechanism). A GROUP id retracts the triple: every source's record for it,
  *  demoted leaves included, since retracting "dogs bark" cannot leave half its
  *  assertions standing. A single record id retracts just that record. Scrubs
  *  any edge referencing a removed id as subject or object; an orphaned Source
- *  is left in place (not a GC pass). Unknown ids are silently skipped. Returns
- *  { removed } — the ids asked for that matched, so it may be smaller than the
- *  input and is never longer than it. */
-export async function removeFacts(dir, ids) {
+ *  is left in place (not a GC pass). Unknown ids are silently skipped.
+ *
+ *  The delete leaves a RETRACTION RECORD behind, one per (triple, source),
+ *  carrying the record ids it suppressed and the moment it did. That record is
+ *  what makes the retraction survive a sync: a plain delete against a grow-only
+ *  set comes straight back from any peer that still holds the fact. It also
+ *  keeps the retraction on record rather than erasing the fact that something
+ *  was asserted at all. A retraction record is never itself removed here.
+ *
+ *  Returns { removed, records } — `removed` the ids asked for that matched, so
+ *  it may be smaller than the input and is never longer than it; `records` the
+ *  concrete record ids that went, which is what the retraction absorbed. */
+export async function removeFacts(dir, ids, { provenance = "", retractedAt = "" } = {}) {
   const idSet = new Set((ids || []).filter(Boolean));
   const removed = [];
-  if (!idSet.size) return { removed };
+  const records = [];
+  if (!idSet.size) return { removed, records };
+  const retractedAtVal = retractedAt || nowIso();
   await mutateMemory(dir, (payload) => {
     const removedSet = new Set();
     const matched = new Set();
+    const retiredByGroupAndSource = new Map(); // `${groupId}${sourceId}` -> { groupId, sourceId, ids, template }
     payload.individuals = (payload.individuals || []).filter((ind) => {
       if (ind?.class !== FACT_CLASS) return true;
       const groupId = factGroupId(ind.id);
@@ -2957,18 +3079,114 @@ export async function removeFacts(dir, ids) {
       if (!asked) return true;
       matched.add(asked);
       removedSet.add(ind.id);
+      const sourceId = recordSourceIdOf(ind);
+      const key = `${groupId}${sourceId}`;
+      // The record's own tags come along. They are the account of what was
+      // asserted and by whom, which a retraction keeps rather than erases, and
+      // they are also what lets a broadcast re-key this id onto the Source the
+      // receiving store files the same assertion under.
+      const tags = individualAttr(ind, "mgx:factProvenance");
+      const retired = retiredByGroupAndSource.get(key);
+      if (retired) {
+        retired.ids.push(ind.id);
+        if (tags) retired.tags.push(tags);
+      } else {
+        retiredByGroupAndSource.set(key, {
+          groupId,
+          sourceId,
+          ids: [ind.id],
+          tags: tags ? [tags] : [],
+          template: {
+            label: ind.label || "",
+            subject: individualAttr(ind, "rdf:subject"),
+            predicate: individualAttr(ind, "rdf:predicate"),
+            object: individualAttr(ind, "rdf:object"),
+          },
+        });
+      }
       return false;
     });
     for (const id of matched) removed.push(id);
     if (!removed.length) return; // honest no-op — nothing matched, no write needed beyond this
+    for (const id of removedSet) records.push(id);
     for (const group of payload.objectProperties || []) {
       const before = group.examples || [];
       group.examples = before.filter((e) => !removedSet.has(e?.subject) && !removedSet.has(e?.object));
       group.count = group.examples.length;
     }
+    for (const retired of retiredByGroupAndSource.values()) {
+      const record = planRetraction({
+        groupId: retired.groupId,
+        sourceId: retired.sourceId,
+        recordIds: retired.ids,
+        retractedAt: retractedAtVal,
+        template: retired.template,
+        provenance: [...retired.tags, provenance].filter(Boolean).join(" | "),
+      });
+      if (record) upsertIndividual(payload, record);
+    }
+    recountClasses(payload);
+  });
+  return { removed, records };
+}
+
+/** Every retraction record the store holds, as the wire facts that carry them.
+ *  The P2P layer's own diff and sync response read this: a retraction is not a
+ *  fact row, so nothing that walks readFactRows would ever find one. */
+export function readRetractions(memory) {
+  const out = [];
+  for (const ind of memory?.individuals || []) {
+    if (ind?.class !== RETRACTION_CLASS) continue;
+    const fact = retractionWireFact(ind);
+    if (fact) out.push(fact);
+  }
+  return out.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+
+/** Merge received retractions and enforce them. Two steps, and both are
+ *  needed: the record joins by union with whatever this store already held for
+ *  that (triple, source), then any assertion it now suppresses is dropped. The
+ *  second step is what makes a retraction that arrives AFTER the fact converge
+ *  with one that arrives before it.
+ *
+ *  Returns { merged, removed } — how many records landed, and the record ids the
+ *  enforcement took out. */
+export async function appendRetractions(dir, wireFacts) {
+  const incoming = [];
+  for (const fact of wireFacts || []) {
+    const record = retractionFromWire(fact);
+    if (record) incoming.push(record);
+  }
+  const removed = [];
+  if (!incoming.length) return { merged: 0, removed };
+  await mutateMemory(dir, (payload) => {
+    const suppress = new Map(); // groupId -> the merged retraction records over it
+    for (const record of incoming) {
+      const stored = upsertIndividual(payload, record);
+      const groupId = factGroupId(stored.id);
+      const held = suppress.get(groupId);
+      if (held) held.push(stored);
+      else suppress.set(groupId, [stored]);
+    }
+    // A retraction that names a triple this store never held is still stored —
+    // it has to be, or the fact arriving later would land unopposed.
+    const drop = new Set();
+    for (const [groupId, retractions] of suppress) {
+      for (const recordId of factRecordIdsFor(payload, groupId)) {
+        const stored = storedIndividual(payload, recordId);
+        if (!stored) continue;
+        const tags = individualAttr(stored, "mgx:factProvenance").split(" | ").filter(Boolean);
+        if (!isRetractedRecord(retractions, recordId, assertionTimestampFor(tags, individualAttr(stored, CREATED_AT_PROP)))) continue;
+        drop.add(recordId);
+      }
+    }
+    if (drop.size) {
+      dropAbsorbedRecords(payload, drop);
+      for (const id of drop) removed.push(id);
+    }
     recountClasses(payload);
   });
-  return { removed };
+  return { merged: incoming.length, removed };
 }
 
 /** The trust floor a fact must clear before a differing object counts as a real

package/src/domain/ask-vocab.mjs

@@ -222,7 +222,7 @@ export const WORLD_RELATIONS = Object.freeze({
     reads: "feels",
   }),
   mass: Object.freeze({
-    predicate: "mgx:mass",
+    predicate: "mgx:hasMass",
     comment: "individual -> number: the subject's current mass.",
     nouns: Object.freeze(["mass", "masses", "weight", "weights"]),
     reads: "has mass",

package/src/domain/ask.mjs

@@ -4575,12 +4575,16 @@ function evalWorldRelation(graph, ast) {
   const wantedClasses = ast.classes ? new Set(ast.classes) : null;
   const wantedSubjects = ast.subjects ? new Set(ast.subjects) : null;
   const entry = WORLD_RELATIONS[ast.relation];
+  // Both sides go through normalizePredicate: a curated predicate is written in
+  // whatever case its own vocabulary uses (mgx:hasMass), and comparing a
+  // lowercased row against a mixed-case constant matches nothing.
+  const wantedPredicate = normalizePredicate(entry.predicate);
   const stated = new Map();
   const taught = new Map();
   for (const group of graph?.relations || []) {
     const prop = normalizePredicate(group.prop);
     const predicate = normalizePredicate(group.predicate);
-    const statesRelation = prop === entry.predicate || predicate === entry.predicate;
+    const statesRelation = prop === wantedPredicate || predicate === wantedPredicate;
     const prep = statesRelation ? null : taughtLocativePreposition(ast.relation, group);
     if (!statesRelation && !prep) continue;
     for (const edge of group.edges || []) {
@@ -4617,16 +4621,23 @@ function evalWorldRelation(graph, ast) {
 }
 
 // A world writes each turn's facts against a stamped subject ("spider-1@turn3",
-// "player@step7") and folds them back onto the base id, newest stamp winning —
-// spider-fly.mjs's foldSpiderFlyState and domain.mjs's foldWorldState both do
-// exactly this. An unstamped row is the world's own starting value, stamp 0.
-const WORLD_SNAPSHOT_RE = /^(.+)@(?:turn|step)(\d+)$/;
+// "player@step7", "fox-1@epoch2@turn3" once a recast has moved it on) and folds
+// them back onto the base id, the newest (epoch, turn) winning — the same fold
+// predator-prey.mjs and domain.mjs both do. An unstamped row is the world's own
+// starting value, epoch 0, stamp 0. The base capture is lazy for the epoch
+// form's sake: a greedy one reads "fox-1@epoch2" as the base, an id no roster
+// matches, which drops every post-recast row out of the projection silently.
+const WORLD_SNAPSHOT_RE = /^(.+?)@(?:epoch(\d+)@)?(?:turn|step)(\d+)$/;
 
 function splitWorldSnapshot(term) {
   const m = WORLD_SNAPSHOT_RE.exec(String(term ?? ""));
-  return m ? { base: m[1], stamp: Number(m[2]) } : { base: String(term ?? ""), stamp: 0 };
+  if (!m) return { base: String(term ?? ""), epoch: 0, stamp: 0 };
+  return { base: m[1], epoch: m[2] ? Number(m[2]) : 0, stamp: Number(m[3]) };
 }
 
+const outranksSnapshot = (prior, epoch, stamp) =>
+  !prior || prior.epoch < epoch || (prior.epoch === epoch && prior.stamp <= stamp);
+
 /** Project plain world fact rows (`{subject, predicate, object}`, the shape
  *  memory/core.mjs's readFactRows returns) into the `{individuals,
  *  objectProperties}` payload parseEntities consumes, so a page holding a live
@@ -4654,14 +4665,13 @@ export function worldRelationGraphPayload(rows, { classOf = () => null } = {}) {
   const newest = new Map();
   for (const row of rows || []) {
     if (!row?.subject || !wanted.has(row.predicate)) continue;
-    const { base, stamp } = splitWorldSnapshot(row.subject);
+    const { base, epoch, stamp } = splitWorldSnapshot(row.subject);
     const cls = declaredClass.get(base) || classOf(base);
     if (!cls) continue;
     const key = `${row.predicate}\u0000${base}`;
-    const prior = newest.get(key);
-    if (prior && prior.stamp > stamp) continue;
+    if (!outranksSnapshot(newest.get(key), epoch, stamp)) continue;
     individuals.set(base, { id: base, label: base, class: cls });
-    newest.set(key, { stamp, predicate: row.predicate, subject: base, object: splitWorldSnapshot(row.object).base });
+    newest.set(key, { epoch, stamp, predicate: row.predicate, subject: base, object: splitWorldSnapshot(row.object).base });
   }
   const groups = new Map();
   for (const edge of newest.values()) {

package/src/domain/game-config.mjs

@@ -82,6 +82,12 @@ export const DEFAULT_GAME_CONFIG = Object.freeze({
     placedFoodMass: 2,
     maxPreyPopulation: 6,
     maxFoodItems: 8,
+    // Whether food only enters an agent's belief once it is within vision
+    // radius, the same as every other candidate. True by default — a crumb
+    // known to everyone the instant it spawns changes the foraging feel, and
+    // this is the one switch that turns that off (visionRadius: Infinity for
+    // the food-only belief call) without any new belief machinery.
+    foodVisionGated: true,
   }),
   guessNumber: Object.freeze({
     defaultLo: 1,
@@ -152,6 +158,7 @@ const MUDIII_KEY_MAP = Object.freeze({
   placed_food_mass: "placedFoodMass",
   max_prey_population: "maxPreyPopulation",
   max_food_items: "maxFoodItems",
+  food_vision_gated: "foodVisionGated",
 });
 
 const ADVENTURE_KEY_MAP = Object.freeze({

package/src/domain/interpret/normalize.mjs

@@ -123,6 +123,10 @@ export function correctMisspellings(text) {
   return String(text || "").replace(MISSPELLING_RE, (m) => MISSPELLINGS[m.toLowerCase()]);
 }
 
+/** 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. */
+export 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;
+
 const FILLER_RE = FILLER_WORDS.length
   ? new RegExp(
       "\\b(" + [...FILLER_WORDS].sort((a, b) => b.length - a.length).map(escapeRegex).join("|") + ")\\b\\s*,?",