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

package/src/adapters/memory/corpus-bands.mjs

@@ -27,30 +27,28 @@ import { assertValidRow } from "./row-backend.mjs";
 export const BAND_PARTITION_PREFIX = "corpus:";
 export const MANIFEST_SORT_KEY = "manifest";
 
-/** The three bands this plan ships a build pipeline and a loader for. */
+/** The bands this repo ships a build pipeline and a loader for. */
 export const FIRST_CLASS_BANDS = Object.freeze([
-  "wikidata-slice",
+  "child",
+  "conceptnet",
   "wordnet-complete",
-  "conceptnet-full",
 ]);
 
-// Reserved so the partition name is spoken for; no pipeline for it ships
-// here. Its own design doc covers the band when it lands.
-export const RESERVED_BAND_NAMES = Object.freeze(["simplewiki-derived"]);
-
 /** The licence and attribution notice each first-class band's content
  *  carries — a property of the band's identity, not of any one load, so the
  *  loader reads it from here rather than taking it as a per-invocation flag.
  *  `notice` is a repo-relative path to the human-readable attribution file;
  *  null when the licence carries no attribution burden. */
 export const BAND_LICENSES = Object.freeze({
-  "wikidata-slice": Object.freeze({ license: "CC0-1.0", notice: null }),
+  // The child pack is ConceptNet-derived, so it carries ConceptNet's own
+  // share-alike terms rather than the maintainer-owned seed script's.
+  child: Object.freeze({ license: "CC-BY-SA-4.0", notice: "corpus/child/LICENSE-NOTICE" }),
+  conceptnet: Object.freeze({ license: "CC-BY-SA-4.0", notice: "corpus/conceptnet/LICENSE-NOTICE" }),
   "wordnet-complete": Object.freeze({ license: "CC-BY-4.0", notice: "corpus/wordnet/LICENSE-NOTICE" }),
-  "conceptnet-full": Object.freeze({ license: "CC-BY-SA-4.0", notice: "corpus/conceptnet/conceptnet-full.NOTICE" }),
 });
 
 /** `{license, notice}` for `band`, or both null when the band carries no
- *  entry here (a consumer's own band, outside the three first-class ones). */
+ *  entry here (a consumer's own band, outside the first-class ones). */
 export function bandLicenseInfo(band) {
   return BAND_LICENSES[band] ?? { license: null, notice: null };
 }
@@ -153,3 +151,28 @@ export function bandFactRow({ subject, predicate, object, provenance = "", band,
   };
   return assertValidRow(row, { provenance });
 }
+
+/** The inverse of `bandFactRow`: the `{subject, predicate, object,
+ *  provenance}` triple a band's own wire row carries, read back off its
+ *  `json` field. A caller that grounds a term straight from a band Query (no
+ *  article, no extraction) hands this triple to `appendFacts` unchanged, so
+ *  the fact lands under the SAME content-addressed id and the SAME
+ *  `corpus:<band> ...` provenance the band shipped it with — trust reads it
+ *  as a corpus source, not a live research one.
+ *
+ *  Null when `json` fails to parse or the individual carries no
+ *  rdf:subject/predicate/object triple — a malformed row degrades to
+ *  "nothing to fold in" rather than a throw, since a caller reads a whole
+ *  page of rows and one bad one should not cost the rest. */
+export function factFromBandRow(row) {
+  let parsed;
+  try { parsed = JSON.parse(row?.json ?? ""); } catch { return null; }
+  const attributes = parsed?.individual?.attributes;
+  if (!Array.isArray(attributes)) return null;
+  const valueOf = (prop) => attributes.find((a) => a?.prop === prop)?.value;
+  const subject = valueOf("rdf:subject");
+  const predicate = valueOf("rdf:predicate");
+  const object = valueOf("rdf:object");
+  if (!subject || !predicate || !object) return null;
+  return { subject, predicate, object, provenance: valueOf("mgx:factProvenance") || "" };
+}

package/src/adapters/memory/inspect.mjs

@@ -5,6 +5,7 @@
 
 import { loadMemory, UTTERANCE_CLASS, IN_REPLY_TO_PROP, readFactRows, findContradictions } from "./core.mjs";
 import { loadBlockIndex } from "./blocks.mjs";
+import { compareFactsByContent } from "../../domain/memory/fact-order.mjs";
 import { buildTableauKb, findTableauViolations } from "../../domain/tableau.mjs";
 import { elUnsatisfiableClasses } from "../../domain/el-classify.mjs";
 
@@ -33,6 +34,23 @@ export function balancedSample(items, k) {
 }
 
 const attrOf = (ind, key) => (ind?.attributes || []).find((a) => a.key === key)?.value || "";
+
+/** Codepoint order, never localeCompare — this text is read on whatever machine
+ *  holds the store, and two locales have to land on the same lines. */
+const byCodepoint = (a, b) => {
+  const ka = String(a ?? "");
+  const kb = String(b ?? "");
+  return ka < kb ? -1 : ka > kb ? 1 : 0;
+};
+
+/** Order two individuals by their own id, in codepoint order. Every id here is
+ *  derived from content — a Fact hashes its triple, an Utterance reads
+ *  `utt:<session>#<ts>#<role>`, a Source keys on its provenance tag — so this
+ *  is a pure function of the stored set, and the utterance case still comes out
+ *  in the order the conversation happened. Without it the class samples below
+ *  span the payload in the order the individuals were written, which is arrival
+ *  order: two peers holding one store would sample different rows. */
+const byIndividualId = (a, b) => byCodepoint(a?.id, b?.id);
 const truncate = (s, cap) => {
   const t = String(s ?? "").replace(/\s+/g, " ").trim();
   return t.length > cap ? `${t.slice(0, cap - 1)}…` : t;
@@ -55,7 +73,8 @@ export function renderMemory({ memory, blocks }, { verbose = false } = {}) {
       if (!byClass.has(cls)) byClass.set(cls, []);
       byClass.get(cls).push(ind);
     }
-    const classes = [...byClass.entries()].sort((a, b) => b[1].length - a[1].length);
+    for (const members of byClass.values()) members.sort(byIndividualId);
+    const classes = [...byClass.entries()].sort((a, b) => b[1].length - a[1].length || byCodepoint(a[0], b[0]));
     lines.push(`memory — ${individuals.length} individuals: ${classes.map(([c, of]) => `${of.length} ${c}`).join(", ")}.`);
     for (const [cls, of] of classes) {
       const k = sampleSize(of.length, { verbose });
@@ -68,7 +87,7 @@ export function renderMemory({ memory, blocks }, { verbose = false } = {}) {
       .filter((r) => r.sourceIds.length || r.provenance)
       .sort((a, b) => b.trust - a.trust
         || b.sourceIds.length - a.sourceIds.length
-        || `${a.subject} ${a.predicate} ${a.object}`.localeCompare(`${b.subject} ${b.predicate} ${b.object}`));
+        || compareFactsByContent(a, b));
     if (ranked.length) {
       lines.push("", "top facts by trust:");
       for (const r of ranked.slice(0, verbose ? 8 : 3)) {
@@ -137,7 +156,7 @@ export function renderMemory({ memory, blocks }, { verbose = false } = {}) {
     const pairs = (replyGroup?.examples || [])
       .map((e) => ({ a: byId.get(e.subject), q: byId.get(e.object) }))
       .filter((p) => p.a && p.q && p.a.class === UTTERANCE_CLASS)
-      .sort((x, y) => attrOf(y.a, "ts").localeCompare(attrOf(x.a, "ts")));
+      .sort((x, y) => byCodepoint(attrOf(y.a, "ts"), attrOf(x.a, "ts")) || byIndividualId(x.a, y.a));
     if (pairs.length) {
       lines.push("", `recent Q→A pairs (${pairs.length} recorded):`);
       for (const p of pairs.slice(0, verbose ? 8 : 3)) {
@@ -153,7 +172,7 @@ export function renderMemory({ memory, blocks }, { verbose = false } = {}) {
     const tokens = entries.reduce((n, [, b]) => n + (b.tokens?.length || 0), 0);
     const top = entries
       .slice()
-      .sort((a, b) => (b[1].rank ?? 0) - (a[1].rank ?? 0) || a[0].localeCompare(b[0]))
+      .sort((a, b) => (b[1].rank ?? 0) - (a[1].rank ?? 0) || byCodepoint(a[0], b[0]))
       .slice(0, verbose ? 8 : 3);
     lines.push("", `blocks — ${entries.length} folded session block${entries.length === 1 ? "" : "s"}, ${tokens} indexed tokens.`);
     lines.push(`  top by rank: ${top.map(([id, b]) => `${String(id).slice(0, 8)} (${(b.rank ?? 0).toFixed(3)})`).join(", ")}`);
@@ -169,7 +188,7 @@ export function renderMemory({ memory, blocks }, { verbose = false } = {}) {
     const freq = new Map();
     for (const f of facts) if (clean(f.object)) freq.set(f.object, (freq.get(f.object) || 0) + 1);
     const terms = [...freq.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(([t]) => t)
       .slice(0, 3);
     const sample = facts.find((f) => clean(f.subject) && terms.includes(f.object));

package/src/adapters/memory/rows.mjs

@@ -89,8 +89,13 @@ function storedIndividualForm(ind) {
 /** The ord each row key carries. An existing key keeps the ord it already had
  *  and a new one takes the next free number, matching how a store keeps a row's
  *  sort position across an update. Without prior rows the ords are the payload's
- *  own array order. */
-function ordAssigner(priorRows) {
+ *  own array order.
+ *
+ *  `baseOrds` is a read-only layer's key -> ord map, consulted after the prior
+ *  rows so a key both layers hold keeps the row's own ord. It is read in place:
+ *  a caller holding one for the life of its handle hands it over rather than
+ *  projecting a row per key and parsing each back. */
+function ordAssigner(priorRows, baseOrds) {
   const priorOrds = new Map();
   let next = 0;
   for (const row of priorRows || []) {
@@ -100,8 +105,9 @@ function ordAssigner(priorRows) {
     priorOrds.set(row.rowKey, ord);
     if (ord >= next) next = ord + 1;
   }
+  for (const ord of baseOrds?.values() || []) if (Number.isFinite(ord) && ord >= next) next = ord + 1;
   return (rowKey) => {
-    const prior = priorOrds.get(rowKey);
+    const prior = priorOrds.get(rowKey) ?? baseOrds?.get(rowKey);
     if (prior !== undefined) return prior;
     const ord = next;
     next += 1;
@@ -139,14 +145,16 @@ const OVERSIZED_ROW_POSTURES = new Set(["throw", "drop", "keep"]);
  *
  *  `priorRows` are the rows this payload was last projected as; pass them and
  *  every unchanged row comes back byte-identical, so `diffRows` writes only
- *  what actually moved. `onOversizedRow` is "throw" (default), "drop", or
- *  "keep" (rows that never reach the wire — see `admitRow`), and `log` takes
- *  the drop notices. */
-export function payloadToRows(payload, { priorRows = null, onOversizedRow = "throw", log = warnToConsole } = {}) {
+ *  what actually moved. `priorOrds` is the same information for a read-only
+ *  layer that already holds it as a key -> ord map (a sqlite seed's own key
+ *  columns), read under the prior rows. `onOversizedRow` is "throw" (default),
+ *  "drop", or "keep" (rows that never reach the wire — see `admitRow`), and
+ *  `log` takes the drop notices. */
+export function payloadToRows(payload, { priorRows = null, priorOrds = null, onOversizedRow = "throw", log = warnToConsole } = {}) {
   if (!OVERSIZED_ROW_POSTURES.has(onOversizedRow)) {
     throw new TypeError(`onOversizedRow must be "throw", "drop", or "keep", got ${JSON.stringify(onOversizedRow)}`);
   }
-  const ordFor = ordAssigner(priorRows);
+  const ordFor = ordAssigner(priorRows, priorOrds);
   const posture = { onOversizedRow, log };
   const rows = [];
 
@@ -239,6 +247,87 @@ function carryForward(payload, carried) {
   });
 }
 
+// The ids of the assembled individuals in ROW order, kept beside the assembled
+// array. `sortFactIndividualsById` lifts the Facts out of the slots row order
+// put them in, so the array itself no longer says which slot each Fact came
+// from — and a removal needs exactly that, because dropping a Fact drops one of
+// those slots, not the position the sort moved it to. Non-enumerable and
+// symbol-keyed for the same reason as the derivations above; the `individuals`
+// reference is the guard, so a copy or a rebuilt array is never reconciled
+// against an order that describes a different one.
+const ASSEMBLED_ROW_ORDER = Symbol("tmct.assembledRowOrder");
+
+function carryRowOrder(payload, ids) {
+  Object.defineProperty(payload, ASSEMBLED_ROW_ORDER, {
+    value: { individuals: payload.individuals, ids },
+    writable: true, configurable: true, enumerable: false,
+  });
+}
+
+/** The row order this payload was assembled in, or null when it carries none
+ *  or the one it carries describes a different individuals array. */
+function carriedRowOrder(payload) {
+  const carried = payload?.[ASSEMBLED_ROW_ORDER];
+  if (!carried || carried.individuals !== payload.individuals) return null;
+  return carried;
+}
+
+/** True when `removedIds` can be dropped from this payload's individuals
+ *  incrementally — every id is one the assembly actually holds, and the payload
+ *  still carries the row order that says which slot each one occupies. Asked
+ *  before anything is mutated, so a caller that gets `false` can rebuild from a
+ *  payload nothing has touched. */
+export function canDropAssembledIndividuals(payload, removedIds) {
+  const carried = carriedRowOrder(payload);
+  if (!carried) return false;
+  const held = new Set(carried.ids);
+  for (const id of removedIds) if (!held.has(String(id))) return false;
+  return true;
+}
+
+/** Drop `removedIds` from an assembled payload's individuals, in place, leaving
+ *  the array a rebuild from the remaining rows would have produced. Reads the
+ *  row order back, filters the dropped ids out of it, and refills the array in
+ *  that order — so the fact slots that survive are the ones the surviving ROWS
+ *  own, which is what `sortFactIndividualsById` then sorts into. Returns false
+ *  when the payload has no usable row order, having changed nothing. */
+export function dropAssembledIndividuals(payload, removedIds) {
+  const carried = carriedRowOrder(payload);
+  if (!carried) return false;
+  const dropped = new Set([...removedIds].map((id) => String(id)));
+  const byId = new Map();
+  for (const ind of payload.individuals || []) if (ind?.id) byId.set(String(ind.id), ind);
+  const keptIds = [];
+  const kept = [];
+  for (const id of carried.ids) {
+    if (dropped.has(id)) continue;
+    const ind = byId.get(id);
+    if (!ind) return false;
+    keptIds.push(id);
+    kept.push(ind);
+  }
+  payload.individuals = kept;
+  carried.individuals = kept;
+  carried.ids = keptIds;
+  return true;
+}
+
+/** Forget the row order this payload carries, for a caller that rewrote the ids
+ *  the order names (the load-time legacy-fact-id heal). The next removal
+ *  rebuilds from rows instead of patching. */
+export function dropAssembledRowOrder(payload) {
+  if (payload && payload[ASSEMBLED_ROW_ORDER]) payload[ASSEMBLED_ROW_ORDER] = null;
+}
+
+/** Record one newly-assembled individual's id at the tail of the row order —
+ *  where a row keyed for the first time lands, since `payloadToRows` gives it an
+ *  ord past every ord already assembled. A payload carrying no row order stays
+ *  that way, and the next removal rebuilds instead of patching. */
+export function appendAssembledRowOrder(payload, id) {
+  const carried = carriedRowOrder(payload);
+  if (carried) carried.ids.push(String(id));
+}
+
 /** What this payload can reconcile against, or null when it must derive
  *  instead. `index` identity is the guard: state that describes some other
  *  prose index cannot be applied to this one. `needSupersessions` narrows to
@@ -469,8 +558,16 @@ export function rowsToPayload(rows, { meta = null } = {}) {
   individualEntries.sort(byOrdThenRowKey);
   groupEntries.sort(byOrdThenRowKey);
 
-  payload.individuals = individualEntries.map((e) => e.individual).filter(Boolean);
+  const rowOrderIds = [];
+  const individuals = [];
+  for (const entry of individualEntries) {
+    if (!entry.individual) continue;
+    individuals.push(entry.individual);
+    rowOrderIds.push(String(entry.individual.id ?? ""));
+  }
+  payload.individuals = individuals;
   payload.objectProperties = groupEntries.map((e) => e.group).filter(Boolean);
+  carryRowOrder(payload, rowOrderIds);
   return renormalizeAssembledPayload(payload);
 }
 

package/src/adapters/memory/shacl.mjs

@@ -18,12 +18,19 @@ export const EXTRACTION_FINDINGS = Object.freeze([
   "clause-fallback",    // the row grounded from a clause fragment after the whole sentence declined
   "pronoun-carry",      // the subject was substituted from the paragraph's pronoun carry
   "definitional-frame", // the row came from a definitional copula frame ("X is the name for Y")
+  "reported-speech",    // the row was read from a reported-speech clause, its speaker attributed separately
 ]);
 const EXTRACTION_FINDING_SET = new Set(EXTRACTION_FINDINGS);
-const RULE_KINDS = new Set([
+
+// The closed vocabulary of a taught Rule's SHAPE tag — three structural
+// kinds plus the action-* family shared by one taught sentence's sibling
+// Rules. Exported (like EXTRACTION_FINDINGS above) so an estate guard can
+// cross-check it against its own prose mirrors in the ontology files.
+export const RULE_KINDS = Object.freeze([
   "compose2", "filter", "recursive",
   "action-signature", "action-precond", "action-effect", "action-constraint",
 ]);
+const RULE_KIND_SET = new Set(RULE_KINDS);
 
 // Mirrors the REQUIRED subset of core.mjs's own (unexported) RULE_SLOT_SPEC —
 // kept in sync by hand. Two kinds there also carry optional slots
@@ -140,8 +147,8 @@ function checkFact(ind, violations) {
 function checkRule(ind, violations) {
   if (!nonEmpty(attrValue(ind, "mgx:ruleName"))) violations.push("a Rule needs a non-empty mgx:ruleName");
   const kind = attrValue(ind, "mgx:ruleKind");
-  if (!kind || !RULE_KINDS.has(kind)) {
-    violations.push(`a Rule's mgx:ruleKind must be one of ${[...RULE_KINDS].join(" | ")} (got ${JSON.stringify(kind)})`);
+  if (!kind || !RULE_KIND_SET.has(kind)) {
+    violations.push(`a Rule's mgx:ruleKind must be one of ${RULE_KINDS.join(" | ")} (got ${JSON.stringify(kind)})`);
     return; // no declared kind to check slots against
   }
   for (const prop of RULE_SLOT_PROPS[kind]) {

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();