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

package/src/domain/sense-gate.mjs

@@ -0,0 +1,220 @@
+// sense-gate.mjs — the disjointness gate on isa DERIVATION.
+//
+// WordNet-derived bands flatten every sense of a word onto one label. "region"
+// carries a geographic sense (region ⊑ location) and an anatomical one
+// (region ⊑ body part), and both rows store the same six characters. Each row
+// is true of its own sense, so the corpus is right to hold both. subClassOf
+// transitivity then walks straight across the join:
+// russia ⊑ country ⊑ geographical area ⊑ region ⊑ body part.
+//
+// This module refuses that step, and only that step. It answers one question,
+// `declines(subject, object)`, for a candidate DERIVED isa edge. An asserted
+// row never reaches it: the gate constrains what the closure concludes, never
+// what a corpus or a teacher records. A refusal costs the MATERIALISED
+// shortcut row and nothing else. The stated chain stays whole, and every
+// walker over it (findIsaChain, the ancestor closers) still reaches what it
+// reached before.
+//
+// How a term is placed. Every candidate is resolved to the top classes it
+// sits under, by an upward breadth-first walk over the ASSERTED isa edges,
+// stopping at the FIRST level where any top appears and returning every top
+// found at that level. Nearest-level, not full reachability: the graph these
+// bands build is cyclic (place ⊑ passage ⊑ section ⊑ area ⊑ place is one of
+// many), so "every top above x" resolves to nearly all of them for nearly
+// every x and discriminates nothing. The nearest level is the sense the
+// term's own short chain commits to. Russia reaches `place` in two hops and
+// `body part` in four.
+//
+// When it declines. Both ends must resolve, the two top sets must not share a
+// member, and EVERY cross pair must be a declared disjoint pair. One
+// unresolved end, one shared top, or one pair the table does not separate,
+// and the derivation goes through. A term genuinely sitting under two tops
+// keeps both branches, so the gate cuts a crossing only when the evidence on
+// both sides is unambiguous.
+//
+// Pure over the fact set. One memo per gate, no clock, no arrival order; the
+// walk sorts every frontier by codepoint, so two ingestion orders of the same
+// facts return the same verdicts.
+
+import { normFactTerm } from "./hash.mjs";
+
+/**
+ * The top classes the gate resolves a term to, each with the labels the
+ * committed bands actually spell it. A label is a synonym FOR the top, not a
+ * subclass of it: `location` names the same region of the ontology as
+ * `place`, so both spellings resolve to one top and never separate.
+ *
+ * `region` is deliberately absent. It is the sense-mixed node itself — making
+ * it a top would place `geographical area` under it and settle nothing.
+ */
+export const TOP_CLASSES = [
+  { top: "place", labels: ["place", "location"] },
+  {
+    top: "body part",
+    labels: ["body part", "organ", "internal organ", "external body part", "body covering", "limb", "blood vessel"],
+  },
+  { top: "living thing", labels: ["living thing", "organism"] },
+  { top: "artifact", labels: ["artifact", "instrumentality"] },
+  { top: "substance", labels: ["substance", "matter"] },
+  { top: "event", labels: ["event", "happening"] },
+  { top: "communication", labels: ["communication", "message"] },
+  { top: "time period", labels: ["time period"] },
+  { top: "feeling", labels: ["feeling", "emotion"] },
+];
+
+/**
+ * The pairs of tops that DO overlap, so the disjoint table can be every other
+ * pair. Each one names something the ontology really holds both ways: a
+ * cathedral is an artifact and a place; a book is an artifact and a
+ * communication; concrete is an artifact and a substance; bone is a body part
+ * and a substance; timber is a living thing and a substance; a speech is an
+ * event and a communication; a cry is a communication and a feeling.
+ *
+ * Listing the overlaps rather than the exclusions keeps the judgement small:
+ * nine tops make thirty-six pairs, and the seven below are the ones that need
+ * an argument. The rest follow.
+ */
+export const OVERLAPPING_TOP_PAIRS = [
+  ["artifact", "communication"],
+  ["artifact", "place"],
+  ["artifact", "substance"],
+  ["body part", "substance"],
+  ["communication", "event"],
+  ["communication", "feeling"],
+  ["living thing", "substance"],
+];
+
+const pairKey = (a, b) => (a < b ? `${a}␟${b}` : `${b}␟${a}`);
+
+/**
+ * Every disjoint pair of tops, as `[a, b]` with `a < b`, sorted — all pairs
+ * of `topClasses` except `overlappingPairs`. Derived rather than typed out,
+ * so the table is symmetric and duplicate-free by construction.
+ */
+export function disjointTopPairs(topClasses = TOP_CLASSES, overlappingPairs = OVERLAPPING_TOP_PAIRS) {
+  const overlaps = new Set((overlappingPairs || []).map(([a, b]) => pairKey(a, b)));
+  const tops = (topClasses || []).map((t) => t.top);
+  const pairs = [];
+  for (let i = 0; i < tops.length; i += 1) {
+    for (let j = i + 1; j < tops.length; j += 1) {
+      const [a, b] = tops[i] < tops[j] ? [tops[i], tops[j]] : [tops[j], tops[i]];
+      if (overlaps.has(pairKey(a, b))) continue;
+      pairs.push([a, b]);
+    }
+  }
+  pairs.sort((p, q) => (p[0] < q[0] ? -1 : p[0] > q[0] ? 1 : p[1] < q[1] ? -1 : p[1] > q[1] ? 1 : 0));
+  return pairs;
+}
+
+/** How far up the gate will look for a top before giving the term up as
+ *  unplaced, and how many classes one term's walk may visit. Both bound the
+ *  cost of a single `topsOf` on a graph whose upper levels fan out hard; a
+ *  term whose nearest top sits past either bound is simply unplaced, and an
+ *  unplaced term never blocks anything. */
+export const DEFAULT_MAX_HOPS = 6;
+export const DEFAULT_MAX_VISITED = 3000;
+
+/** Codepoint order. Deliberately not localeCompare — the walk below must
+ *  return the same set on any machine and any ICU version. */
+const compareStrings = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
+/**
+ * Builds the gate over one fact set. `subClassEdges` and `typeEdges` are
+ * `[[child, parent], …]` lists of ASSERTED isa rows only (a caller holding
+ * entailed rows must filter them out first — feeding the closure's own output
+ * back in is what the gate exists to stop). Type edges act as a first hop, so
+ * an individual with a taught `rdf:type` places the same way a class does.
+ *
+ * Returns `{ declines, topsOf, tops, disjointPairs }`. `declines(subject,
+ * object)` is the whole contract; `topsOf(term)` is exposed for tests and for
+ * a caller that wants to explain a refusal.
+ */
+export function buildSenseGate({
+  subClassEdges = [], typeEdges = [], maxHops = DEFAULT_MAX_HOPS,
+  maxVisited = DEFAULT_MAX_VISITED, topClasses = TOP_CLASSES,
+  overlappingPairs = OVERLAPPING_TOP_PAIRS,
+} = {}) {
+  const topOfLabel = new Map(); // normalized label -> its top's canonical name
+  for (const entry of topClasses || []) {
+    for (const label of entry.labels || []) {
+      const n = normFactTerm(label);
+      if (n) topOfLabel.set(n, entry.top);
+    }
+  }
+  const allTops = (topClasses || []).map((t) => t.top);
+  const pairs = disjointTopPairs(topClasses, overlappingPairs);
+  const disjoint = new Set(pairs.map(([a, b]) => pairKey(a, b)));
+
+  const parentSets = new Map(); // child -> Set(direct asserted superclass)
+  const addEdge = (child, parent) => {
+    if (!child || !parent || child === parent) return;
+    if (!parentSets.has(child)) parentSets.set(child, new Set());
+    parentSets.get(child).add(parent);
+  };
+  for (const [child, parent] of subClassEdges || []) addEdge(child, parent);
+  for (const [instance, cls] of typeEdges || []) addEdge(instance, cls);
+  // Sorted once, read many: `maxVisited` can truncate a level part-way, and
+  // truncating a Set in arrival order would make the verdict depend on which
+  // order the facts were ingested in.
+  const parents = new Map();
+  for (const [child, set] of parentSets) parents.set(child, [...set].sort(compareStrings));
+
+  const memo = new Map(); // term -> sorted array of top names at its nearest level
+  function topsOf(term) {
+    if (!term) return [];
+    if (memo.has(term)) return memo.get(term);
+    let found = [];
+    const own = topOfLabel.get(term);
+    if (own) {
+      found = [own];
+    } else {
+      const seen = new Set([term]);
+      let frontier = [term];
+      for (let hop = 1; hop <= maxHops && frontier.length && seen.size < maxVisited; hop += 1) {
+        const next = [];
+        for (const node of frontier) {
+          for (const parent of parents.get(node) || []) {
+            if (seen.has(parent)) continue;
+            seen.add(parent);
+            next.push(parent);
+            if (seen.size >= maxVisited) break;
+          }
+          if (seen.size >= maxVisited) break;
+        }
+        next.sort(compareStrings);
+        const hits = new Set();
+        for (const node of next) {
+          const top = topOfLabel.get(node);
+          if (top) hits.add(top);
+        }
+        if (hits.size) { found = [...hits].sort(compareStrings); break; }
+        frontier = next;
+      }
+    }
+    memo.set(term, found);
+    return found;
+  }
+
+  /** True when EVERY cross pair of the two top sets is a declared disjoint
+   *  pair — one shared top or one undeclared pair and the answer is false. */
+  function separated(subjectTops, objectTops) {
+    for (const a of subjectTops) {
+      for (const b of objectTops) {
+        if (a === b) return false;
+        if (!disjoint.has(pairKey(a, b))) return false;
+      }
+    }
+    return true;
+  }
+
+  function declines(subject, object) {
+    if (!subject || !object || subject === object) return false;
+    const subjectTops = topsOf(subject);
+    if (!subjectTops.length) return false;
+    const objectTops = topsOf(object);
+    if (!objectTops.length) return false;
+    return separated(subjectTops, objectTops);
+  }
+
+  return { declines, topsOf, tops: allTops, disjointPairs: pairs };
+}

package/src/domain/syllogise.mjs

@@ -20,11 +20,17 @@
 // `entailed:*` Source, prior 0.3, so it never outranks a stated fact and is
 // retractable by provenance).
 //
+// The two isa rules take a fifth: the SENSE gate (sense-gate.mjs), which
+// refuses a conclusion that only holds because a corpus band flattened two
+// word senses onto one label — russia ⊑ … ⊑ region ⊑ body part. It screens
+// derivations only; a stated fact is never blocked.
+//
 // Two further capabilities below are LIVE-CHASE ONLY, never part of the
 // batch pass: cardinality monotonicity (`proveCardinalityAtLeast`) and
 // max-cardinality-0 as encoded negation (`proveMaxCardinalityZeroDenial`).
 
 import { normFactTerm, factIdForTriple } from "./hash.mjs";
+import { buildSenseGate } from "./sense-gate.mjs";
 
 /** The two persisting entry points (syllogise, retractSubClassOf) take the
  *  memory store's read/write functions through a required `store` option —
@@ -122,8 +128,14 @@ function normalizeFocus(focus) {
  * (not already present), each `{ subject, object, via }`, bounded by `budget`
  * and `depth`, focus-filtered, tautology- and dedup-screened, in a deterministic
  * order. No I/O — this is the whole inference kernel, unit-testable in isolation.
+ *
+ * `gate` (sense-gate.mjs's `buildSenseGate`, or null) is the SENSE screen: a
+ * candidate a⊑c is dropped when the gate places a and c under top classes the
+ * ontology declares disjoint, so a band that flattens two word senses onto one
+ * label cannot license a walk across the join. Null (the default) leaves the
+ * kernel's behaviour exactly as it was.
  */
-export function deriveSubClassClosure(edges, { depth = 32, budget = 50, focus = null } = {}) {
+export function deriveSubClassClosure(edges, { depth = 32, budget = 50, focus = null, gate = null } = {}) {
   const present = new Set();      // "a\0b" for every edge already known
   const succ = new Map();         // a -> Set(b): the live successor relation
   for (const [a, b] of edges || []) {
@@ -150,6 +162,7 @@ export function deriveSubClassClosure(edges, { depth = 32, budget = 50, focus =
           const key = `${a}${SEP}${c}`;
           if (present.has(key) || derivedKeys.has(key)) continue; // dedup / novelty screen
           if (!inFocus(a, b, c)) continue;             // focus-connection screen
+          if (gate?.declines(a, c)) continue;       // sense screen
           additions.push([a, b, c, key]);
         }
       }
@@ -183,7 +196,7 @@ export function deriveSubClassClosure(edges, { depth = 32, budget = 50, focus =
  * `allEdges` is already closed (a prior pass ran to fixpoint), the output
  * equals the full kernel's novel output, order included.
  */
-export function deriveSubClassClosureDelta(allEdges, deltaEdges, { depth = 32, budget = 50, focus = null } = {}) {
+export function deriveSubClassClosureDelta(allEdges, deltaEdges, { depth = 32, budget = 50, focus = null, gate = null } = {}) {
   const present = new Set();      // "a\0b" for every edge already known
   const succ = new Map();         // a -> Set(b): the live successor relation
   const pred = new Map();         // b -> Set(a): its inverse, for the R∘Δ join
@@ -216,6 +229,7 @@ export function deriveSubClassClosureDelta(allEdges, deltaEdges, { depth = 32, b
       const key = `${a}${SEP}${c}`;
       if (present.has(key) || derivedKeys.has(key)) return;   // dedup / novelty screen
       if (!inFocus(a, b, c)) return;                          // focus-connection screen
+      if (gate?.declines(a, c)) return;                    // sense screen
       additions.push([a, b, c, key]);
     };
     for (const [a, b] of delta) {
@@ -336,8 +350,13 @@ export function buildRelevanceFrontier(rows, seedTerms) {
  * a delta caller that pre-filters `typeEdges` to the relevant slice passes the
  * FULL list here, so an already-stored conclusion outside the slice is still
  * recognized as known rather than re-derived.
+ *
+ * `gate` is the same SENSE screen `deriveSubClassClosure` takes, read over the
+ * individual and the class it would inherit: an entity placed under one top
+ * never picks up a type from a disjoint one because a band flattened two
+ * senses onto a class somewhere in its chain.
  */
-export function deriveTypePropagation(typeEdges, subClassEdges, { budget = 50, focus = null, presentTypeEdges = typeEdges } = {}) {
+export function deriveTypePropagation(typeEdges, subClassEdges, { budget = 50, focus = null, presentTypeEdges = typeEdges, gate = null } = {}) {
   const ancestorsOf = buildAncestorCloser(subClassEdges);
 
   const present = new Set(); // "x\0C" for every rdf:type edge already known
@@ -357,6 +376,7 @@ export function deriveTypePropagation(typeEdges, subClassEdges, { budget = 50, f
       const key = `${x}${SEP}${d}`;
       if (present.has(key)) continue;                // dedup / novelty screen
       if (!inFocus(x, c, d)) continue;                // focus-connection screen
+      if (gate?.declines(x, d)) continue;          // sense screen
       candidates.push([x, c, d, key]);
     }
   }
@@ -820,7 +840,9 @@ export function findConsistencyViolations(typeEdges, subClassEdges, disjointEdge
  * even when none of its own three terms was named), `maxEnvironments`
  * (per-fact environment cap,
  * default DEFAULT_MAX_ENVIRONMENTS), `full` (force full evaluation even with
- * a valid watermark), `store` (REQUIRED — the memory store's
+ * a valid watermark), `senseGate` (default true: screen scm-sco and cax-sco
+ * conclusions through sense-gate.mjs so a two-sense band word can't licence a
+ * walk across the join; false runs the kernels raw), `store` (REQUIRED — the memory store's
  * { loadMemory, readFactRows, appendFacts } read/write functions, injected so
  * this inference module never imports the store itself; optional
  * loadSyllogiseState/saveSyllogiseState enable delta mode).
@@ -830,7 +852,7 @@ export function findConsistencyViolations(typeEdges, subClassEdges, disjointEdge
  */
 export async function syllogise(repoDir, {
   depth = 32, budget = 50, focus = null, expandFocus = false,
-  maxEnvironments = DEFAULT_MAX_ENVIRONMENTS, full = false, store,
+  maxEnvironments = DEFAULT_MAX_ENVIRONMENTS, full = false, store, senseGate = true,
 } = {}) {
   const { loadMemory, readFactRows, appendFacts } = requireStore(store, ["loadMemory", "readFactRows", "appendFacts"], "syllogise");
   const stateFnsPresent = typeof store?.loadSyllogiseState === "function" && typeof store?.saveSyllogiseState === "function";
@@ -857,6 +879,15 @@ export async function syllogise(repoDir, {
     const target = someValuesFromOf.get(restriction);
     if (target) restrictionEdges.push({ restriction, property, target });
   }
+  // The sense gate reads STATED isa rows only. Feeding it a previous pass's
+  // own conclusions would let one crossing licence the next, which is the
+  // failure it exists to stop.
+  const gate = senseGate
+    ? buildSenseGate({
+      subClassEdges: rows.filter((r) => isSubClassOf(r.predicate) && !isPurelyEntailed(r.provenance)).map((r) => [r.subject, r.object]),
+      typeEdges: rows.filter((r) => isType(r.predicate) && !isPurelyEntailed(r.provenance)).map((r) => [r.subject, r.object]),
+    })
+    : null;
   const callerFocus = normalizeFocus(focus);
   // An expanded focus is the same relevance walk a delta pass runs, seeded by
   // the caller's terms instead of a change set — still a focus (never reads
@@ -898,8 +929,8 @@ export async function syllogise(repoDir, {
     ? deltaRows.filter((r) => isSubClassOf(r.predicate)).map((r) => [r.subject, r.object])
     : [];
   const scmDerived = mode === "delta"
-    ? (deltaSubEdges.length ? deriveSubClassClosureDelta(subClassEdges, deltaSubEdges, { depth, budget, focus: normalizedFocus }) : [])
-    : deriveSubClassClosure(subClassEdges, { depth, budget, focus: normalizedFocus });
+    ? (deltaSubEdges.length ? deriveSubClassClosureDelta(subClassEdges, deltaSubEdges, { depth, budget, focus: normalizedFocus, gate }) : [])
+    : deriveSubClassClosure(subClassEdges, { depth, budget, focus: normalizedFocus, gate });
   // cax-sco sees the ENLARGED subClassOf edge set (stated ∪ this pass's own
   // scm-sco conclusions) so both rules complete in one `tmct syllogise` call.
   const enlargedSubClassEdges = subClassEdges.concat(scmDerived.map((d) => [d.subject, d.object]));
@@ -954,7 +985,7 @@ export async function syllogise(repoDir, {
 
   const remainingBudget = Math.max(0, budget - scmDerived.length);
   const caxDerived = remainingBudget > 0 && !deltaEmpty
-    ? deriveTypePropagation(caxTypeEdges, enlargedSubClassEdges, { budget: remainingBudget, focus: kernelFocus, presentTypeEdges: typeEdges })
+    ? deriveTypePropagation(caxTypeEdges, enlargedSubClassEdges, { budget: remainingBudget, focus: kernelFocus, presentTypeEdges: typeEdges, gate })
     : [];
   // cax-dw sees the SAME enlarged subClassOf set (so its own ⊑-lift reaches a
   // chain scm-sco just grew this pass) — it doesn't need the enlarged TYPE

package/src/domain/term-ledger.mjs

@@ -65,8 +65,23 @@ const NOISE_TERM_SETS = [
   FOREIGN_PARTICLE_TERMS,
 ];
 
+/** A version or model string shatters into pieces that are mostly digits and
+ *  punctuation — "Qwen3.8-2.4T" leaves "8-2" and "4t" behind. A term with no
+ *  letter at all, or one carrying a digit whose digits and punctuation match or
+ *  outnumber its letters, states a quantity or a version; it never names a
+ *  subject a reference lookup could define. A letter-only term with interior
+ *  stops ("u.s.") carries no digit, so it stays. */
+function isShapeNoiseTerm(term) {
+  const letters = (term.match(/[a-z]/g) || []).length;
+  if (!letters) return true;
+  const digits = (term.match(/\d/g) || []).length;
+  if (!digits) return false;
+  const punctuation = (term.match(/[^a-z0-9\s]/g) || []).length;
+  return digits + punctuation >= letters;
+}
+
 function isNoiseTerm(term) {
-  return NOISE_TERM_SETS.some((set) => set.has(term));
+  return NOISE_TERM_SETS.some((set) => set.has(term)) || isShapeNoiseTerm(term);
 }
 
 /** Ledger entry field order fixed once here so `ledgerPayload` serializes

package/src/services/chat.mjs

@@ -37,7 +37,7 @@ import { uuidv7 } from "../adapters/uuid.mjs";
 import * as defaultSource from "../adapters/source.mjs";
 import { loadTemplates, render as renderTemplate } from "../adapters/corpus/templates.mjs";
 import { rankByBiasThenTrust } from "../domain/memory/bias.mjs";
-import { HAS_A_PREDICATE, loadMemory as loadMemoryStore, normFactPredicate, normFactTerm as normFactTermStatic, readFactRows as readStoredFactRows, readRuleRows as readStoredRuleRows } from "../adapters/memory/core.mjs";
+import { HAS_A_PREDICATE, foldedFactRows as foldStoreFactRows, loadMemory as loadMemoryStore, normFactPredicate, normFactTerm as normFactTermStatic, readFactRows as readStoredFactRows, readRuleRows as readStoredRuleRows } from "../adapters/memory/core.mjs";
 import { BACKEND_REJECTED_CODE, BACKEND_UNAVAILABLE_CODE } from "../adapters/memory/row-backend.mjs";
 import {
   CAPABILITY_REPORT_CAP, NEG_CAPABLE_OF_PREDICATE, NEG_SUBCLASS_PREDICATE, capabilityBaseRate,
@@ -8461,8 +8461,9 @@ async function memoryFacts(memoryDir) {
  *
  *  `cache`: an optional, caller-owned plain object (`{ rows: null }`, e.g. one
  *  runTurn call's own `factRowsCache`) — when `cache.rows` is already
- *  populated, it's returned directly, skipping loadMemory/readFactRows
- *  entirely; otherwise the result is computed as before and stashed onto
+ *  populated, it's returned directly, skipping the store read entirely;
+ *  otherwise the fold is taken (from the store's own held one when it has a
+ *  current one — see core's `foldedFactRows`) and stashed onto
  *  `cache.rows` for the next caller sharing the same cache this turn.
  *  Absent/null (the default) reproduces a fresh, uncached reload every call,
  *  so every caller that doesn't pass one is byte-for-byte unaffected. Never
@@ -8473,8 +8474,8 @@ async function memoryFacts(memoryDir) {
 async function factRows(memoryDir, cache = null) {
   if (cache?.rows) return cache.rows;
   try {
-    const { loadMemory, readFactRows } = await import("../adapters/memory/core.mjs");
-    const rows = readFactRows(await loadMemory(memoryDir));
+    const { foldedFactRows } = await import("../adapters/memory/core.mjs");
+    const rows = await foldedFactRows(memoryDir);
     if (cache) { cache.rows = rows; cache.reloads = (cache.reloads || 0) + 1; }
     return rows;
   } catch {
@@ -18476,15 +18477,19 @@ function finishTurn(result, ctx) {
   return finish(result, ctx);
 }
 
-/** An uncached readFactRows() snapshot of the memory store — one half of the
- *  before/after pair a turn's `factsTouched` diff is taken over. Deliberately
- *  bypasses the turn's factRowsCache: the cache is invalidated by only some
- *  write paths, and a diff read through it would miss the very writes it exists
- *  to report. Null (rather than []) when there is no store or it won't load, so
- *  the caller can tell "nothing to diff" from "diffed, nothing moved". */
+/** A readFactRows() snapshot of the memory store — one half of the before/after
+ *  pair a turn's `factsTouched` diff is taken over. Deliberately bypasses the
+ *  turn's factRowsCache: the cache is invalidated by only some write paths, and
+ *  a diff read through it would miss the very writes it exists to report. The
+ *  store's own held fold is a different thing and safe to read: every write
+ *  moves the stamp it is keyed to, so a snapshot taken after a write is that
+ *  write's own fold, and a turn that wrote nothing gets back the array it
+ *  started from — which diffs to nothing, correctly. Null (rather than []) when
+ *  there is no store or it won't load, so the caller can tell "nothing to diff"
+ *  from "diffed, nothing moved". */
 async function factRowSnapshot(memoryDir) {
   if (!memoryDir) return null;
-  try { return readStoredFactRows(await loadMemoryStore(memoryDir)); } catch { return null; }
+  try { return await foldStoreFactRows(memoryDir); } catch { return null; }
 }
 
 /** The Fact rows this turn wrote, diffed against the snapshot taken before it,