@polycode-projects/the-mechanical-code-talker 6.0.18 → 6.0.20

package/src/domain/ask.mjs

@@ -43,6 +43,23 @@ import { pickPhrase } from "./answer-variants.mjs";
 export { normalizeQuery, applyNegationFrames };
 import { defaultNlp } from "./interpret/nlp-registry.mjs";
 
+/** Codepoint order, never localeCompare. Every string sorted through this is a
+ *  label, id or attribute value read off the graph. Several of these sorts get
+ *  read at `[0]` (the newest commit a query substitutes in, the entry-point
+ *  module a where-defined answer names) or cut to a top-N, so the comparator
+ *  picks WHICH individual the answer is about. A locale-sensitive compare would
+ *  let two readers ask one graph the same question and be told about different
+ *  commits. */
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
+/** Commits newest first, ties broken on the commit's own id. The date is
+ *  ISO-8601, so a codepoint compare IS the date compare, and undated commits
+ *  sort last. The id tiebreak is what makes `[0]` a pure function of the
+ *  graph: two commits sharing a date would otherwise be separated by whichever
+ *  edge happened to be walked first. */
+const byNewestCommit = (dateOf) => (a, b) =>
+  byCodepoint(dateOf(b), dateOf(a)) || byCodepoint(String(a.id), String(b.id));
+
 // Per-graph, per-kind memo; a local copy of codegraph.mjs's private
 // edgesOfKind. Named differently from codegraph.mjs's own cache: the inlined
 // viewer bundle concatenates a stripped codegraph.mjs + this file into one
@@ -2045,7 +2062,7 @@ function computeFind(graph, entityType, term) {
  *  the architecture map prints, so the two surfaces agree. */
 function packageIndividuals(graph) {
   return [...packageCounts(modulesOf(graph)).entries()]
-    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+    .sort((a, b) => b[1] - a[1] || byCodepoint(a[0], b[0]))
     .map(([dir]) => ({ id: `pkg:${dir}`, label: dir, class: "Package" }));
 }
 
@@ -2364,7 +2381,7 @@ export function degreeMetric(graph, ind, metric) {
 function evalRecentCommits(graph) {
   const commits = graph.individuals.filter((i) => i.class === "Commit");
   const dateOf = (c) => String((c.attributes || []).find((a) => a.key === "date")?.value || "");
-  commits.sort((a, b) => dateOf(b).localeCompare(dateOf(a)));
+  commits.sort(byNewestCommit(dateOf));
   return { compositeKind: "recentCommits", matches: commits };
 }
 
@@ -2407,7 +2424,7 @@ function evalCommitFilter(graph, ast) {
       if (op === "after") return d > pivotDate;
       return d === pivotDate; // "on"
     })
-    .sort((a, b) => dateOf(b).localeCompare(dateOf(a)) || String(a.id).localeCompare(String(b.id)));
+    .sort(byNewestCommit(dateOf));
   // A kind-headed window reads what the qualifying commits touched at that
   // grain; the bare shape answers with the commits themselves.
   const touched = entityType && entityType !== "Commit" && entityType !== "Change"
@@ -2450,7 +2467,7 @@ function evalTemporal(graph, ast, opts) {
   // reverseOverSet(touches) collects touching commits across both grains.
   const commits = reverseOverSet(graph, "touches", "Commit", ids);
   const dateOf = (c) => String((c.attributes || []).find((a) => a.key === "date")?.value || "");
-  commits.sort((a, b) => dateOf(b).localeCompare(dateOf(a)));
+  commits.sort(byNewestCommit(dateOf));
   return { compositeKind: "temporal", matches: commits, entityType: ast.entityType, innerCount: inner.length };
 }
 
@@ -3899,7 +3916,7 @@ function rankEntryPointModules(graph, term) {
       fixture: isTestFixturePath(ind.label) ? 1 : 0,
     }))
     .sort((a, b) => (b.named - a.named) || (a.depth - b.depth) || (a.fixture - b.fixture)
-      || String(a.ind.label).localeCompare(String(b.ind.label)))
+      || byCodepoint(String(a.ind.label), String(b.ind.label)))
     .map((x) => x.ind);
 }
 
@@ -3939,7 +3956,7 @@ function subclassClosure(graph, ind, kind) {
     found.set(next.id, next);
     queue.push(...childrenOf(next));
   }
-  return [...found.values()].sort((a, b) => String(a.label).localeCompare(String(b.label)));
+  return [...found.values()].sort((a, b) => byCodepoint(String(a.label), String(b.label)));
 }
 
 /** A graph's own vocabulary nodes carry their definition text under one of
@@ -4171,7 +4188,7 @@ export function traverse(graph, parsed, { contextId = null, prev = null, pinnedO
         const c = graph.byId.get(e.subject);
         if (c && c.class === "Commit") commits.push(c);
       }
-      commits.sort((a, b) => dateOf(b).localeCompare(dateOf(a)));
+      commits.sort(byNewestCommit(dateOf));
     }
     // The dated commit this answer named is a discourse `event` referent, so a
     // later "was that before X was touched" binds it (see evalCommitFilter).
@@ -4203,7 +4220,7 @@ export function traverse(graph, parsed, { contextId = null, prev = null, pinnedO
       const c = graph.byId.get(e.subject);
       if (c && c.class === "Commit") commits.push(c);
     }
-    commits.sort((a, b) => dateOf(b).localeCompare(dateOf(a)));
+    commits.sort(byNewestCommit(dateOf));
     // The dated commit behind the "who last touched X" answer is the same
     // `event` referent the when-shape registers, so either phrasing feeds a
     // later temporal comparison. Registered only when the commit carries a date.
@@ -5371,7 +5388,7 @@ function substituteLastCommitPhrase(graph, query) {
   const commits = graph.individuals.filter((i) => i.class === "Commit");
   if (!commits.length) return q;
   const dateOf = (c) => String((c.attributes || []).find((a) => a.key === "date")?.value || "");
-  const newest = [...commits].sort((a, b) => dateOf(b).localeCompare(dateOf(a)))[0];
+  const newest = [...commits].sort(byNewestCommit(dateOf))[0];
   if (!newest) return q;
   const out = q.replace(LAST_COMMIT_PHRASE_RE, `commit ${newest.label}`);
   const bareTrimmed = out.trim().replace(/[?.!]+$/, "");
@@ -5559,7 +5576,7 @@ function evalWorldRelation(graph, ast) {
   // 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))
+      byCodepoint(String(a.subject.id), String(b.subject.id)) || byCodepoint(String(a.object), String(b.object))
     ));
   return {
     compositeKind: "worldRelation",

package/src/domain/cli-verbs.mjs

@@ -58,12 +58,11 @@ export const CLI_VERBS = [
     prose: ["initialize a repo for tmct (default: cwd): .tmct/,"],
     flags: [
       { flag: "[--force]", prose: ["tmct.toml, .tmct/TOOLS.md (the cold-tool catalog),", "tier-1 corpus seed, provenance record"] },
-      { flag: "[--corpus <id|path>]", prose: ["also seed a corpus — a tier-2 manifest id (aws|python|java|", "general) or a jsonl file path — opt-in, offline, $0"] },
+      { flag: "[--corpus <id|path>]", prose: ["also seed a corpus — a bundle name (code|conceptnet|child|", "namenet|general) or a jsonl file path — opt-in, offline, $0"] },
       { flag: "[--ontology <name|path>]", prose: ["activate+seed an ontology bundle (a recognized name or a path)"] },
       { flag: "[--lexicon <name|path>]", prose: ["activate a lexicon bundle (recognized name or a path;", "merged read-time, never seeded — see mergedLexiconExtra)"] },
       { flag: "[--graph <path>]", prose: ["set graph_file/graph_files in tmct.toml (repeatable)"] },
       { flag: "[--config <path>]", prose: ["write to an alternate tmct.toml location"] },
-      { flag: "[--detect]", prose: ["suggest a tier-2 corpus from the repo's manifests", "(pyproject.toml → python, pom.xml → java); never seeds unasked"] },
       { flag: "[--with-persona <name>]", prose: ["write an explicit [extensions]/[bias] preset into tmct.toml", "(\"code\" — today's implicit default, made explicit)"] },
       { flag: "[--persona-size <medium|large>]", prose: ["grow the default \"human\" persona's fact count", "beyond Small (the default): \"medium\" activates", "human-medium.jsonl (~1,608 facts total), \"large\" also", "activates human-large.jsonl (~13,600 facts total,", "with genuine multi-hop hypernym chains) — additive", "size tiers of the SAME bundle, not separate personas"] },
       { flag: "[--memory-backend <default|memory|sqlite>]", prose: ["write tmct.toml's [memory] backend", "(same flag name as `tmct chat`) — a later `tmct chat`", "in this repo picks it up with no flag needed"] },
@@ -216,9 +215,9 @@ export const CLI_VERBS = [
     mode: "corpus",
     errorLabel: "corpus load",
     usage: "tmct corpus load <band> [--table <name>] [--source <path>] [--dry-run]",
-    prose: ["load a shared, read-only corpus band (wikidata-slice, wordnet-complete,"],
+    prose: ["load a shared, read-only corpus band (wordnet-complete, or a"],
     flags: [
-      { flag: "[--table <name>]", prose: ["conceptnet-full) into a DynamoDB row-backend table from a jsonl of", "wire-row-shaped facts (default table from TMCT_DYNAMO_TABLE); a", "source whose digest already matches the band's manifest is a no-op"] },
+      { flag: "[--table <name>]", prose: ["consumer's own) into a DynamoDB row-backend table from a jsonl of", "wire-row-shaped facts (default table from TMCT_DYNAMO_TABLE); a", "source whose digest already matches the band's manifest is a no-op"] },
       { flag: "[--source <path>]", prose: ["the band's jsonl (a scripts/corpus-bands/ build output, or any jsonl", "in the same wire-row shape)"] },
       { flag: "[--dry-run]", prose: ["report the row count and source digest without writing anything"] },
     ],

package/src/domain/completions/group.mjs

@@ -9,6 +9,11 @@ import { requireInjected } from "./injected.mjs";
 
 const LABEL_TOKEN_COUNT = 5;
 
+// Codepoint order, never localeCompare — hit ids and content tokens trace
+// back to the memory store, and two readers must land on the same order
+// regardless of locale.
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
 /** Plain union-find (path halving, union-by-index) — small N here (a single broad search's
  *  hit count). */
 function unionFind(n) {
@@ -83,7 +88,7 @@ export function groupHits(hits, { overlapMin, store } = {}) {
   for (const memberIdx of componentIdx.values()) {
     const members = memberIdx
       .map((i) => byId.get(ids[i]))
-      .sort((a, b) => a.id.localeCompare(b.id));
+      .sort((a, b) => byCodepoint(a.id, b.id));
     const memberIds = members.map((m) => m.id);
 
     // label tokens: rank by member coverage, then IDF, then token text (deterministic).
@@ -92,7 +97,7 @@ export function groupHits(hits, { overlapMin, store } = {}) {
       for (const t of new Set(tokensById[ids[i]])) coverage.set(t, (coverage.get(t) || 0) + 1);
     }
     const tokens = [...coverage.keys()]
-      .sort((a, b) => (coverage.get(b) - coverage.get(a)) || (idf(b) - idf(a)) || a.localeCompare(b))
+      .sort((a, b) => (coverage.get(b) - coverage.get(a)) || (idf(b) - idf(a)) || byCodepoint(a, b))
       .slice(0, LABEL_TOKEN_COUNT);
 
     groups.push({
@@ -104,6 +109,6 @@ export function groupHits(hits, { overlapMin, store } = {}) {
     });
   }
 
-  groups.sort((a, b) => a.memberIds[0].localeCompare(b.memberIds[0]));
+  groups.sort((a, b) => byCodepoint(a.memberIds[0], b.memberIds[0]));
   return groups;
 }

package/src/domain/completions/infer.mjs

@@ -16,6 +16,11 @@ import { requireInjected } from "./injected.mjs";
 // supply their own copy in the `helpers` bag resolveRelationChase expects.
 const HAS_PROPERTY_PREDICATE = "mgx:hasProperty";
 
+// Codepoint order, never localeCompare — group ids trace back to memory-store
+// block ids, and two readers must land on the same relation order regardless
+// of locale.
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
 // The taught ISA-family predicates (stored edges only, not their transitive closure).
 const ISA_PREDICATES = new Set(["rdfs:subClassOf", "rdf:type"]);
 
@@ -281,7 +286,7 @@ export async function inferRelations(groups, memory, { store } = {}) {
     relationNames: relationNameCandidates(rows),
   };
 
-  const sorted = list.slice().sort((x, y) => x.id.localeCompare(y.id));
+  const sorted = list.slice().sort((x, y) => byCodepoint(x.id, y.id));
   const out = [];
 
   for (let i = 0; i < sorted.length; i += 1) {
@@ -311,6 +316,6 @@ export async function inferRelations(groups, memory, { store } = {}) {
     }
   }
 
-  out.sort((x, y) => x.from.localeCompare(y.from) || x.to.localeCompare(y.to) || x.relation.localeCompare(y.relation));
+  out.sort((x, y) => byCodepoint(x.from, y.from) || byCodepoint(x.to, y.to) || byCodepoint(x.relation, y.relation));
   return out;
 }

package/src/domain/completions/prune.mjs

@@ -8,6 +8,10 @@
 
 const DEFAULT_MAX_SENTENCES_PER_GROUP = 3;
 
+// Codepoint order, never localeCompare — group ids trace back to memory-store
+// block ids, and two readers must land on the same order regardless of locale.
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
 /** Every group id referenced as either side of an asserted relation. */
 function relatedGroupIdsOf(relations) {
   const set = new Set();
@@ -56,7 +60,7 @@ export function pruneCompletion(state = {}, { maxSentencesPerGroup = DEFAULT_MAX
 
   const relatedGroupIds = relatedGroupIdsOf(relations);
 
-  const sortedGroups = groups.slice().sort((a, b) => a.id.localeCompare(b.id));
+  const sortedGroups = groups.slice().sort((a, b) => byCodepoint(a.id, b.id));
   for (const g of sortedGroups) {
     const ranked = Array.isArray(rankedByGroup[g.id]) ? rankedByGroup[g.id] : [];
     const groupFeedsInference = relatedGroupIds.has(g.id);

package/src/domain/completions/rank.mjs

@@ -12,6 +12,11 @@ import { requireInjected } from "./injected.mjs";
 // (no abbreviation dictionary).
 const SENTENCE_SPLIT_RE = /(?<=[.!?])\s+(?=[A-Z0-9])/;
 
+// Codepoint order, never localeCompare — sourceBlockId traces back to the
+// memory store's block ids, and two readers must land on the same rank order
+// regardless of locale.
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
 /**
  * Split raw block text into trimmed, non-empty sentences (order-preserving, no dedup).
  *
@@ -89,7 +94,7 @@ export function rankSentences(group, { overlapMin, query = null, store } = {}) {
   });
 
   scored.sort((a, b) => b.score - a.score
-    || a.sourceBlockId.localeCompare(b.sourceBlockId)
-    || a.sentence.localeCompare(b.sentence));
+    || byCodepoint(a.sourceBlockId, b.sourceBlockId)
+    || byCodepoint(a.sentence, b.sentence));
   return scored;
 }

package/src/domain/digest/compose.mjs

@@ -12,6 +12,10 @@ import DEFAULT_CONFIG from "./config.json" with { type: "json" };
 
 const DESCRIPTION_FAMILIES = FAMILY_PRIORITY.filter((f) => f !== "isa" && f !== "other");
 
+/** Codepoint order, never localeCompare — an ontology root is a class name
+ *  read off stored facts, so two locales have to name the same roots. */
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
 /** Group the selector's `selected` items by family, preserving each item's
  *  ranked order, and return `{ family -> rows[] }` over the fact rows. */
 function rowsByFamily(selected) {
@@ -82,7 +86,7 @@ export function closerRootsFor(chains, usedRows, count) {
     rootRows.get(root).push(row);
   }
   const roots = [...rootCount.keys()]
-    .sort((a, b) => (rootCount.get(b) - rootCount.get(a)) || a.localeCompare(b))
+    .sort((a, b) => (rootCount.get(b) - rootCount.get(a)) || byCodepoint(a, b))
     .slice(0, Math.max(0, count));
   const rows = [];
   const seen = new Set();

package/src/domain/digest/select.mjs

@@ -25,7 +25,12 @@
 // the ranking stays auditable.
 
 import { SOURCE_PRIOR } from "../memory/trust.mjs";
+import { compareFactsByContent } from "../memory/fact-order.mjs";
 import { clusterSenses } from "../sense-split.mjs";
+
+/** Codepoint order, never localeCompare — a cluster label is a class name read
+ *  off stored facts, so two locales have to land on the same dominant sense. */
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
 import DEFAULT_CONFIG from "./config.json" with { type: "json" };
 
 // A relation predicate -> the sentence-family key the digest groups it under.
@@ -148,7 +153,7 @@ export function selectFacts(term, rows, store = {}, opts = {}) {
   }
   let dominantLabel = null;
   let bestWeight = -1;
-  for (const [label, weight] of [...clusterWeight].sort((a, b) => a[0].localeCompare(b[0]))) {
+  for (const [label, weight] of [...clusterWeight].sort((a, b) => byCodepoint(a[0], b[0]))) {
     if (weight > bestWeight) { bestWeight = weight; dominantLabel = label; }
   }
 
@@ -186,16 +191,17 @@ export function selectFacts(term, rows, store = {}, opts = {}) {
     else eligible.push(item);
   }
 
-  // Breadth-first cut to budget: each family sorted by score (tie broken by
-  // object label for determinism), then pulled round-robin in family priority
-  // order so the digest covers relations before it repeats one.
+  // Breadth-first cut to budget: each family sorted by score (ties broken on
+  // the fact's own content, never on the order it arrived), then pulled
+  // round-robin in family priority order so the digest covers relations before
+  // it repeats one.
   const byFamily = new Map();
   for (const item of eligible) {
     if (!byFamily.has(item.family)) byFamily.set(item.family, []);
     byFamily.get(item.family).push(item);
   }
   for (const list of byFamily.values()) {
-    list.sort((a, b) => b.score - a.score || a.row.object.localeCompare(b.row.object));
+    list.sort((a, b) => b.score - a.score || compareFactsByContent(a.row, b.row));
   }
   const orderedFamilies = FAMILY_PRIORITY.filter((f) => byFamily.has(f))
     .concat([...byFamily.keys()].filter((f) => !FAMILY_PRIORITY.includes(f)).sort());
@@ -222,7 +228,7 @@ export function selectFacts(term, rows, store = {}, opts = {}) {
   selected.sort((a, b) => {
     const fa = FAMILY_PRIORITY.indexOf(a.family);
     const fb = FAMILY_PRIORITY.indexOf(b.family);
-    return (fa - fb) || (b.score - a.score) || a.row.object.localeCompare(b.row.object);
+    return (fa - fb) || (b.score - a.score) || compareFactsByContent(a.row, b.row);
   });
 
   return {

package/src/domain/domain.mjs

@@ -37,10 +37,17 @@ const optionalTerm = (value) => {
   return t === "" ? undefined : t;
 };
 
+/** Codepoint order, never localeCompare. Every string this file sorts came out
+ *  of the fact/Rule store. The planner walks actions, signatures and state rows
+ *  in exactly the order these comparators leave them, so a locale-sensitive
+ *  compare would let two machines holding one taught domain return different
+ *  plans from it. */
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
 const rowSort = (a, b) =>
-  a.subject.localeCompare(b.subject) ||
-  a.predicate.localeCompare(b.predicate) ||
-  a.object.localeCompare(b.object);
+  byCodepoint(a.subject, b.subject) ||
+  byCodepoint(a.predicate, b.predicate) ||
+  byCodepoint(a.object, b.object);
 
 const normRow = (row) => ({
   subject: normTerm(row.subject),
@@ -108,13 +115,13 @@ export function compileDomain(factRows, ruleRows) {
       });
     }
   }
-  const actions = [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+  const actions = [...byName.values()].sort((a, b) => byCodepoint(a.name, b.name));
   for (const action of actions) {
     action.signatures.sort((a, b) =>
-      a.subjectClass.localeCompare(b.subjectClass) || a.targetClass.localeCompare(b.targetClass));
-    action.preconds.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
-    action.effects.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
-    action.constraints.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+      byCodepoint(a.subjectClass, b.subjectClass) || byCodepoint(a.targetClass, b.targetClass));
+    action.preconds.sort((a, b) => byCodepoint(JSON.stringify(a), JSON.stringify(b)));
+    action.effects.sort((a, b) => byCodepoint(JSON.stringify(a), JSON.stringify(b)));
+    action.constraints.sort((a, b) => byCodepoint(JSON.stringify(a), JSON.stringify(b)));
   }
 
   // Class membership from typing edges. A member is a subject with a typing

package/src/domain/el-classify.mjs

@@ -21,9 +21,18 @@ import {
   SUBCLASS_PREDICATE, ON_PROPERTY_PREDICATE, SOME_VALUES_FROM_PREDICATE, TYPE_PREDICATE,
   DEFAULT_MAX_ENVIRONMENTS, buildCardinalityRestrictions,
 } from "./syllogise.mjs";
+import { compareFactsByContent } from "./memory/fact-order.mjs";
 
 const SEP = "␟"; // an in-key separator no fact term can contain — same convention as syllogise.mjs's own SEP
 
+// Codepoint order, never localeCompare — a stored row's id is read on whatever
+// machine holds the graph, and two locales have to land on the same order.
+const byId = (a, b) => {
+  const ka = String(a.id);
+  const kb = String(b.id);
+  return ka < kb ? -1 : ka > kb ? 1 : 0;
+};
+
 /** The two reserved concept names every EL derivation is built from. Neither
  *  can collide with a stored term: normFactTerm never produces them from a
  *  class noun, and normalizeElTBox drops any row that literally names one. */
@@ -78,7 +87,7 @@ const isCardinalityPredicate = (p) => CARDINALITY_PREDICATES.has(lower(p));
  */
 export function normalizeElTBox(rows, { budget = 500 } = {}) {
   const input = (Array.isArray(rows) ? rows : []).filter((r) => r && r.id && r.subject && r.predicate && r.object !== undefined && r.object !== null);
-  const sorted = [...input].sort((a, b) => String(a.id).localeCompare(String(b.id)));
+  const sorted = [...input].sort(byId);
   const truncated = sorted.length > budget;
   const used = truncated ? sorted.slice(0, budget) : sorted;
 
@@ -216,7 +225,7 @@ export function normalizeElTBox(rows, { budget = 500 } = {}) {
   for (const role of [...transitiveRoleRow.keys()].sort()) {
     roleAxioms.push({ kind: "transitive", role, from: [transitiveRoleRow.get(role).id] });
   }
-  for (const r of [...subPropertyRows].sort((a, b) => `${a.subject}${SEP}${a.object}`.localeCompare(`${b.subject}${SEP}${b.object}`))) {
+  for (const r of [...subPropertyRows].sort(compareFactsByContent)) {
     roleAxioms.push({ kind: "sub", sub: r.subject, sup: r.object, from: [r.id] });
   }
 

package/src/domain/fact-phrase.mjs

@@ -60,6 +60,7 @@ export const FACT_PREDICATE_PHRASES = Object.freeze({
   "mgx:consumes": "eats",
   "mgx:vision-radius": "sees within",
   "mgx:guards": "guards",
+  "mgx:attributedTo": "is attributed to",
 });
 
 /** The closed participle set the relational teach frames read as "X is
@@ -70,6 +71,23 @@ export const FACT_PREDICATE_PHRASES = Object.freeze({
  *  them back into English, so both read the one vocabulary. */
 export const TEACH_PARTICIPLE_SRC = "connected|related|associated|linked|based|derived|composed|made|used|known|located|found|involved|concerned";
 
+/** The participles a news report's agentless passive states its subject's own
+ *  condition with — "is banned from", "was deported to". One per verb in the
+ *  extractor's closed newswire event band, so the same list that decides which
+ *  events read also decides which passives read back as English. Kept apart
+ *  from TEACH_PARTICIPLE_SRC because the teach lane parses that list into its
+ *  own frames and nothing should widen those by writing here. */
+export const NEWS_PASSIVE_PARTICIPLE_SRC = [
+  "hit", "struck", "killed", "injured", "wounded", "damaged", "destroyed", "devastated",
+  "banned", "halted", "blocked", "barred", "suspended", "imposed",
+  "arrested", "detained", "jailed", "charged", "convicted", "sentenced", "deported", "released", "freed",
+  "elected", "appointed", "ousted", "overthrown",
+  "signed", "adopted", "approved", "rejected", "vetoed",
+  "launched", "unveiled", "seized", "captured", "invaded", "attacked", "bombed", "targeted",
+  "discovered", "uncovered", "rescued", "evacuated",
+  "sparked", "triggered", "caused", "forced", "deployed", "restored", "expanded",
+].join("|");
+
 /** The MECHANICAL fallback for a predicate the table has no curated entry
  *  for — specifically the minted "mgx:<lemma>" predicates ("mgx:eat",
  *  "mgx:drive", …) — the mechanical INVERSE of the naive -s/-es/-ies fold the
@@ -132,14 +150,35 @@ const SINGULAR_NOUNS_ENDING_S = new Set([
   "news", "physics", "species", "series", "means", "measles", "mathematics", "politics", "economics",
 ]);
 
+/** How much word has to sit in front of one of those nouns before the whole
+ *  reads as a COMPOUND built on it. An English compound takes its number from
+ *  its rightmost element, so "hackernews", "subspecies", "miniseries" and
+ *  "geopolitics" are all as singular as the noun they end in, and the table
+ *  above covers the family rather than one site's name. Three characters is
+ *  where the real first elements start ("sub", "geo", "mini", "hacker") and
+ *  where the words that merely END in one of those nouns stop: "sinews",
+ *  "renews" and "demeans" leave two characters in front and stay plural. */
+const COMPOUND_FIRST_ELEMENT_MIN_CHARS = 3;
+
+/** Does a head noun end in one of the singular "-s" nouns above, as itself or
+ *  as the last element of a compound built on it? */
+function endsInSingularNounEndingS(head) {
+  for (const noun of SINGULAR_NOUNS_ENDING_S) {
+    if (head === noun) return true;
+    if (head.endsWith(noun) && head.length - noun.length >= COMPOUND_FIRST_ELEMENT_MIN_CHARS) return true;
+  }
+  return false;
+}
+
 /**
  * Is a stored fact's SUBJECT text grammatically plural, for the one thing
  * this file needs it for: choosing a minted verb's surface form. Reads the
  * HEAD noun only — the word right after any leading article, before a
  * trailing "of ..." phrase, so "the group of scientists" agrees on "group"
  * ("the group of scientists reports"), not "scientists". From there: the
- * closed irregular table above, then the regular "-s" suffix, same
- * naive-morphology trade thirdPersonSingularSurface already takes above. A
+ * closed irregular table above, then the singular "-s" nouns and the compounds
+ * they head, then the regular "-s" suffix, same naive-morphology trade
+ * thirdPersonSingularSurface already takes above. A
  * subject this can't read (empty, or a plural-invariant noun like "sheep")
  * defaults to singular — English's own unmarked form, and also this file's
  * pre-existing default for every caller that passes no subject at all.
@@ -148,7 +187,7 @@ export function isSubjectPlural(subject) {
   const head = String(subject || "").trim().replace(/^(?:the|a|an)\s+/i, "").split(/\s+/)[0]?.toLowerCase() ?? "";
   if (!head) return false;
   if (IRREGULAR_PLURAL_NOUNS.has(head)) return true;
-  if (SINGULAR_NOUNS_ENDING_S.has(head)) return false;
+  if (endsInSingularNounEndingS(head)) return false;
   return /[a-z]s$/.test(head) && !/ss$/.test(head);
 }
 
@@ -204,7 +243,7 @@ export function predicatePhrase(predicate, subject) {
   // a participle + preposition renders as its copula surface: mgx:connected-with
   // -> "is connected with" (the participle is already a participle, so no 3sg
   // fold — "connecteds" isn't a word)
-  const part = new RegExp(`^mgx:(${TEACH_PARTICIPLE_SRC})-([a-z]+)$`, "i").exec(p);
+  const part = new RegExp(`^mgx:(${TEACH_PARTICIPLE_SRC}|${NEWS_PASSIVE_PARTICIPLE_SRC})-([a-z]+)$`, "i").exec(p);
   if (part) return `is ${part[1].toLowerCase()} ${part[2].toLowerCase()}`;
   // a shared-attribute predicate: mgx:same-goal-as -> "has the same goal as"
   const same = /^mgx:same-([a-z]+)-as$/i.exec(p);
@@ -218,10 +257,49 @@ export function predicatePhrase(predicate, subject) {
     const verb = isSubjectPlural(subject) ? minted[1] : thirdPersonSingularSurface(minted[1]);
     return `${verb}${minted[2] ? ` ${minted[2]}` : ""}`;
   }
+  // The lexicon's own minted verb predicates come pre-inflected: it builds
+  // "tmct:<3sg>[<Prep>]" from a declared verb, so "release" is stored as
+  // "tmct:releases" and "rely" + "on" as "tmct:reliesOn". Singular subjects
+  // read that surface as it stands. A plural one takes the bare form through
+  // baseVerbSurface, the documented inverse of the fold that made it, so
+  // "rescuers release" comes out of the same rule that gives "rescuers report".
+  // The camel-cased preposition is its own word in a sentence.
+  const declared = /^tmct:([a-z]+)([A-Z][a-z]+)?$/.exec(p);
+  if (declared) {
+    const verb = isSubjectPlural(subject) ? baseVerbSurface(declared[1]) : declared[1];
+    return `${verb}${declared[2] ? ` ${declared[2].toLowerCase()}` : ""}`;
+  }
   const colon = p.indexOf(":");
   return colon === -1 ? p : p.slice(colon + 1);
 }
 
+/**
+ * The verb a stored predicate states an ACT with, as `{ lemma, particle }`,
+ * or null when the predicate states anything else. `mgx:free` reads
+ * `{ lemma: "free", particle: "" }`, the lexicon's pre-inflected
+ * `tmct:releases` reads `{ lemma: "release", particle: "" }`, and
+ * `mgx:strike-near` / `tmct:reliesOn` carry their particle beside the lemma.
+ *
+ * The branches below mirror predicatePhrase's own, in its order, so anything
+ * that reads as a curated phrase, a negation, a comparative, a passive
+ * participle or a shared attribute answers null here rather than a verb it
+ * never renders as. Two rows minted down different paths — one through the
+ * lexicon's declared verbs, one from a bare lemma — reduce to the same answer,
+ * which is what lets a caller ask whether they state their act in one word.
+ */
+export function predicateVerb(predicate) {
+  const p = String(predicate ?? "");
+  if (FACT_PREDICATE_PHRASES[p] || p.startsWith("mgxneg:")) return null;
+  if (/^mgx:[a-z]+(?:-[a-z]+)*-than$/i.test(p)) return null;
+  if (new RegExp(`^mgx:(?:${TEACH_PARTICIPLE_SRC}|${NEWS_PASSIVE_PARTICIPLE_SRC})-[a-z]+$`, "i").test(p)) return null;
+  if (/^mgx:same-[a-z]+-as$/i.test(p)) return null;
+  const minted = /^mgx:([a-z]+)(?:-([a-z]+))?$/i.exec(p);
+  if (minted) return { lemma: minted[1].toLowerCase(), particle: minted[2]?.toLowerCase() ?? "" };
+  const declared = /^tmct:([a-z]+)([A-Z][a-z]+)?$/.exec(p);
+  if (declared) return { lemma: baseVerbSurface(declared[1]).toLowerCase(), particle: declared[2]?.toLowerCase() ?? "" };
+  return null;
+}
+
 /** "a heart has a valve" from one { subject, predicate, object } fact row —
  *  "scientists report a finding" for a plural row.subject, off the same
  *  agreement rule in predicatePhrase above. */
@@ -244,6 +322,7 @@ export const FINDING_CAVEATS = Object.freeze({
   "clause-fallback": "(read from a clause fragment)",
   "pronoun-carry": "(subject carried from the previous sentence)",
   "identifier-token": "(identifier token)",
+  "reported-speech": "(read from reported speech)",
 });
 
 /**
@@ -276,10 +355,13 @@ export function findingCaveat(finding) {
 export function phraseRendererSource() {
   return [
     `const TEACH_PARTICIPLE_SRC = ${JSON.stringify(TEACH_PARTICIPLE_SRC)};`,
+    `const NEWS_PASSIVE_PARTICIPLE_SRC = ${JSON.stringify(NEWS_PASSIVE_PARTICIPLE_SRC)};`,
     `const thirdPersonSingularSurface = ${thirdPersonSingularSurface};`,
     `const baseVerbSurface = ${baseVerbSurface};`,
     `const IRREGULAR_PLURAL_NOUNS = new Set(${JSON.stringify([...IRREGULAR_PLURAL_NOUNS])});`,
     `const SINGULAR_NOUNS_ENDING_S = new Set(${JSON.stringify([...SINGULAR_NOUNS_ENDING_S])});`,
+    `const COMPOUND_FIRST_ELEMENT_MIN_CHARS = ${COMPOUND_FIRST_ELEMENT_MIN_CHARS};`,
+    `const endsInSingularNounEndingS = ${endsInSingularNounEndingS};`,
     `const isSubjectPlural = ${isSubjectPlural};`,
     `const predicatePhrase = ${predicatePhrase};`,
     `const factSentence = ${factSentence};`,

package/src/domain/hash.mjs

@@ -104,6 +104,14 @@ const TEXT_CAP = 2000;   // an utterance's stored text (a whole answer fits; a p
  *  on which module did the writing. */
 export const normText = (t) => String(t ?? "").replace(/\s+/g, " ").trim().slice(0, TEXT_CAP);
 
+// A term that is exactly a fact group id ("fact:" + the 16 lowercase hex
+// digits factIdFor mints — an 8-byte SHA-256 truncation, see factIdFor below)
+// must survive normFactTerm whole. Without this guard the generic CURIE
+// strip below removes "fact:" from it same as any other prefix, so a
+// reference TO a fact and a taught word become the same term and collide
+// on one id. No existing corpus/vocabulary term takes this exact shape.
+const FACT_ID_TERM_RE = /^fact:[0-9a-f]{16}$/;
+
 /** Normalize a fact TERM (subject/object) so every writer converges on one
  *  spelling: ConceptNet's /c/en/foo_bar, tmct:Foo_bar, and bare "Foo bar" all
  *  become "foo bar". Also strips a leading "the"/"a"/"an" (idempotent — safe
@@ -111,6 +119,7 @@ export const normText = (t) => String(t ?? "").replace(/\s+/g, " ").trim().slice
  *  is meaningful controlled vocabulary. */
 export function normFactTerm(t) {
   let s = normText(t);
+  if (FACT_ID_TERM_RE.test(s.toLowerCase())) return s.toLowerCase();
   s = s.replace(/^\/c\/[a-z]{2,3}\//i, "");
   s = s.replace(/^[a-z][\w.-]*:/i, "");
   s = s.replace(/_/g, " ").replace(/\s+/g, " ").trim();

package/src/domain/memory/bias.mjs

@@ -2,6 +2,8 @@
 // computeTrust. `biasByBundle` is the `[bias]` table from tmct.toml. CRITICAL:
 // bias only REORDERS a hit list — it must never drop or hide one.
 
+import { compareFactsByContent } from "./fact-order.mjs";
+
 /** Matches a corpus-kind Source id ("src:corpus:<bundleName>"); anything else
  *  is not a corpus bundle and ranks at the neutral bias of 1. */
 const CORPUS_SOURCE_RE = /^src:corpus:(.+)$/;
@@ -23,12 +25,14 @@ export function biasForRow(row, biasByBundle = {}) {
   return Math.max(...ids.map((id) => biasForSourceId(id, biasByBundle)));
 }
 
-/** Rank fact rows by bias (desc), then trust (desc), then original order
- *  (stable) — reorders only, never drops a row. */
+/** Rank fact rows by bias (desc), then trust (desc), then content order —
+ *  reorders only, never drops a row. The last step is content and not array
+ *  index on purpose: an index tiebreak is arrival order, so two peers holding
+ *  one fact set would rank it two ways. */
 export function rankByBiasThenTrust(rows, biasByBundle = {}) {
   const list = Array.isArray(rows) ? rows : [];
   return list
-    .map((row, index) => ({ row, index, bias: biasForRow(row, biasByBundle) }))
-    .sort((a, b) => (b.bias - a.bias) || ((b.row?.trust ?? 0) - (a.row?.trust ?? 0)) || (a.index - b.index))
+    .map((row) => ({ row, bias: biasForRow(row, biasByBundle) }))
+    .sort((a, b) => (b.bias - a.bias) || ((b.row?.trust ?? 0) - (a.row?.trust ?? 0)) || compareFactsByContent(a.row, b.row))
     .map((x) => x.row);
 }