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

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(