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

package/src/adapters/memory/inspect.mjs

@@ -70,6 +70,17 @@ export function renderMemory({ memory, blocks }, { verbose = false } = {}) {
       }
     }
 
+    // ---- assertion spread: how many sources vouch for the most-corroborated
+    //      triple. A fact is stored one record per asserting source, so this is
+    //      the number that says when a group is getting big enough to be worth
+    //      compacting — reported so the moment is observable rather than
+    //      guessed at. ----
+    const widest = readFactRows(memory).reduce((a, b) => ((b.assertions?.length || 0) > (a?.assertions?.length || 0) ? b : a), null);
+    const spread = widest?.assertions?.length || 0;
+    if (spread > 1) {
+      lines.push("", `assertions — widest fact carries ${spread} independent sources: ${truncate(`${widest.subject} ${widest.predicate} ${widest.object}`, textCap)}`);
+    }
+
     // ---- contradictions: same (subject,predicate), differing object, both above
     //      the trust floor → surface BOTH with provenance, never silently pick ----
     const contradictions = findContradictions(memory);

package/src/adapters/memory/shacl.mjs

@@ -39,6 +39,22 @@ const RULE_SLOT_PROPS = {
 // abbreviation or a version ("v1.2", "core.mjs") stays a legal term.
 const SPANS_A_SENTENCE_BOUNDARY_RE = /[.!?]\s+\w/;
 
+// A Fact record's id: the content-addressed group key, then the Source key this
+// one assertion is filed under, then — only on a record its own source has since
+// superseded — the version that demoted it. Checked only for the two SUFFIXES,
+// never for the group part: a hand-built individual with a short opaque id is a
+// legitimate sparse write, and rejecting it is exactly the false positive this
+// gate must never produce. The source suffix is matched loosely on purpose — a
+// Source id legitimately carries colons, spaces and an `@revid` of its own
+// ("src:reference:simplewiki:Polar bear@912").
+const FACT_RECORD_ID_RE = /^[^@]+@(.+?)(#v[1-9][0-9]*)?$/;
+const looksLikeFactRecordId = (id) => id.includes("@") || /#v\d/.test(id);
+
+// mgx:supersedes / mgx:supersededBy hold a space-joined id LIST, not a single
+// value: one logical source can have two live replicas that each supersede the
+// same prior record before they ever sync, so a fork is real data, not a bug.
+const SUPERSESSION_LINK_PROPS = ["mgx:supersedes", "mgx:supersededBy"];
+
 function attrValue(ind, prop) {
   const a = (ind?.attributes || []).find((x) => x?.prop === prop);
   return a ? String(a.value ?? "") : undefined;
@@ -70,6 +86,28 @@ function checkFact(ind, violations) {
   }
   const prov = attrValue(ind, "mgx:factProvenance");
   if (prov !== undefined && !nonEmpty(prov)) violations.push("mgx:factProvenance, when present, must be non-empty");
+
+  const id = typeof ind?.id === "string" ? ind.id : "";
+  if (looksLikeFactRecordId(id) && !FACT_RECORD_ID_RE.test(id)) {
+    violations.push(`a Fact record id must read <groupId>@<sourceId>, optionally suffixed #v<n> once superseded (got ${JSON.stringify(id)})`);
+  }
+  const sourceId = attrValue(ind, "mgx:sourceId");
+  if (sourceId !== undefined && !nonEmpty(sourceId)) {
+    violations.push("mgx:sourceId, when present, must be non-empty (every assertion record has a key, src:none included)");
+  }
+  const observedAt = attrValue(ind, "mgx:observedAt");
+  if (observedAt !== undefined && !Number.isFinite(Date.parse(observedAt))) {
+    violations.push(`mgx:observedAt, when present, must be a parseable instant (got ${JSON.stringify(observedAt)})`);
+  }
+  for (const prop of SUPERSESSION_LINK_PROPS) {
+    const links = attrValue(ind, prop);
+    if (links === undefined) continue; // absent, never empty, until a chain's first supersession
+    const ids = links.split(" ").filter(Boolean);
+    if (!ids.length) violations.push(`${prop}, when present, must name at least one record id`);
+    for (const linked of ids) {
+      if (!FACT_RECORD_ID_RE.test(linked)) violations.push(`${prop} must name Fact record ids (got ${JSON.stringify(linked)})`);
+    }
+  }
 }
 
 /** RuleShape (mgx:RuleShape): a non-empty name; a kind from the closed

package/src/adapters/p2p/webrtc-transport.mjs

@@ -9,10 +9,16 @@
 // RTCPeerConnection's own state ("new" | "connecting" | "connected" | "failed"
 // | "closed"), so a caller can poll it without registering a handler.
 //
-// `iceServers` defaults to [] and this design keeps it empty: no STUN, no
-// TURN, no third party in the loop at all. Peers that cannot already reach
-// each other directly (same machine, same LAN, or a NAT that allows it) never
-// finish the handshake, which is the stated boundary of staying serverless.
+// `iceServers` defaults to DEFAULT_ICE_SERVERS below: a couple of public STUN
+// servers, no TURN, no relay — a STUN server only tells each peer its own
+// public-facing (server-reflexive) address; no application data ever passes
+// through it. Real-browser cross-engine testing found host-candidate-only
+// (no STUN) connections depend on OS-level local-network/mDNS behavior that
+// varies by machine and can fail for a real user even where the raw handshake
+// works in an automated test; STUN candidates sidestep that because they use
+// the peer's real address rather than an mDNS-obscured local one. TURN (a
+// relay that data actually flows through) is still not in scope — that's a
+// bigger trust/cost trade a STUN server isn't.
 //
 // Both `createOffer` and `createAnswerFor` resolve only once ICE gathering has
 // completed, so the SDP string they return already carries every candidate.
@@ -26,7 +32,11 @@
 
 const CHANNEL_LABEL = "tmct";
 
-export function createTransport({ iceServers = [] } = {}) {
+export const DEFAULT_ICE_SERVERS = [
+  { urls: ["stun:stun.l.google.com:19302", "stun:stun1.l.google.com:19302"] },
+];
+
+export function createTransport({ iceServers = DEFAULT_ICE_SERVERS } = {}) {
   const PeerConnection = globalThis.RTCPeerConnection;
   if (typeof PeerConnection !== "function") {
     throw new Error("no RTCPeerConnection here: this transport runs in a browser, not in bare node");
@@ -80,15 +90,28 @@ export function createTransport({ iceServers = [] } = {}) {
     if (state === "failed" || state === "closed") announceClose();
   });
 
+  // Bounded, not open-ended: a STUN request that never gets a reply (a
+  // dropped packet, a rate-limited public server, two peer connections in one
+  // tab racing for the same server) must not hang the offer/answer blob
+  // forever — the blob is still useful with only the host candidates it
+  // already has, and a caller waiting on it deserves a result either way.
+  const ICE_GATHERING_TIMEOUT_MS = 5000;
+
   async function whenIceGatheringCompletes() {
     if (connection.iceGatheringState === "complete") return;
     await new Promise((resolve) => {
+      let timer;
       const settle = () => {
         if (connection.iceGatheringState !== "complete") return;
+        clearTimeout(timer);
         connection.removeEventListener("icegatheringstatechange", settle);
         resolve();
       };
       connection.addEventListener("icegatheringstatechange", settle);
+      timer = setTimeout(() => {
+        connection.removeEventListener("icegatheringstatechange", settle);
+        resolve();
+      }, ICE_GATHERING_TIMEOUT_MS);
     });
   }
 

package/src/domain/ask-vocab.mjs

@@ -209,6 +209,11 @@ export const WORLD_RELATIONS = Object.freeze({
     comment: "individual -> place: where the subject is right now.",
     nouns: Object.freeze(["location", "locations", "position", "positions", "place", "places", "whereabouts", "room", "rooms"]),
     reads: "is in",
+    // A folded prepositional-verb predicate the teach path minted (mgx:rest-on,
+    // mgx:sit-in) says where its subject is, same as `predicate` above. This
+    // relation answers off those rows too, reading each one under its own
+    // preposition rather than under this entry's default `reads`.
+    matchesLocativePredicates: true,
   }),
   mood: Object.freeze({
     predicate: "mgx:feels",
@@ -235,6 +240,25 @@ export const WORLD_PREDICATES = Object.freeze(
   Object.values(WORLD_RELATIONS).map((r) => r.predicate),
 );
 
+/** The closed set of prepositions a folded prepositional-verb predicate ends in
+ *  when it states WHERE its subject is. A world writes its own placement rows
+ *  under WORLD_RELATIONS.placement's single predicate; a taught fact arrives as
+ *  whatever verb someone used, folded with the preposition they said it with
+ *  ("ann lives in paris" -> mgx:life-in), so the tail is the only thing that
+ *  marks it as a location rather than an arbitrary relation. */
+export const LOCATIVE_PREPOSITIONS = Object.freeze([
+  "on", "in", "at", "inside", "under", "below", "above", "near", "beside", "behind", "by",
+]);
+
+const LOCATIVE_PREDICATE_RE = new RegExp(`^mgx:[a-z]+-(${LOCATIVE_PREPOSITIONS.join("|")})$`, "i");
+
+/** The preposition a locative predicate folded ("mgx:rest-on" -> "on"), or null
+ *  when the predicate says nothing about where its subject is. */
+export function locativePreposition(predicate) {
+  const m = LOCATIVE_PREDICATE_RE.exec(String(predicate || ""));
+  return m ? m[1].toLowerCase() : null;
+}
+
 // The regular English 3rd-person-singular suffix rule (the same regular
 // -s/-es/-ies shape src/domain/inflect.mjs's own `pluralOf` applies to a
 // noun) — not imported from there, since inflect.mjs sits downstream of
@@ -280,6 +304,21 @@ export const WHERE_MARKERS = Object.freeze(["defined", "declared", "located", "i
  *  the term itself is free text, and only a listed word may be taken off it. */
 export const TRAILING_TEMPORAL_ADVERBS = Object.freeze(["now", "currently", "right now", "at the moment", "these days", "today"]);
 
+// Longest phrase first, or "right now" would lose only its "now" and leave a
+// stray "right" glued to the term.
+const TRAILING_TEMPORAL_ADVERB_RE = new RegExp(
+  `\\s+(?:${[...TRAILING_TEMPORAL_ADVERBS].sort((a, b) => b.length - a.length).join("|")})(\\s*[?.!]*)$`,
+  "i",
+);
+
+/** Take one trailing temporal adverb off a locative question ("where does ann
+ *  live now" -> "where does ann live"), leaving the question's own punctuation.
+ *  A question that IS the adverb keeps it — the strip needs something in front
+ *  of the word to be taking it off. */
+export function stripTrailingTemporalAdverb(text) {
+  return String(text || "").replace(TRAILING_TEMPORAL_ADVERB_RE, "$1");
+}
+
 /** Prose-mention markers: "where is X <marker>" -> the prose/mentions surface. */
 export const MENTION_MARKERS = Object.freeze(["mentioned", "referenced"]);
 

package/src/domain/ask.mjs

@@ -26,8 +26,8 @@ import {
   PASSIVE_PARTICIPLE_TO_KIND, GENERIC_AGENT_WORDS, REDUCED_RELATIVE_CLAUSES,
   AGGREGATE_TRIGGERS, LIST_TRIGGERS, SUPERLATIVE_EXTREMES, EDGE_NOUN_TO_METRIC, METRIC_IMPLIES_ENTITY, ANAPHORA_TRIGGERS,
   MEMBERSHIP_KINDS, CASCADE_NOISE, CASCADE_SYNONYMS, HELP_TRIGGERS,
-  WORLD_RELATIONS, WORLD_NOUN_TO_RELATION, WORLD_PREDICATES,
-  stripTrailingScopeFiller,
+  WORLD_RELATIONS, WORLD_NOUN_TO_RELATION, WORLD_PREDICATES, locativePreposition,
+  stripTrailingScopeFiller, stripTrailingTemporalAdverb,
 } from "./ask-vocab.mjs";
 import { expandContractions, normalizeQuery, applyNegationFrames, applyPhrasingFrames, matchNegationSet, STOPWORDS, splitWords, wordsOf, escapeRegex } from "./interpret/normalize.mjs";
 import { editDistance, fuzzyBound } from "./interpret/fuzzy.mjs";
@@ -178,6 +178,47 @@ function pruneSpuriousMeaningAmbiguity(parsed) {
   return metaC;
 }
 
+// "where does ann live", "where do the mice sleep", "where does startup get
+// defined" — a where question fronted by do/does/did. Its verb carries no
+// relation kind, so keyword-spot's where branch is the strategy that claims the
+// surface, and that branch has no verb slot: it drops the auxiliary as a stop
+// word and glues subject and verb into one term ("ann live"), which resolves
+// against nothing. The subject alone is the term asked about; the verb is the
+// sentence's predicate and rides in its own `verb` slot for a caller that mints
+// a predicate from it.
+const WHERE_AUX_LEAD_RE = /^where\s+(?:does|do|did)\s+/i;
+const WHERE_MARKER_WORDS = new Set(wordsOf(WHERE_MARKERS));
+
+function splitAuxFrontedWhereVerb(parsed, rawText) {
+  if (!parsed || parsed.shape !== "where" || parsed.altObject || !WHERE_AUX_LEAD_RE.test(rawText)) return parsed;
+  // The shared pre-pass takes a trailing temporal adverb off "where is X now",
+  // but the auxiliary fronts the verb past it ("where does ann live now"), so
+  // the adverb is still on the end here — and it sits exactly where this split
+  // looks for the verb.
+  const text = stripTrailingTemporalAdverb(rawText);
+  const objectText = stripTrailingTemporalAdverb(String(parsed.object || ""));
+  const withoutAdverb = objectText === parsed.object ? parsed : { ...parsed, object: objectText };
+  const objectWords = splitWords(objectText);
+  if (objectWords.length < 2) return withoutAdverb;
+  const verb = objectWords[objectWords.length - 1].toLowerCase();
+  if (!/^[a-z][a-z'-]*$/.test(verb) || STOPWORDS.has(verb) || VERB_TO_KIND[verb]) return withoutAdverb;
+  // do/does/did takes a bare infinitive, so a trailing participle ("where do i
+  // begin reading") is a complement and the tensed verb sits further left —
+  // dropping one word would leave a verb in the term either way, so decline.
+  if (verb.endsWith("ing")) return withoutAdverb;
+  // The auxiliary fronts the verb to the end of the sentence, so the glued word
+  // is only the predicate when it really sits there — a trailing where marker
+  // ("... get defined") is scaffolding keyword-spot already dropped.
+  const sentenceWords = splitWords(text).map((w) => w.toLowerCase());
+  while (sentenceWords.length && WHERE_MARKER_WORDS.has(sentenceWords[sentenceWords.length - 1])) sentenceWords.pop();
+  if (sentenceWords[sentenceWords.length - 1] !== verb) return withoutAdverb;
+  const subject = objectWords.slice(0, -1).join(" ");
+  // The glued reading stays reachable as `altObject`: traverse() prefers it when
+  // the subject alone doesn't resolve, so a graph holding an entity actually
+  // spelt that way still answers.
+  return { ...parsed, object: subject, altObject: objectText, verb };
+}
+
 export function parseQuery(query, { nlp = undefined } = {}) {
   return parseQueryFull(query, { nlp }).parsed;
 }
@@ -198,7 +239,7 @@ export function parseQueryFull(query, { nlp = undefined } = {}) {
   const merged = mergeStrategyResults(runStrategiesSync(text, { nlp: adapter, raw }));
   if (!merged) return { parsed: null, alternates: [], class: null };
   return {
-    parsed: pruneSpuriousMeaningAmbiguity(merged.parsed),
+    parsed: splitAuxFrontedWhereVerb(pruneSpuriousMeaningAmbiguity(merged.parsed), text),
     alternates: merged.alternates || [],
     class: merged.class || null,
   };
@@ -2299,13 +2340,12 @@ function renderComposite(parsed, result, graph) {
   // verbatim. Nothing is derived: an empty set is the honest miss, never a
   // sentence about a subject the world has no row for.
   if (result.compositeKind === "worldRelation") {
-    const asked = listJoin(result.askedClasses);
+    const asked = listJoin(result.asked);
     const noun = WORLD_RELATIONS[result.relation].nouns[1];
     if (!result.pairs.length) {
       return { content: `no ${noun} on record for ${asked} in this graph.`, miss: true, ambiguous: false, matches: [] };
     }
-    const reads = WORLD_RELATIONS[result.relation].reads;
-    const sentences = result.pairs.map((p) => `${p.subject.label || p.subject.id} ${reads} ${p.object}`);
+    const sentences = result.pairs.map((p) => `${p.subject.label || p.subject.id} ${p.reads} ${p.object}`);
     return { content: `${sentences.join("; ")}.`, miss: false, ambiguous: false, matches: result.matches };
   }
   // A non-empty inherited result is disclosed out loud ("X has no own <kind>
@@ -3829,7 +3869,14 @@ function renderCore(parsed, result, graph) {
         }
       }
     }
-    const noun = pool.length && pool.every((i) => i.class === "Commit") ? "commit" : "module";
+    // Candidates that all share one class are named by THAT class: a board's
+    // pegs are pegs, and calling them modules states something about the graph
+    // that isn't true. A class the curated noun table doesn't carry (a world's
+    // own taxonomy) reads as its own enum. Mixed grains keep "module".
+    const tiedClass = pool.length && pool.every((i) => i.class === pool[0].class) ? pool[0].class : null;
+    const noun = tiedClass
+      ? (PLURAL_FORMS[tiedClass] ? nounFor(tiedClass, 1) : classDisplayName(tiedClass))
+      : "module";
     const shown = pool.slice(0, OVERFLOW_CAP).map((i) => i.label);
     const extra = pool.length > OVERFLOW_CAP ? `, …and ${pool.length - OVERFLOW_CAP} more` : "";
     const lead = `"${parsed.object}" matches more than one ${noun} ambiguously — did you mean ${listJoin(shown)}${extra}? Try one of those. If you're not sure, narrow it to one name.`;
@@ -3843,9 +3890,17 @@ function renderCore(parsed, result, graph) {
     // preview is about. Swapped only when the literal ambiguous term still
     // appears as a whole word in that ONE branch's own text — every other
     // branch, and every non-branch render, is untouched.
+    //
+    // The candidate's own label is held out of the swap: a label that CONTAINS
+    // the term as a word ("peg" inside "peg-a") already names the candidate,
+    // and rewriting it there would grow it into "peg-a-a".
     const term = String(parsed.object || "");
     const termRe = term ? new RegExp(`\\b${escapeRegex(term)}\\b`, "gi") : null;
-    const branchText = (b) => (termRe ? b.rendered.content.replace(termRe, b.candidate.label) : b.rendered.content);
+    const branchText = (b) => {
+      const label = String(b.candidate.label || "");
+      if (!termRe || !label) return b.rendered.content;
+      return b.rendered.content.split(label).map((outsideLabel) => outsideLabel.replace(termRe, label)).join(label);
+    };
     const content = (branches && branches.length)
       ? `${lead}\n${branches.map((b, i) => `${i + 1}) ${b.candidate.label}: ${branchText(b)}`).join("\n")}`
       : lead;
@@ -4459,48 +4514,103 @@ const WORLD_LISTING_RE = new RegExp(
 // holds. A phrase that isn't a bare class noun ("where is auth.mjs defined")
 // fails parseWorldClassList and keeps the definition-site reading.
 const WORLD_WHERE_RE = /^where(?:'s|\s+is|\s+are)\s+(?:all\s+)?(?:the\s+)?(.+?)[?.!\s]*$/i;
+// "where does ann live", "where do the mice sleep" — the auxiliary-fronted
+// sibling of WORLD_WHERE_RE. The trailing verb is dropped rather than captured:
+// a stored relation is matched on its own folded preposition, not on the verb
+// the question happened to use, so group 1 is the subject alone and both shapes
+// hand this lane the same text.
+const WORLD_WHERE_AUX_RE = /^where\s+(?:does|do|did)\s+(?:all\s+)?(?:the\s+)?(.+?)\s+[a-z][a-z'-]*[?.!\s]*$/i;
+
+/** The single individual a question names ("where is ann"), or null when this
+ *  graph holds no individual of that name — or holds more than one, which is a
+ *  real ambiguity this lane declines rather than picking a side of. */
+function worldIndividualSubject(graph, text) {
+  const wanted = String(text || "").trim().toLowerCase();
+  if (!wanted) return null;
+  const ids = new Set();
+  for (const ind of graph?.individuals || []) {
+    if (!ind?.id) continue;
+    if (String(ind.id).toLowerCase() === wanted || String(ind.label || "").toLowerCase() === wanted) ids.add(ind.id);
+  }
+  return ids.size === 1 ? [...ids][0] : null;
+}
 
 /** Compile "<list trigger> the <world-relation noun> of <class> and <class>"
  *  (or "where are the <class> and <class>") into a world-relation listing AST,
- *  or null when this isn't that shape. */
+ *  or null when this isn't that shape. A subject that names no class is tried
+ *  as one named INDIVIDUAL, so "where is ann" reads a taught locative fact off
+ *  the same lane the board's own pieces answer through. Classes win the tie:
+ *  a graph where "pod" is both a class and an individual keeps its class
+ *  reading, exactly as before. */
 function worldRelationQuery(graph, query) {
-  const q = String(query || "").trim();
+  // "where is disk-1 now" asks the same question "where is disk-1" does, and the
+  // adverb would otherwise be bound as part of the subject.
+  const q = stripTrailingTemporalAdverb(String(query || "").trim());
   const listM = q.match(WORLD_LISTING_RE);
   const relation = listM ? WORLD_NOUN_TO_RELATION[listM[1].toLowerCase()] : "placement";
   if (!relation) return null;
-  const subjectText = listM ? listM[2] : q.match(WORLD_WHERE_RE)?.[1];
+  const subjectText = listM ? listM[2] : (q.match(WORLD_WHERE_RE)?.[1] || q.match(WORLD_WHERE_AUX_RE)?.[1]);
   if (!subjectText) return null;
+  const base = { node: "worldRelation", relation, predicate: WORLD_RELATIONS[relation].predicate };
   const resolved = parseWorldClassList(graph, subjectText);
-  if (!resolved) return null;
-  return {
-    node: "worldRelation",
-    relation,
-    predicate: WORLD_RELATIONS[relation].predicate,
-    classes: resolved.classes,
-    askedClasses: resolved.asked,
-  };
+  if (resolved) return { ...base, classes: resolved.classes, asked: resolved.asked };
+  const individual = worldIndividualSubject(graph, subjectText);
+  if (!individual) return null;
+  return { ...base, subjects: [individual], asked: [individual] };
 }
 
 const normalizePredicate = (p) => String(p || "").toLowerCase();
 
+/** The preposition a group's rows are stated with when they are a TAUGHT
+ *  locative fact rather than this relation's own curated predicate — "on" for
+ *  mgx:rest-on, "in" for mgx:life-in. Null for a group that says nothing about
+ *  where its subject is, and for a relation that isn't about placement. */
+function taughtLocativePreposition(relation, group) {
+  if (!WORLD_RELATIONS[relation].matchesLocativePredicates) return null;
+  return locativePreposition(normalizePredicate(group.prop))
+    || locativePreposition(normalizePredicate(group.predicate));
+}
+
 function evalWorldRelation(graph, ast) {
-  const wanted = new Set(ast.classes);
-  const latest = new Map();
+  const wantedClasses = ast.classes ? new Set(ast.classes) : null;
+  const wantedSubjects = ast.subjects ? new Set(ast.subjects) : null;
+  const entry = WORLD_RELATIONS[ast.relation];
+  const stated = new Map();
+  const taught = new Map();
   for (const group of graph?.relations || []) {
-    if (normalizePredicate(group.prop) !== ast.predicate && normalizePredicate(group.predicate) !== ast.predicate) continue;
-    // A world appends a fresh row per turn rather than rewriting one, so the
-    // LAST edge for a subject is its current value — the same last-wins fold
-    // every world's own state reader applies to its rows.
+    const prop = normalizePredicate(group.prop);
+    const predicate = normalizePredicate(group.predicate);
+    const statesRelation = prop === entry.predicate || predicate === entry.predicate;
+    const prep = statesRelation ? null : taughtLocativePreposition(ast.relation, group);
+    if (!statesRelation && !prep) continue;
     for (const edge of group.edges || []) {
       const subject = graph.byId?.get(edge.subject);
-      if (subject && wanted.has(subject.class)) latest.set(edge.subject, { subject, object: edge.object });
+      if (!subject) continue;
+      const kept = wantedSubjects ? wantedSubjects.has(edge.subject) : wantedClasses.has(subject.class);
+      if (!kept) continue;
+      // A world appends a fresh row per turn rather than rewriting one, so the
+      // LAST edge for a subject is its current value — the same last-wins fold
+      // every world's own state reader applies to its rows. A taught row keys
+      // on its predicate as well, because two taught locative facts about one
+      // subject are two separate claims and neither supersedes the other.
+      const pair = { subject, object: edge.object, reads: statesRelation ? entry.reads : `is ${prep}` };
+      if (statesRelation) stated.set(edge.subject, pair);
+      else taught.set(`${prop || predicate}\u0000${edge.subject}`, pair);
     }
   }
-  const pairs = [...latest.values()].sort((a, b) => String(a.subject.id).localeCompare(String(b.subject.id)));
+  // A graph that states this relation in its own predicate has already said
+  // where the subject is. A taught locative row about the same subject
+  // describes that position more loosely — a hanoi disk rests on a disk AND
+  // stands on a peg — so taught rows are read only for subjects the graph
+  // never placed outright.
+  const pairs = [...stated.values(), ...[...taught.values()].filter((p) => !stated.has(p.subject.id))]
+    .sort((a, b) => (
+      String(a.subject.id).localeCompare(String(b.subject.id)) || String(a.object).localeCompare(String(b.object))
+    ));
   return {
     compositeKind: "worldRelation",
     relation: ast.relation,
-    askedClasses: ast.askedClasses,
+    asked: ast.asked,
     pairs,
     matches: pairs.map((p) => p.subject),
   };
@@ -4547,7 +4657,7 @@ export function worldRelationGraphPayload(rows, { classOf = () => null } = {}) {
     const { base, stamp } = splitWorldSnapshot(row.subject);
     const cls = declaredClass.get(base) || classOf(base);
     if (!cls) continue;
-    const key = `${row.predicate}${base}`;
+    const key = `${row.predicate}\u0000${base}`;
     const prior = newest.get(key);
     if (prior && prior.stamp > stamp) continue;
     individuals.set(base, { id: base, label: base, class: cls });
@@ -4571,6 +4681,45 @@ const BARE_META_WHATIS_RE = /^what\s+(?:is|are)\s+(?:an?\s+)?(.+?)[?.!\s]*$/i;
 // is entity-term noise (resolveObject's own article strip) and is dropped.
 const WHATIS_FOR_FALLBACK_RE = /^what\s+is\s+(?:the\s+)?(?!(?:an?|it|this|that|these|those)\s)(.+?)\s+(?:used\s+)?for[?.!\s]*$/i;
 
+/** True when the name resolver's tie is not a second reading of the question at
+ *  all: every tied candidate belongs to ONE class, and the term the question
+ *  used is that class's own noun. "where are the disks" over a board of disk-1,
+ *  disk-2 and disk-3 ties on the pieces' names — but "disks" names the class
+ *  they are all members of, so the question is about the class, and offering
+ *  "did you mean disk-1, disk-2 or disk-3" answers a question nobody asked.
+ *
+ *  A genuine module-name ambiguity fails this: two modules both called store.mjs
+ *  tie on their names, and no class in the graph is called "store". */
+function tieNamesAClass(graph, parsed, result) {
+  const term = String(parsed?.object || "").trim();
+  if (!term) return false;
+  const cls = resolveDynamicClass(graph, term);
+  if (!cls) return false;
+  const tied = [result.objMatch, ...(result.candidates || [])].filter(Boolean);
+  const tiedIds = new Set(tied.map((i) => i.id));
+  if (tiedIds.size < 2) return false;
+  // One id can hold several class entries — a memory projection lists a taught
+  // term under every class it was taught, so the entry that ties is often the
+  // generic one. Membership is read across ALL of an id's entries, and the
+  // class's own word counts as one of them: a projection that lists "disk"
+  // itself as an individual ties it in alongside disk-1 and disk-2, and it is
+  // the word the question used rather than a rival reading of it.
+  const classesById = new Map();
+  for (const ind of graph?.individuals || []) {
+    if (!ind?.id) continue;
+    if (!classesById.has(ind.id)) classesById.set(ind.id, new Set());
+    classesById.get(ind.id).add(ind.class);
+  }
+  return [...tiedIds].every((id) => id === cls || classesById.get(id)?.has(cls));
+}
+
+/** The class-membership fallbacks below run once the cascade above has nothing
+ *  of its own to say: an honest miss, or a name tie that was really a reference
+ *  to a class. Each lane still has to answer for real before it is adopted. */
+const classLanesApply = (graph, parsed, result, rendered) => (rendered.ambiguous
+  ? tieNamesAClass(graph, parsed, result)
+  : !!rendered.miss);
+
 export function ask(graph, query, { contextId = null, nlp = undefined, prev = null } = {}) {
   if (isHelpRequest(query)) {
     return {
@@ -4595,9 +4744,9 @@ export function ask(graph, query, { contextId = null, nlp = undefined, prev = nu
   }
   let result = traverse(graph, parsed, { contextId, prev });
   let rendered = render(parsed, result, graph);
-  // Dynamic memory-graph class count/list fallback, only once everything
-  // above already produced an honest miss.
-  if (rendered.miss && !rendered.ambiguous) {
+  // Dynamic memory-graph class count/list fallback, only once everything above
+  // has had its turn and come back with nothing of its own.
+  if (classLanesApply(graph, parsed, result, rendered)) {
     const dyn = dynamicClassQuery(graph, query);
     if (dyn) {
       const dynResult = traverse(graph, dyn, { contextId, prev });
@@ -4606,8 +4755,8 @@ export function ask(graph, query, { contextId = null, nlp = undefined, prev = nu
     }
   }
   // World-relation listing ("list the locations of flies and spiders"), on the
-  // same terms: only after an honest miss, and only when it answers for real.
-  if (rendered.miss && !rendered.ambiguous) {
+  // same terms, and only when it answers for real.
+  if (classLanesApply(graph, parsed, result, rendered)) {
     const world = worldRelationQuery(graph, query);
     if (world) {
       const worldResult = traverse(graph, world, { contextId, prev });

package/src/domain/grammar/assert.mjs

@@ -25,8 +25,13 @@ export function provenanceTag({ source = "chat", sessionId = "", ts = "" } = {})
  *  `appendFact` (memory/core.mjs's, in the live wiring). Returns the parse
  *  result extended with `ids` (one fact id per triple, same order) and the
  *  provenance tag — or null (grammar miss, nothing written), or the residue
- *  parse (unknown words: triples empty, ids empty, nothing written). */
-export async function assertSentence(dir, sentence, { lexicon, provenance, appendFact } = {}) {
+ *  parse (unknown words: triples empty, ids empty, nothing written).
+ *
+ *  `observedAt`, when given, passes straight through to every appended fact
+ *  — the dated teach frame's own hook (chat.mjs's assertTurn strips the
+ *  "as of <date>" suffix before the sentence ever reaches parseAce, and
+ *  supplies the parsed instant here). */
+export async function assertSentence(dir, sentence, { lexicon, provenance, appendFact, observedAt } = {}) {
   if (typeof appendFact !== "function") {
     throw new TypeError("assertSentence needs an appendFact option (memory/core.mjs's writer) — the grammar never imports the store");
   }
@@ -37,6 +42,7 @@ export async function assertSentence(dir, sentence, { lexicon, provenance, appen
   for (const t of parse.triples) {
     const { id } = await appendFact(dir, {
       subject: t.subject, predicate: t.predicate, object: t.object, provenance: tag,
+      ...(observedAt ? { observedAt } : {}),
     });
     ids.push(id);
   }