@polycode-projects/the-mechanical-code-talker 6.0.19 → 6.0.21

package/src/services/chat.mjs

@@ -37,6 +37,12 @@ import { uuidv7 } from "../adapters/uuid.mjs";
 import * as defaultSource from "../adapters/source.mjs";
 import { loadTemplates, render as renderTemplate } from "../adapters/corpus/templates.mjs";
 import { rankByBiasThenTrust } from "../domain/memory/bias.mjs";
+import { compareFactsByContent } from "../domain/memory/fact-order.mjs";
+// Bare-string ordering for anything read out of the store that isn't a whole
+// fact row: a taught action family's name, a node id. Codepoint order, never
+// localeCompare — fact-order.mjs states the reason, and it applies to a
+// store-derived string just as much as to the row it came off.
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
 import { HAS_A_PREDICATE, foldedFactRows as foldStoreFactRows, loadMemory as loadMemoryStore, normFactPredicate, normFactTerm as normFactTermStatic, readFactRows as readStoredFactRows, readRuleRows as readStoredRuleRows } from "../adapters/memory/core.mjs";
 import { BACKEND_REJECTED_CODE, BACKEND_UNAVAILABLE_CODE } from "../adapters/memory/row-backend.mjs";
 import {
@@ -79,6 +85,7 @@ import { getChildPackProvider } from "../adapters/corpus/child-pack.mjs";
 import { dialogueActForLane } from "../domain/dialogue-acts.mjs";
 import { splitChoiceQuestion, routeChoiceRelation, lemmaFoldVariants, headNounOf, stemTopicCandidates, stemConstraintTerms } from "../domain/choice-question.mjs";
 import { subClassParents, subClassChildren, descendantSet, ancestryChain, clusterSenses } from "../domain/sense-split.mjs";
+import { buildSenseGate } from "../domain/sense-gate.mjs";
 import { ANSWER_STOP_SET } from "../domain/hub-terms.mjs";
 import { relatedForTerm } from "../domain/skos-view.mjs";
 import { ENUMERATION_LANES, answerAssertsASet, retrievalMarkerLine } from "../domain/retrieval-marker.mjs";
@@ -1050,7 +1057,7 @@ async function answerMemoryClassQuery(memoryDir, query) {
   try { ({ loadMemory, readFactRows } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   let mem;
   try { mem = await loadMemory(memoryDir); } catch { return null; }
-  const rows = cls === "Fact" ? readFactRows(mem) : null;
+  const rows = cls === "Fact" ? readFactRows(mem).slice().sort(compareFactsByContent) : null;
   const inds = rows || (mem.individuals || []).filter((i) => (i.class || "") === cls);
   if (countM) return { text: `${inds.length} ${inds.length === 1 ? plural.replace(/s$/, "") : plural}.`, kind: "count" };
   if (!inds.length) return { text: `I don't have any ${plural} stored yet.`, miss: true };
@@ -1071,13 +1078,6 @@ async function answerMemoryClassQuery(memoryDir, query) {
 // stealing the phrasing before a member count ever runs.
 const TAUGHT_CLASS_COUNT_RE = /^how\s+many\s+([a-z][\w-]*(?:\s+[a-z][\w-]*)*)\s*(.*)$/i;
 
-/** A fact row's deterministic identity for ordering. */
-const orderKeyOf = (f) => `${f.subject} ${f.predicate} ${f.object} ${f.provenance || ""}`;
-const orderKeyCompare = (a, b) => {
-  const ka = orderKeyOf(a); const kb = orderKeyOf(b);
-  return ka < kb ? -1 : ka > kb ? 1 : 0;
-};
-
 /** The store's subclass graph, both directions, built once per turn.
  *  Keyed on the rows array identity so a rebuilt row cache rebuilds the maps. */
 function classGraphFor(rows, cache) {
@@ -1097,7 +1097,7 @@ function taughtMembersUnder(isa, children, variants, biasByBundle) {
   for (const v of variants) for (const d of descendantSet(v, children)) classes.add(d);
   const isDirect = (f) => variants.has(f.object);
   const candidates = isa.filter((f) => isDirect(f) || classes.has(f.object));
-  const keyed = uniqueFacts(candidates).slice().sort(orderKeyCompare);
+  const keyed = uniqueFacts(candidates);
   const direct = rankByBiasThenTrust(keyed.filter(isDirect), biasByBundle);
   const inherited = rankByBiasThenTrust(keyed.filter((f) => !isDirect(f)), biasByBundle);
   return { direct, inherited, members: [...direct, ...inherited], classes };
@@ -1307,11 +1307,7 @@ async function answerCollectionContents(memoryDir, query, biasByBundle = {}, cac
   const containerRaw = restricted ? restricted[2] : unrestricted[1];
   const rows = await factRows(memoryDir, cache);
   const containerVariants = factTermVariants(normFactTerm, containerRaw);
-  // Sorted by content-addressed key before ranking, same discipline as
-  // taughtMembersUnder: rankByBiasThenTrust's own tiebreak is array index, so
-  // an unsorted filter would render two peers' facts in their own arrival
-  // order instead of one shared order.
-  const members = rows.filter((f) => CONTAINMENT_PREDICATES.includes(f.predicate) && containerVariants.has(f.object)).sort(orderKeyCompare);
+  const members = rows.filter((f) => CONTAINMENT_PREDICATES.includes(f.predicate) && containerVariants.has(f.object));
   if (!members.length) return null; // no containment rows at all — answerMembershipList keeps this noun
   const renderMembers = (list, noun) => {
     const ranked = rankByBiasThenTrust(uniqueFacts(list), biasByBundle);
@@ -3625,43 +3621,56 @@ const MINT_ISA_PREDICATES = new Set(["rdfs:subClassOf", "rdf:type"]);
  *  zorp is a thing"), then chain the other new term off the now-grounded one. */
 const GENERIC_ANCHOR_NOUNS = new Set(["thing", "concept", "object", "entity"]);
 
-/** Corpus source types treated as a real anchor for the isa-tier below.
- *  `corpus` is the band provenanceTagToSource (trust.mjs) assigns to
- *  corpus:<bundle>/child:<pack>:<term>/world:<name>/mud:<character> — a
- *  shipped isa row from one of those, not the operator's own words. Named
- *  explicitly, rather than "everything except corpusWeak/reference/web/...",
- *  so a new corpus band added later has to be added here on purpose before it
- *  can anchor anything: corpusWeak only ever carries mgx:relatedTo (already
- *  excluded by the predicate filter, named here too so a future corpus-weak
- *  isa row can't anchor silently); reference/referenceLive/extracted/
- *  optimisticExtract/web isa rows can be extraction artifacts, a wider band a
- *  benchmark would need to earn separately; provider-sourced code symbols
- *  already ground via isGroundedTerm's own resolveSymbol branch. */
-const CORPUS_ANCHOR_SOURCE_TYPES = new Set(["corpus"]);
-const isCorpusAnchorRow = (f) => !!f.sourceTypes?.some((t) => CORPUS_ANCHOR_SOURCE_TYPES.has(t));
+/** Source types treated as a real anchor for the isa-tier below: a reference
+ *  work's own claim that a term denotes a class, as against the operator's
+ *  own words. provenanceTagToSource (trust.mjs) assigns them:
+ *    corpus         corpus:<bundle>/child:<pack>:<term>/world:<name>/mud:<character>
+ *    reference      reference:<pack>:<article>@<revid>, the shipped
+ *                   revision-pinned pack (reference-pack.mjs)
+ *    referenceLive  research:<source>:<term>, a live KB-adapter lookup, and the
+ *                   live-Wikipedia supplement — the news enrichment cycle's own
+ *                   fetched definitions land here
+ *  Without that last band the cycle could define a term and still leave every
+ *  sentence naming it unreadable, so re-processing an article after a lookup
+ *  could never change its answer. reference sits beside referenceLive on its
+ *  own merit, not symmetry: it outranks referenceLive in SOURCE_PRIOR and is
+ *  where a preloaded bulk knowledge band would land, so anchoring the live
+ *  lookup while refusing the curated pinned pack would be incoherent.
+ *
+ *  Named explicitly, rather than "everything except corpusWeak/web/...", so a
+ *  band added later has to be added here on purpose before it can anchor
+ *  anything. What stays out and why: corpusWeak only ever carries
+ *  mgx:relatedTo (already excluded by the predicate filter, named here so a
+ *  future corpus-weak isa row can't anchor silently); extracted/
+ *  optimisticExtract/web isa rows are readings of running prose rather than a
+ *  reference work's own statement, which is the line this set draws;
+ *  provider-sourced code symbols already ground via isGroundedTerm's own
+ *  resolveSymbol branch. */
+const ANCHOR_SOURCE_TYPES = new Set(["corpus", "reference", "referenceLive"]);
+const isAnchorRow = (f) => !!f.sourceTypes?.some((t) => ANCHOR_SOURCE_TYPES.has(t));
 
 /** Every term that appears as the subject or object of an isa-family fact
  *  (MINT_ISA_PREDICATES), split into the two tiers the grounding checks below
- *  need: TAUGHT (isOperatorTaught) and CORPUS-ANCHORED (isCorpusAnchorRow). A
- *  row that is both (an operator teach merged onto an existing corpus row,
- *  same triple) lands in both Sets — no special case needed. Membership only:
- *  no ordering, no first-match, no wall clock, so the same fact set fed in
- *  any order produces identical Sets. */
+ *  need: TAUGHT (isOperatorTaught) and ANCHORED (isAnchorRow). A row that is
+ *  both (an operator teach merged onto an existing anchor-band row, same
+ *  triple) lands in both Sets — no special case needed. Membership only: no
+ *  ordering, no first-match, no wall clock, so the same fact set fed in any
+ *  order produces identical Sets. */
 function buildIsaTermIndex(rows) {
   const taught = new Set();
-  const corpusAnchored = new Set();
+  const anchored = new Set();
   for (const f of rows) {
     if (!MINT_ISA_PREDICATES.has(f.predicate)) continue;
     const taughtRow = isOperatorTaught(f);
-    const corpusRow = isCorpusAnchorRow(f);
-    if (!taughtRow && !corpusRow) continue;
+    const anchorRow = isAnchorRow(f);
+    if (!taughtRow && !anchorRow) continue;
     for (const term of [f.subject, f.object]) {
       if (!term) continue;
       if (taughtRow) taught.add(term);
-      if (corpusRow) corpusAnchored.add(term);
+      if (anchorRow) anchored.add(term);
     }
   }
-  return { taught, corpusAnchored };
+  return { taught, anchored };
 }
 export { buildIsaTermIndex };
 
@@ -3706,8 +3715,8 @@ async function normalizedFactTerm(term) {
  *  "store"; "every store is a container" then needs "store" to read as known
  *  even though it's not in the static lexicon at all).
  *
- *  This is the narrowest of three isa-anchor tiers: isCorpusAnchoredTerm
- *  (right below) anchors on a shipped corpus isa row instead of an
+ *  This is the narrowest of three isa-anchor tiers: isAnchoredTerm
+ *  (right below) anchors on an anchor-band isa row instead of an
  *  operator-taught one; isGroundedTerm (below that) folds in the static
  *  lexicon and GENERIC_ANCHOR_NOUNS too. A caller that specifically needs
  *  "the operator SAID this" — a proof chain citing its own warrant, a
@@ -3722,17 +3731,17 @@ async function isGroundedByFact(term, memoryDir, cache = null) {
   return (await isaTermIndex(memoryDir, cache)).taught.has(t);
 }
 
-/** CORPUS-ANCHORED tier of the isa-anchor ladder: true when `term` is the
- *  subject or object of an isa-family fact whose source is the corpus band
- *  (CORPUS_ANCHOR_SOURCE_TYPES) — a shipped bundle's own claim that the term
+/** ANCHORED tier of the isa-anchor ladder: true when `term` is the subject or
+ *  object of an isa-family fact whose source is the anchor band
+ *  (ANCHOR_SOURCE_TYPES) — a reference source's own claim that the term
  *  denotes a class, not necessarily anything the operator taught. See
  *  isAnchorableTerm, just below isGroundedTerm, for where this tier and the
  *  taught tier combine into "anchorable in any sense". */
-async function isCorpusAnchoredTerm(term, memoryDir, cache = null) {
+async function isAnchoredTerm(term, memoryDir, cache = null) {
   if (!memoryDir) return false;
   const t = await normalizedFactTerm(term);
   if (!t) return false;
-  return (await isaTermIndex(memoryDir, cache)).corpusAnchored.has(t);
+  return (await isaTermIndex(memoryDir, cache)).anchored.has(t);
 }
 
 /** A bare single alphabetic character ("a", "i", …) classify() resolves only
@@ -3772,14 +3781,14 @@ export { isGroundedTerm };
 
 /** "Anchorable in ANY sense" — everything isGroundedTerm already tests
  *  (static lexicon, GENERIC_ANCHOR_NOUNS, a resolved code-graph symbol, a
- *  prior-taught isa fact) PLUS the corpus-anchored tier (isCorpusAnchoredTerm,
- *  above): a term a shipped corpus bundle's own isa row already names as a
- *  class. isGroundedTerm itself stays exactly as narrow as before (it's
- *  exported and pinned by test/services/chat-grounding.test.mjs) — every
- *  widening onto the corpus tier goes through this function instead. */
+ *  prior-taught isa fact) PLUS the anchored tier (isAnchoredTerm, above): a
+ *  term an anchor-band source's own isa row already names as a class.
+ *  isGroundedTerm itself stays exactly as narrow as before (it's exported and
+ *  pinned by test/services/chat-grounding.test.mjs) — every widening onto the
+ *  anchor band goes through this function instead. */
 async function isAnchorableTerm(term, lex, memoryDir, cache = null, graph = null) {
   if (await isGroundedTerm(term, lex, memoryDir, cache, graph)) return true;
-  return isCorpusAnchoredTerm(term, memoryDir, cache);
+  return isAnchoredTerm(term, memoryDir, cache);
 }
 export { isAnchorableTerm };
 
@@ -4223,17 +4232,17 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon,
     && !/\s/.test(subjectRaw)
     && objectCarriesArticle(payload)
     && readsAsIndividualName(subjectRaw, lex);
-  // A PRIOR turn's minted term, a GENERIC_ANCHOR_NOUNS root, or a shipped
-  // corpus bundle's own isa row grounds Y just as legitimately as a static
-  // lexicon noun — all three are always treated as class-level (never
+  // A PRIOR turn's minted term, a GENERIC_ANCHOR_NOUNS root, or an
+  // anchor-band source's own isa row grounds Y just as legitimately as a
+  // static lexicon noun — all three are always treated as class-level (never
   // property), consistent with unknownObjectFallback (below) always minting
-  // a CLASS. Without the corpus-anchored check, "p is a kind of consonant"
-  // (both sides corpus-anchored, neither in the static lexicon) refuses; with
-  // it, "florb is a kind of glyph" also stores, minting "florb" — one
-  // anchored side is enough, the same rule the taught tier already applies.
+  // a CLASS. Without the anchor check, "p is a kind of consonant" (both sides
+  // anchored, neither in the static lexicon) refuses; with it, "florb is a
+  // kind of glyph" also stores, minting "florb" — one anchored side is
+  // enough, the same rule the taught tier already applies.
   if (lookupNoun(lex, objectRaw) || GENERIC_ANCHOR_NOUNS.has(String(objectRaw).toLowerCase())
     || (await isGroundedByFact(objectRaw, memoryDir, cache))
-    || (await isCorpusAnchoredTerm(objectRaw, memoryDir, cache))) {
+    || (await isAnchoredTerm(objectRaw, memoryDir, cache))) {
     return teachFact(memoryDir, sessionId, {
       subject,
       predicate: namedIndividual ? TYPE_PREDICATE : SUBCLASS_PREDICATE,
@@ -4338,9 +4347,9 @@ async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, c
   if (!/^(?:every|each|all|any)$/i.test((det || "").trim()) && !classIntent) return null; // class-level mint needs a universal quantifier or an explicit kind-of infix
   const { loadLexicon, lookupNoun } = await import("../domain/grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
-  // Anchorable (not just lexicon-grounded): a corpus-anchored subject earns
-  // the same mint a lexicon-grounded one does ("p is a kind of alphabet
-  // letter" — "p" anchored via a corpus isa row, "alphabet letter" minted).
+  // Anchorable (not just lexicon-grounded): an anchored subject earns the
+  // same mint a lexicon-grounded one does ("p is a kind of alphabet letter"
+  // — "p" anchored via a corpus isa row, "alphabet letter" minted).
   const subjectGrounded = await isAnchorableTerm(subjectRaw, lex, memoryDir, cache, graph);
   if (!subjectGrounded) return null; // ungrounded subject isn't this fallback's asymmetry — never a guessed mint
   // The OBJECT gate stays on isGroundedTerm, deliberately narrower than the
@@ -4449,15 +4458,15 @@ async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon
   if (/\s+(?:is|are)\s+an?\s+[\w-]+[.!?]*\s*$/i.test(String(payload).trim())) return null;
   const { loadLexicon, lookupNoun, lookupAdjective, classify } = await import("../domain/grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
-  // Y already a known NOUN, a fact-grounded CLASS term, or a corpus-anchored
-  // CLASS term — a genuine class-membership sentence, unknownSubjectFallback/
+  // Y already a known NOUN, a fact-grounded CLASS term, or an anchored CLASS
+  // term — a genuine class-membership sentence, unknownSubjectFallback/
   // unknownObjectFallback's own territory (already had first refusal on it)
-  // — never misread as a property. The corpus-anchored check is required
-  // here, not optional: without it a corpus-anchored object could be
-  // misread as a brand-new adjective instead of the class term it is.
+  // — never misread as a property. The anchor check is required here, not
+  // optional: without it an anchored object could be misread as a brand-new
+  // adjective instead of the class term it is.
   if (lookupNoun(lex, objectRaw) || GENERIC_ANCHOR_NOUNS.has(String(objectRaw).toLowerCase())
     || (await isGroundedByFact(objectRaw, memoryDir, cache))
-    || (await isCorpusAnchoredTerm(objectRaw, memoryDir, cache))) return null;
+    || (await isAnchoredTerm(objectRaw, memoryDir, cache))) return null;
   // CLASS-LEVEL adjective predication — "every snake is venomous": a universal
   // quantifier over a grounded noun class, with an adjective complement. The
   // quantifier is the same deliberate-generalization signal the article/
@@ -4472,7 +4481,7 @@ async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon
   // itself carries the safety here, so leaving this narrow would make
   // "every p is a glyph" teach while "every p is venomous" refuses, an
   // unpredictable asymmetry between two universally-quantified sentences
-  // over the same corpus-anchored subject.
+  // over the same anchored subject.
   // A bare GENERIC PLURAL subject with no determiner at all ("animals are
   // alive") carries the same implicit-universal reading matchBareHabitualTeach
   // already gives a bare plural verb subject ("dogs bark" mints the same
@@ -4502,13 +4511,13 @@ async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon
   const bareSubject = subjectRaw.replace(/^(?:the|an?)\s+/i, "").trim() || subjectRaw;
   const hadArticle = bareSubject !== subjectRaw;
   const capitalized = /^[A-Z]/.test(bareSubject);
-  // Deliberately isGroundedByFact (taught-only), NOT isCorpusAnchoredTerm or
+  // Deliberately isGroundedByFact (taught-only), NOT isAnchoredTerm or
   // isAnchorableTerm: this is the bare, unquantified property claim, where
   // NOTHING else stands in for the article/capitalization/quantifier
-  // "deliberate entity" signal this function's own docblock requires. Corpus
-  // anchoring a bare subject here would reopen the pinned "module is banana"
+  // "deliberate entity" signal this function's own docblock requires.
+  // Anchoring a bare subject here would reopen the pinned "module is banana"
   // regression under a new spelling — "dog is banana" would silently mint
-  // dog mgx:hasProperty banana, since "dog" is corpus-anchored via ConceptNet.
+  // dog mgx:hasProperty banana, since "dog" is anchored via ConceptNet.
   const factGrounded = await isGroundedByFact(bareSubject, memoryDir, cache);
   const genericAnchor = GENERIC_ANCHOR_NOUNS.has(bareSubject.toLowerCase());
   // A bare (no article, no capitalization) subject grounded ONLY via the
@@ -7147,8 +7156,8 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     } catch { /* lexicon unavailable — fall through to the generic message */ }
   }
   // Residue is what the STATIC lexicon didn't recognize. A token the fact
-  // store anchors — taught, corpus, or a code-graph symbol — is a word tmct
-  // does know, so it must not be named here. Only a token unknown under
+  // store anchors — taught, anchor-band, or a code-graph symbol — is a word
+  // tmct does know, so it must not be named here. Only a token unknown under
   // EVERY tier is. Deliberately not isAnchorableTerm: its classify branch
   // would drop a token the lexicon knows under the WRONG part of speech, and
   // that token genuinely IS the problem — this loop stays word-anchor-only.
@@ -7157,7 +7166,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     const survivors = [];
     for (const w of unknown) {
       if (await isGroundedByFact(w, memoryDir, cache)) continue;
-      if (await isCorpusAnchoredTerm(w, memoryDir, cache)) continue;
+      if (await isAnchoredTerm(w, memoryDir, cache)) continue;
       if (graph && resolveSymbol(graph, w)?.match) continue;
       survivors.push(w);
     }
@@ -8147,9 +8156,10 @@ function citationProvenance(provenance) {
 }
 
 /** What every rendered fact line ends with: the extractor's caveat, when the
- *  row carries a finding worth declaring, then the source citation. The order
- *  is fixed — a reader sees how the sentence was read, then who said it — and
- *  both halves are optional, so a clean untraced row ends with nothing at all.
+ *  row carries a finding worth declaring, then the speaker a report attributed
+ *  the claim to, then the source citation. The order is fixed — a reader sees
+ *  how the sentence was read, then who said it, then where it came from — and
+ *  every part is optional, so a clean untraced row ends with nothing at all.
  *
  *  A row whose extractor recorded a finding stays answerable (no lane declines
  *  a stored fact); the caveat is how the answer says which reading it leans
@@ -8158,7 +8168,24 @@ function citationProvenance(provenance) {
 function factLineTail(f) {
   const caveat = findingCaveat(f);
   const cite = f.provenance ? ` (source: ${citationProvenance(f.provenance)})` : "";
-  return `${caveat ? ` ${caveat}` : ""}${cite}`;
+  return `${caveat ? ` ${caveat}` : ""}${attributionClause(f)}${cite}`;
+}
+
+/** "(president trump said)" — the speaker a report attributed this claim to,
+ *  off the `attributedTo` the fold hangs on an attributed row. A claim stays
+ *  grounded and answerable either way; naming the speaker is what keeps the
+ *  answer from reading as tmct's own assertion.
+ *
+ *  Two speakers on one claim both get named: two outlets attributing one claim
+ *  to two people corroborate it, they do not disagree. Sorted and deduped, so
+ *  the line reads the same however the rows arrived. */
+function attributionClause(f) {
+  const speakers = [...new Set((Array.isArray(f?.attributedTo) ? f.attributedTo : []).filter(Boolean))].sort();
+  if (!speakers.length) return "";
+  const named = speakers.length === 1
+    ? speakers[0]
+    : `${speakers.slice(0, -1).join(", ")} and ${speakers[speakers.length - 1]}`;
+  return ` (${named} said)`;
 }
 
 /** Every extraction finding the rows behind ONE composed sentence carry. A
@@ -8168,6 +8195,14 @@ function composedExtraction(rows) {
   return rows.filter(Boolean).flatMap((r) => (Array.isArray(r.extraction) ? r.extraction : []));
 }
 
+/** Every speaker the rows behind ONE composed sentence were attributed to,
+ *  gathered the same way and for the same reason as the findings above: a
+ *  surface that cannot name the speaker must not print the claim, and a
+ *  composed sentence prints several rows at once. */
+function composedAttribution(rows) {
+  return rows.filter(Boolean).flatMap((r) => (Array.isArray(r.attributedTo) ? r.attributedTo : []));
+}
+
 /** One fact as an uncited-framing citation step: the phrase, its caveat and
  *  its source. Chains, both-sides refusals and "via:" receipts all read a
  *  premise this way — the same convention renderFactLine uses, without the
@@ -8215,14 +8250,20 @@ function renderFactLine(f) {
  *  row-per-member dump: "every pet is a cat or a dog (source: …)". `node` is
  *  the `<parent> rdfs:subClassOf <unionNode>` fact row (the parent and the
  *  citation both come from it); `members` are the union node's own
- *  `owl:unionOf` rows, sorted here by member name so the same union always
- *  reads back the same way regardless of the order its rows arrived in.
+ *  `owl:unionOf` rows, sorted here by content so the same union always
+ *  reads back the same way regardless of the order its rows arrived in, and
+ *  regardless of the reader's locale. Every member shares the union node's
+ *  subject and predicate, so content order is member name then source.
  *  Pure — takes the fact rows, returns one line. */
 function renderUnionLine(node, members) {
-  const sorted = [...members].sort((a, b) => a.object.localeCompare(b.object));
+  const sorted = [...members].sort(compareFactsByContent);
   // One sentence states every arm, so its caveat covers every row it was
   // composed from, not just the one the citation came off.
-  const tail = factLineTail({ ...node, extraction: composedExtraction([node, ...sorted]) });
+  const tail = factLineTail({
+    ...node,
+    extraction: composedExtraction([node, ...sorted]),
+    attributedTo: composedAttribution([node, ...sorted]),
+  });
   const arms = sorted.map((m) => `${indefiniteArticleFor(m.object)} ${m.object}`).join(" or ");
   return `every ${node.subject} is ${arms}${tail}`;
 }
@@ -8230,19 +8271,25 @@ function renderUnionLine(node, members) {
 /** An enumerated class's stored `owl:oneOf` triples read back as ONE sentence:
  *  "the primary colours are exactly red, yellow and blue (source: …)". `cls`
  *  is the enumerated class's own term; `members` are its `owl:oneOf` rows,
- *  sorted here by member name for the same order-independence renderUnionLine
- *  keeps. The class name pluralizes through the same naive "+s/+es/+ies" fold
+ *  sorted here by content for the same order- and locale-independence
+ *  renderUnionLine keeps; the source the line cites is read off the first
+ *  member in that order, so it settles the same way for every reader.
+ *  The class name pluralizes through the same naive "+s/+es/+ies" fold
  *  thirdPersonSingularSurface already applies to a verb lemma — the same
  *  accepted trade documented there. Pure — takes the fact rows, returns one
  *  line. */
 function renderEnumerationLine(cls, members) {
-  const sorted = [...members].sort((a, b) => a.object.localeCompare(b.object));
+  const sorted = [...members].sort(compareFactsByContent);
   const names = sorted.map((m) => m.object);
   const list = names.length > 1
     ? `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`
     : names.join("");
   const citeSource = sorted.find((m) => m.provenance)?.provenance;
-  const tail = factLineTail({ provenance: citeSource || "", extraction: composedExtraction(sorted) });
+  const tail = factLineTail({
+    provenance: citeSource || "",
+    extraction: composedExtraction(sorted),
+    attributedTo: composedAttribution(sorted),
+  });
   const plural = thirdPersonSingularSurface(String(cls || "").replace(/-/g, " "));
   return `the ${plural} are exactly ${list}${tail}`;
 }
@@ -8258,12 +8305,57 @@ function renderEnumerationLine(cls, members) {
 function renderUniversalRestrictionLine(node, rows) {
   const onProperty = rows.find((r) => r.predicate === "owl:onProperty");
   const allValuesFrom = rows.find((r) => r.predicate === "owl:allValuesFrom");
-  const tail = factLineTail({ ...node, extraction: composedExtraction([node, onProperty, allValuesFrom]) });
+  const tail = factLineTail({
+    ...node,
+    extraction: composedExtraction([node, onProperty, allValuesFrom]),
+    attributedTo: composedAttribution([node, onProperty, allValuesFrom]),
+  });
   const filler = thirdPersonSingularSurface(String(allValuesFrom?.object || "").replace(/-/g, " "));
   return `every ${node.subject} ${onProperty?.object || ""} only ${filler}${tail}`;
 }
 export { renderUnionLine, renderEnumerationLine, renderUniversalRestrictionLine };
 
+/** The read-time twin of sense-gate.mjs's screen on isa DERIVATION. The
+ *  WordNet-derived bands flatten every sense of a word onto one label —
+ *  "region" carries a geographic sense and an anatomical one, and both rows
+ *  store the same six characters — so a walk that climbs through the shared
+ *  label comes straight back down the other sense: russia ⊑ country ⊑
+ *  geographical area ⊑ region ⊑ body part. The offline closure already
+ *  refuses that step. The readers here walk the same edges live, one question
+ *  at a time, and so need the same screen.
+ *
+ *  Built over the ASSERTED isa rows only. An entailed row is the closure's
+ *  own output, and feeding that back in is what the gate exists to stop. A
+ *  stated row is never screened either: nothing here constrains what a corpus
+ *  or a teacher recorded, only what a multi-hop walk concludes on top of it.
+ *
+ *  Pure over the fact set — buildSenseGate sorts every frontier and memoizes
+ *  per term, so two ingestion orders of the same rows give the same verdicts.
+ *  Held on the caller's per-turn factRows cache and keyed on the row array
+ *  itself, so one turn builds one gate however many readers ask for it. */
+function readTimeSenseScreen(rows, cache = null) {
+  if (cache?.senseScreen?.rows === rows) return cache.senseScreen.gate;
+  const subClassEdges = [];
+  const typeEdges = [];
+  for (const f of rows || []) {
+    if (String(f.provenance || "").includes("entailed:")) continue;
+    if (f.predicate === SUBCLASS_PREDICATE) subClassEdges.push([f.subject, f.object]);
+    else if (f.predicate === TYPE_PREDICATE) typeEdges.push([f.subject, f.object]);
+  }
+  const gate = buildSenseGate({ subClassEdges, typeEdges });
+  if (cache) cache.senseScreen = { rows, gate };
+  return gate;
+}
+
+/** True when concluding `from ⊑ <the asked term>` would cross two senses the
+ *  screen holds apart. Every spelling variant of the asked term is tried: an
+ *  unplaced spelling resolves to no top and so blocks nothing, which is the
+ *  gate's own "one unresolved end lets it through" rule. */
+function senseScreenBlocksWalk(screen, from, toVariants) {
+  for (const to of toVariants) if (screen.declines(from, to)) return true;
+  return false;
+}
+
 /** Append an is-a object's superclass chain to its rendered fact line, before
  *  the caveat and the citation: "rover is a kind of dog" becomes "rover is a
  *  kind of dog → canine → mammal → animal". Only the subject-side is-a lines
@@ -8271,11 +8363,20 @@ export { renderUnionLine, renderEnumerationLine, renderUniversalRestrictionLine
  *
  *  `toward` steers the chain toward a specific ancestor (the class a "list …"
  *  question actually asked about) when the is-a object has more than one
- *  taught parent. */
-function renderFactLineWithChain(f, parents, subjectVariants, { toward = null } = {}) {
+ *  taught parent.
+ *
+ *  `screen` (readTimeSenseScreen's gate) trims the chain where it would cross
+ *  a sense join, so the rendered line stops at the last ancestor the fact's
+ *  own object really sits under rather than reading "…→ region → body part"
+ *  off a geographic subject. */
+function renderFactLineWithChain(f, parents, subjectVariants, { toward = null, screen = null } = {}) {
   const base = renderFactLine(f);
   if (!ISA_PREDICATES.has(f.predicate) || !subjectVariants.has(f.subject)) return base;
-  const chain = ancestryChain(f.object, parents, { cap: 6, stopAt: ANSWER_STOP_SET, toward });
+  let chain = ancestryChain(f.object, parents, { cap: 6, stopAt: ANSWER_STOP_SET, toward });
+  if (screen) {
+    const crossing = chain.findIndex((node, i) => i > 0 && screen.declines(f.object, node));
+    if (crossing > 0) chain = chain.slice(0, crossing);
+  }
   if (chain.length <= 1) return base;
   const suffix = ` → ${chain.slice(1).join(" → ")}`;
   const tail = factLineTail(f);
@@ -8292,10 +8393,11 @@ function renderFactLineWithChain(f, parents, subjectVariants, { toward = null }
  *  Returns `{ lines, grouped }`. `lines` is the flat, chain-enhanced rendering
  *  (indented by `indent`) the caller uses when senses do not split. `grouped`
  *  is a ready `{ text, replace, pending? }` answer when they do, else null. */
-function senseSplitFactList(hits, rows, subjectVariants, { indent = "" } = {}) {
+function senseSplitFactList(hits, rows, subjectVariants, { indent = "", cache = null } = {}) {
   const subClassEdges = rows.filter((f) => f.predicate === SUBCLASS_PREDICATE).map((f) => [f.subject, f.object]);
   const parents = subClassParents(subClassEdges);
-  const lines = hits.map((f) => `${indent}${renderFactLineWithChain(f, parents, subjectVariants)}`);
+  const screen = readTimeSenseScreen(rows, cache);
+  const lines = hits.map((f) => `${indent}${renderFactLineWithChain(f, parents, subjectVariants, { screen })}`);
 
   const isaSubjectFacts = hits.filter((f) => ISA_PREDICATES.has(f.predicate) && subjectVariants.has(f.subject));
   const isaObjects = [...new Set(isaSubjectFacts.map((f) => f.object))];
@@ -8313,7 +8415,7 @@ function senseSplitFactList(hits, rows, subjectVariants, { indent = "" } = {}) {
   const restItems = [];
   let shownCount = 0;
   const addLine = (f) => {
-    const rendered = renderFactLineWithChain(f, parents, subjectVariants);
+    const rendered = renderFactLineWithChain(f, parents, subjectVariants, { screen });
     if (shownCount < FACT_ANSWER_CAP) { shownCount += 1; return `${indent}${rendered}`; }
     restItems.push(rendered);
     return null;
@@ -8786,6 +8888,14 @@ const RECURSIVE_LIST_ASK_RE = /^list\s+(?:the\s+|all\s+)?([a-z][\w-]*)\s+of\s+([
 const ISA_ASK_RE = /^(?:is|are)\s+(?:an?\s+)?(.+?)\s+(?:a\s+kind\s+of|a\s+type\s+of|an?)\s+(.+?)[?.!\s]*$/i;
 const ISA_PREDICATES = new Set(["rdfs:subClassOf", "rdf:type"]);
 
+/** An already-ranked hit list with the subject's type facts moved to the
+ *  front, each half keeping its ranked order. What a thing IS answers "what is
+ *  X" more directly than anything else the store holds about it. */
+const definitionFirst = (hits) => [
+  ...hits.filter((f) => ISA_PREDICATES.has(f.predicate)),
+  ...hits.filter((f) => !ISA_PREDICATES.has(f.predicate)),
+];
+
 /** How far the isa ladder's miss text probes for a chain it can name a
  *  recovery for. Purely a REPORTING reach: the live chases answer within their
  *  own hop bounds and this never widens them, it only tells the miss whether
@@ -9434,9 +9544,12 @@ async function restrictionExistentialHit(memoryDir, cache, subjectVariants, fill
   // the ones meant to answer, including a provable "no".
   const subjectRestrictions = rows.filter((r) => r.predicate === SUBCLASS_PREDICATE && subjectVariants.has(r.subject)
     && onPropertyOf.has(r.object) && someValuesFromOf.has(r.object));
+  // Which restriction gets cited has to settle the same way for every reader,
+  // so the pick runs on the restriction node's id in codepoint order and falls
+  // through to the row's own content when two subject variants point at one node.
   const hit = subjectRestrictions
     .filter((r) => fillerVariants.has(someValuesFromOf.get(r.object)))
-    .sort((a, b) => a.object.localeCompare(b.object))[0];
+    .sort((a, b) => byCodepoint(a.object, b.object) || compareFactsByContent(a, b))[0];
   if (hit) {
     const byId = new Map(rows.map((r) => [r.id, r]));
     const premises = (hit.justification || [])
@@ -9853,7 +9966,7 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
       const containerVariants = factTermVariants(normFactTerm, containerRaw.replace(/^(?:an?|the)\s+/i, "").trim());
       const hits = (await factRows(memoryDir, cache)).filter(
         (f) => predicates.includes(f.predicate) && containerVariants.has(f.object),
-      ).sort(orderKeyCompare); // content-addressed order, not arrival order — see answerCollectionContents' own note
+      );
       if (hits.length) {
         const ranked = rankByBiasThenTrust(uniqueFacts(hits), biasByBundle);
         const lines = ranked.map(renderFactLine);
@@ -10049,10 +10162,15 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     }
     // Bias only REORDERS — every hit still renders and is cited (Part 6's
     // "disclosed, never dropped" contract). Unconfigured/tied bias degrades to
-    // trust-desc, byte-identical to before this feature existed.
-    hits = rankByBiasThenTrust(hits, biasByBundle);
+    // trust-desc.
+    //
+    // A definition then leads with what the subject IS. Bias and trust say
+    // nothing about that, and once they tie the isa row sorts wherever its
+    // predicate spelling happens to fall, so "what is a dog" opens on "dog can
+    // bark". Every other hit keeps its ranked place behind it.
+    hits = definitionFirst(rankByBiasThenTrust(hits, biasByBundle));
     const allRows = await factRows(memoryDir, cache);
-    const { lines, grouped } = senseSplitFactList(hits, allRows, variants);
+    const { lines, grouped } = senseSplitFactList(hits, allRows, variants, { cache });
     // A long undifferentiated "what is X" leads with the digest — a bounded
     // narrative over the same facts — and holds the full list behind the escape.
     // It wins over the sense-split grouping here: the digest's own selector
@@ -10657,12 +10775,21 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     // framing on, just above.
     const isTaughtFact = (f) => !String(f.provenance || "").includes("corpus:") && !String(f.provenance || "").includes("web:");
     const isaRows = rows.filter((f) => ISA_PREDICATES.has(f.predicate) && isTaughtFact(f));
+    // Each subject this walk collects is a claim that it is a subtype of the
+    // ASKED term — a conclusion the walk derives, never a row anyone stated —
+    // so it takes the same disjointness screen the offline closure applies to
+    // the same conclusion. Without it a sense-mixed label part-way up the
+    // chain carries the walk down the other sense, and "what do you know
+    // about body part" answers with facts about Russia.
+    const subtypeScreen = readTimeSenseScreen(rows, cache);
     const subtypeSubjects = new Set();
     let frontier = variants;
     for (let hop = 0; hop < 8 && frontier.size; hop += 1) {
       const nextSubjects = new Set();
       for (const f of isaRows) {
-        if (frontier.has(f.object) && !subtypeSubjects.has(f.subject)) nextSubjects.add(f.subject);
+        if (!frontier.has(f.object) || subtypeSubjects.has(f.subject)) continue;
+        if (senseScreenBlocksWalk(subtypeScreen, f.subject, variants)) continue;
+        nextSubjects.add(f.subject);
       }
       if (!nextSubjects.size) break;
       for (const s of nextSubjects) subtypeSubjects.add(s);
@@ -10761,7 +10888,7 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     hits = rankByBiasThenTrust(hits, biasByBundle);
     const header = `${hits.length} remembered fact${hits.length === 1 ? "" : "s"} about ${term}`
       + `${viaSubtype ? " (including its known subtypes)" : ""}:`;
-    const { lines, grouped } = senseSplitFactList(hits, rows, variants, { indent: "  " });
+    const { lines, grouped } = senseSplitFactList(hits, rows, variants, { indent: "  ", cache });
     if (grouped) return { ...grouped, text: `${header}\n${grouped.text}`, ...(weakOnly ? { weakOnly: true } : {}) };
     const shown = lines.slice(0, FACT_ANSWER_CAP);
     const rest = lines.slice(FACT_ANSWER_CAP);
@@ -10845,7 +10972,7 @@ async function whatElseAnswer(memoryDir, query, last) {
   let normFactTerm;
   try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   const variants = factTermVariants(normFactTerm, term);
-  const hits = (await memoryFacts(memoryDir)).filter((f) => variants.has(f.subject));
+  const hits = (await memoryFacts(memoryDir)).filter((f) => variants.has(f.subject)).sort(compareFactsByContent);
   const picture = pickPhrase("full-picture", term.toLowerCase(), "the full picture");
   const nothingMore = {
     text: `That's everything I know about "${term}" — /memory to see ${picture}.`,
@@ -10888,7 +11015,7 @@ async function synonymFactAnswer(memoryDir, query, envelope) {
   const facts = await memoryFacts(memoryDir);
   for (const { variant, source } of await synonymsOf(term)) {
     const variants = factTermVariants(normFactTerm, variant);
-    const hits = facts.filter((f) => variants.has(f.subject));
+    const hits = facts.filter((f) => variants.has(f.subject)).sort(compareFactsByContent);
     if (!hits.length) continue;
     const lines = hits.map(renderFactLine);
     const shown = lines.slice(0, FACT_ANSWER_CAP);
@@ -11263,7 +11390,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     if (!((fallThroughIsa && !/^there\b/i.test(fallThroughIsa[1].trim())) || CONFIRM_TAG_RE.test(q))) return null;
   }
   const isa = rows.filter((f) => ISA_PREDICATES.has(f.predicate));
-  const byTrust = (a, b) => b.trust - a.trust;
+  const byTrust = (a, b) => (b.trust - a.trust) || compareFactsByContent(a, b);
   const renderMany = (hits) => {
     const lines = hits.map(renderFactLine);
     const shown = lines.slice(0, FACT_ANSWER_CAP);
@@ -11812,9 +11939,17 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     //     technically-true-per-ConceptNet "yes" that has nothing to do with
     //     what the OPERATOR taught; only operator/teach/entailed-sourced isa
     //     facts are chased, matching "TAUGHT" in the gap's own name.
+    // Every chase from here down concludes a subsumption nobody stated, so
+    // each takes the same disjointness screen the offline closure applies to
+    // the same conclusion: a subject whose own asserted chain places it under
+    // a top disjoint from the asked class is not chased at all. A stated fact
+    // is untouched — the direct-hit and polarity branches above have already
+    // returned by the time this runs, so the screen only ever costs a walk.
+    const chaseSenseScreen = readTimeSenseScreen(rows, cache);
+    const chaseSubjects = [...subjCandidates].filter((s) => !senseScreenBlocksWalk(chaseSenseScreen, s, objVariants));
     const factForStep = (step) => (step.predicate === SC_PREDICATE ? chainSubClassRows : chainTypeRows)
       .find((f) => f.subject === step.subject && f.object === step.object);
-    for (const subj of subjCandidates) {
+    for (const subj of chaseSubjects) {
       const chain = findIsaChain(subj, objVariants, chainTypeEdges, chainSubClassSucc, { maxHops: 2 });
       if (!chain) continue;
       const chainRefusal = disjointRefusalFor(subj);
@@ -11835,7 +11970,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     // someValuesFrom chases keep their original, narrower discipline.
     const mixedFactForStep = (step) => (step.predicate === SC_PREDICATE ? mixedSubClassRows : mixedTypeRows)
       .find((f) => f.subject === step.subject && f.object === step.object);
-    for (const subj of subjCandidates) {
+    for (const subj of chaseSubjects) {
       const chain = findIsaChain(subj, objVariants, mixedTypeEdges, mixedSubClassSucc, { maxHops: 2 });
       if (!chain) continue;
       const chainRefusal = disjointRefusalFor(subj);
@@ -12015,7 +12150,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
             }
             : undefined;
         };
-        for (const subj of subjCandidates) {
+        for (const subj of chaseSubjects) {
           const chain = findIsaChain(subj, objVariants, chainTypeEdges, enlargedSubClassSucc, { maxHops: 3 });
           if (!chain) continue;
           const premises = chain.map(factForStepOrSvf);
@@ -12056,8 +12191,11 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     // exists, and telling someone to teach a fact that already follows from
     // what they taught is the mirror lie. The probe reads the SAME taught
     // edge lists the chases use, and /syllogise closes over a superset of
-    // them, so a chain found here is one it can really materialize.
-    const deeperChainExists = [...subjCandidates].some(
+    // them, so a chain found here is one it can really materialize. The
+    // screened subject list is what the probe walks for that reason: a chain
+    // across a sense join is one /syllogise's own gate would refuse, so
+    // offering it here would send the reader after a fact that never lands.
+    const deeperChainExists = chaseSubjects.some(
       (subj) => findIsaChain(subj, objVariants, chainTypeEdges, chainSubClassSucc, { maxHops: DEEP_CHAIN_PROBE_HOPS }),
     );
     // TRACK B1 — the automatic /prove fallback: every live chase above has
@@ -17174,7 +17312,7 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
       lines.push('taught actions: none yet — teach one ("you can move a disk onto a peg.") and /plan can use it.');
     } else {
       lines.push("taught actions (planned over, never dispatched):");
-      for (const [familyName, family] of [...families.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+      for (const [familyName, family] of [...families.entries()].sort(([a], [b]) => byCodepoint(a, b))) {
         const cap = capabilityFromActionRules(familyName, family);
         const sig = cap.parameters
           .map((p) => `${p.name}: ${p.classes.filter(Boolean).join("|") || "?"}`)
@@ -19129,7 +19267,9 @@ async function dispatchTurn(input, { config, source = defaultSource, graph = nul
         const separated = separateChoiceTie(grounded, constraintTerms, rowsAfterPull);
         if (separated) {
           const { winner, runnerUp, missedByRunnerUp } = separated;
-          const groundingFact = winner.facts.length > 0 ? winner.facts.slice().sort((a, b) => b.trust - a.trust)[0] : null;
+          const groundingFact = winner.facts.length > 0
+            ? winner.facts.slice().sort((a, b) => (b.trust - a.trust) || compareFactsByContent(a, b))[0]
+            : null;
           const groundingClause = groundingFact
             ? `${factPhrase(groundingFact)} (source: ${citationProvenance(groundingFact.provenance)})`
             : renderIsaChain(winner.chain);
@@ -19170,7 +19310,7 @@ async function dispatchTurn(input, { config, source = defaultSource, graph = nul
       // edge exists for the winning option — probeChoiceOptions' own guard.
       let text; let matches; let hop; let traversalNote; let matchedBy;
       if (winner.facts.length > 0) {
-        const fact = winner.facts.slice().sort((a, b) => b.trust - a.trust)[0];
+        const fact = winner.facts.slice().sort((a, b) => (b.trust - a.trust) || compareFactsByContent(a, b))[0];
         text = `${winner.text} — ${factPhrase(fact)} (source: ${citationProvenance(fact.provenance)}).`;
         matches = winner.facts;
         hop = 1;