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

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

package/src/domain/memory/capability.mjs

@@ -19,6 +19,7 @@
 // Pure and import-free of core.mjs, exactly like trust.mjs beside it.
 
 import { findIsaChain, buildSubClassSuccessors, SUBCLASS_PREDICATE, TYPE_PREDICATE } from "../syllogise.mjs";
+import { compareFactsByContent } from "./fact-order.mjs";
 
 /** The negative-polarity CURIE prefix. A separate prefix, never an
  *  "mgx:not-<lemma>" mint: fact-phrase.mjs's predicatePhrase reads "mgx:not-fly" as
@@ -74,7 +75,7 @@ export const NEG_CAPABLE_OF_PREDICATE = negatedPredicate(CAPABLE_OF_PREDICATE);
  *  order it lists them in. One constant each, in one place, so the verbosity of
  *  every case-4 answer is tuned by editing two lines. */
 export const CAPABILITY_REPORT_CAP = 6;
-const byTrustThenName = (a, b) => (b.trust || 0) - (a.trust || 0) || String(a.subject).localeCompare(String(b.subject));
+const byTrustThenName = (a, b) => (b.trust || 0) - (a.trust || 0) || compareFactsByContent(a, b);
 
 const asSet = (v) => (v instanceof Set ? v : new Set(Array.isArray(v) ? v : [v]));
 
@@ -155,7 +156,9 @@ export function resolveCapabilityPolarity(subject, object, facts, { maxHops = 3
   }
 
   // hop count first, trust only within a rank — the whole point of the design
-  candidates.sort((a, b) => a.hops - b.hops || (b.fact.trust || 0) - (a.fact.trust || 0));
+  candidates.sort((a, b) => a.hops - b.hops
+    || (b.fact.trust || 0) - (a.fact.trust || 0)
+    || compareFactsByContent(a.fact, b.fact));
   const hops = candidates[0].hops;
   const winning = candidates.filter((c) => c.hops === hops);
   const positive = winning.filter((c) => c.polarity === "positive").map((c) => c.fact);
@@ -198,19 +201,22 @@ export function capabilityBaseRate(subject, object, facts, { maxHops = 3 } = {})
   const rows = Array.isArray(facts) ? facts : [];
   const isaRows = rows.filter((f) => f.predicate === SUBCLASS_PREDICATE || f.predicate === TYPE_PREDICATE);
 
-  const parents = isaRows.filter((f) => subjects.has(f.subject)).map((f) => f.object);
+  // The class the whole report is about, so it cannot come from whichever
+  // parent row happened to be stored first.
+  const parents = isaRows.filter((f) => subjects.has(f.subject)).sort(compareFactsByContent).map((f) => f.object);
   if (!parents.length) return null;
   const klass = parents[0];
 
   const siblings = [...new Set(
-    isaRows.filter((f) => f.object === klass && !subjects.has(f.subject)).map((f) => f.subject),
+    isaRows.filter((f) => f.object === klass && !subjects.has(f.subject))
+      .sort(compareFactsByContent).map((f) => f.subject),
   )];
 
   const capabilityOf = (name) => {
-    const hit = rows.find(
+    const hit = rows.filter(
       (f) => f.subject === name && objects.has(f.object)
         && (f.predicate === CAPABLE_OF_PREDICATE || f.predicate === NEG_CAPABLE_OF_PREDICATE),
-    );
+    ).sort(compareFactsByContent)[0];
     if (!hit) return { name, polarity: "unknown", fact: null };
     return { name, polarity: hit.predicate === NEG_CAPABLE_OF_PREDICATE ? "negative" : "positive", fact: hit };
   };

package/src/domain/memory/fact-order.mjs

@@ -0,0 +1,29 @@
+// memory/fact-order.mjs — the order a fact listing falls back to once ranking
+// runs out of things to say. Every rank over fact rows (bias, trust, relevance)
+// ends in ties, and a stable sort settles a tie by array index, which is
+// arrival order: two peers holding one fact set then render the same facts on
+// different lines.
+//
+// The tiebreak here is a pure function of the fact's own content — the same
+// (subject, predicate, object) triple hash.mjs content-addresses a Fact by,
+// plus the provenance that separates two sources asserting one triple. NUL
+// delimits the parts for hash.mjs's reason: it never occurs inside a
+// normalized term or predicate, so "a b|c" and "a|b c" cannot collide on one
+// key. Codepoint order throughout, never localeCompare — two locales have to
+// land on the same order.
+//
+// The store's own precedent is p2p-room.mjs's sortFactIndividualsById, which
+// sorts Fact individuals by content-addressed id after every merge for exactly
+// this reason. This is that discipline carried through to the read side.
+
+/** A fact row's content-derived sort key. */
+export const factOrderKey = (f) => [
+  f?.subject ?? "", f?.predicate ?? "", f?.object ?? "", f?.provenance ?? "",
+].join("\0");
+
+/** Order two fact rows by content. The last comparison in any fact ranking. */
+export function compareFactsByContent(a, b) {
+  const ka = factOrderKey(a);
+  const kb = factOrderKey(b);
+  return ka < kb ? -1 : ka > kb ? 1 : 0;
+}

package/src/domain/memory/resolution.mjs

@@ -44,6 +44,9 @@ const MERGE_PREDICATE_STEMS = [
   "mgx:createdBy",
   "mgx:mannerOf", "mgx:relatedTo", "mgx:synonym", "mgx:antonym", "mgx:similarTo", "mgx:symbolOf",
   "mgx:knows-about",
+  // One claim can be attributed to many speakers at once. Two outlets naming two
+  // different people corroborate the claim; they do not disagree about it.
+  "mgx:attributedTo",
 ];
 
 export const MERGE_PREDICATES = new Set(