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

package/src/domain/reference-pack.mjs

@@ -226,9 +226,14 @@ function withoutParentheticals(text) {
 
 // Words that end the noun phrase: a relative clause or a trailing modifier
 // carries detail, not the category ("a place where ships shelter" → place).
+// "about"/"around"/"roughly"/"approximately" open a comparison or a topic
+// that reads like more of the head phrase but is not ("a small marsupial
+// about the size of a large cat" is a marsupial, not a size; "a book about
+// dogs" is a book).
 const ISA_CLAUSE_CUT = new Set([
   "that", "which", "where", "who", "whose", "whom", "when", "used", "found",
   "made", "with", "in", "on", "for", "from", "by", "to", "and", "or",
+  "about", "around", "roughly", "approximately",
 ]);
 // Classifier heads carry no category of their own ("a member of the cat
 // family" names family membership, not what the thing is) — no isa beats a

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/sense-scope.mjs

@@ -0,0 +1,116 @@
+// sense-scope.mjs — the same-sense discipline a READ-TIME walk applies when it
+// picks which neighbours of a term to show.
+//
+// sense-gate.mjs already places a term under its nearest top classes and says
+// when two terms are provably in different senses. It uses that to refuse a
+// DERIVED isa edge, and it refuses only on proof: both ends placed, every cross
+// pair declared disjoint. That burden is right for a derivation, because
+// refusing one deletes an entailment the graph would otherwise hold.
+//
+// Selection carries the opposite burden. Nothing is deleted when a background
+// row goes unshown, so a walk may ask for evidence that a neighbour belongs
+// before it spends a line on it. This module asks for exactly that: the
+// neighbour's top classes must MEET the anchor's, not merely fail to be
+// provably disjoint.
+//
+// The difference is the whole bug. "russia" places under `place`; "passage"
+// places under `artifact`. Those two tops overlap by declaration (a cathedral
+// is both), so the derivation gate lets them stand and the store holds an
+// entailed "russia is a kind of passage". A hop-bounded walk out of russia then
+// treats `passage` as a one-hop neighbour and comes back down the anatomy side
+// of it: "orifice is a kind of passage", "duct is a kind of passage", on a card
+// about a prisoner release. Requiring a shared top stops the walk at `passage`
+// while `country`, `district` and `geographical area` — all of which meet
+// `place` — carry straight on.
+//
+// Unplaced is not out of sense. A term the bands never classify (a person's
+// name, a coined product name, most of what a headline is actually about) has
+// no tops to meet, so it is admitted.
+//
+// An unplaced ANCHOR is the harder case: it pools no tops, so by default the
+// scope keeps to nothing and every neighbour walks in as filler. Two ways out,
+// and a caller picks between them. `hasPlacedSense` says whether an anchor set
+// is placed at all, so a caller holding a second, better placed set can anchor
+// there instead. `admitAllWhenUnplaced: false` says these anchors ARE the
+// sense, placed or not: an unplaced anchor set then keeps to the unplaced, so a
+// walk under it goes sparse instead of pulling in the whole placed graph. A
+// graph with no bands at all places nothing, refuses nothing, and reads exactly
+// as it did.
+//
+// Pure over the fact set. The gate underneath sorts every frontier and memoizes
+// per term, and an anchor set is a membership test over the tops it pools, so
+// two ingestion orders of the same facts admit the same terms.
+
+import { normFactTerm } from "./hash.mjs";
+import { buildSenseGate } from "./sense-gate.mjs";
+
+const SUBCLASS_PREDICATE = "rdfs:subClassOf";
+const TYPE_PREDICATE = "rdf:type";
+
+/** Whether a row states its isa edge rather than concluding it. An entailment
+ *  head, a hypothetical's environment, or a justification chain all mark the
+ *  graph's own output; feeding that back to the gate that constrains it is how
+ *  a bad shortcut ends up vouching for itself. Read here rather than imported,
+ *  so this module stands alone for any reader that wants the same discipline. */
+function statesItsIsaEdge(row) {
+  const head = String(row?.provenance || "").trim().split(/\s+/)[0] || "";
+  if (head.startsWith("entailed:")) return false;
+  if (Array.isArray(row?.environments) && row.environments.length) return false;
+  if (Array.isArray(row?.justification) && row.justification.length) return false;
+  return true;
+}
+
+/** Builds the scope over one fact set, reading only the asserted isa rows.
+ *
+ *  Returns `{ topsOf, hasPlacedSense, sameSenseAs }`. `topsOf(term)` is the
+ *  gate's own placement, exposed so a caller can explain a refusal.
+ *  `sameSenseAs(anchors)` takes one term or an iterable of them and answers a
+ *  `(term) => boolean` predicate: true when the term may stay in the anchors'
+ *  neighbourhood. Several anchors pool their tops, so a walk seeded from more
+ *  than one term keeps to the senses of all of them. `hasPlacedSense(anchors)`
+ *  says whether that pool holds anything, which is whether the scope those
+ *  anchors build refuses any term at all. Pass `admitAllWhenUnplaced: false`
+ *  and an unplaced anchor set refuses every placed term instead of admitting
+ *  everything. */
+export function buildSenseScope(rows) {
+  const subClassEdges = [];
+  const typeEdges = [];
+  for (const row of rows || []) {
+    if (!row || !statesItsIsaEdge(row)) continue;
+    const child = normFactTerm(row.subject);
+    const parent = normFactTerm(row.object);
+    if (!child || !parent) continue;
+    if (row.predicate === SUBCLASS_PREDICATE) subClassEdges.push([child, parent]);
+    else if (row.predicate === TYPE_PREDICATE) typeEdges.push([child, parent]);
+  }
+  const gate = buildSenseGate({ subClassEdges, typeEdges });
+
+  const topsOf = (term) => gate.topsOf(normFactTerm(term));
+
+  const anchorList = (anchors) => (typeof anchors === "string" ? [anchors] : [...(anchors || [])]);
+
+  function topsAcross(list) {
+    const tops = new Set();
+    for (const anchor of list) for (const top of topsOf(anchor)) tops.add(top);
+    return tops;
+  }
+
+  const hasPlacedSense = (anchors) => topsAcross(anchorList(anchors)).size > 0;
+
+  function sameSenseAs(anchors, { admitAllWhenUnplaced = true } = {}) {
+    const list = anchorList(anchors);
+    const anchorTops = topsAcross(list);
+    if (!anchorTops.size && admitAllWhenUnplaced) return () => true;
+    const anchorTerms = new Set(list.map((a) => normFactTerm(a)).filter(Boolean));
+    return (term) => {
+      const norm = normFactTerm(term);
+      if (!norm || anchorTerms.has(norm)) return true;
+      const tops = topsOf(norm);
+      if (!tops.length) return true;
+      for (const top of tops) if (anchorTops.has(top)) return true;
+      return false;
+    };
+  }
+
+  return { topsOf, hasPlacedSense, sameSenseAs };
+}

package/src/domain/sense-split.mjs

@@ -260,7 +260,7 @@ export function clusterSenses(objects, {
     let best = depth(label);
     for (const m of sorted) { const d = depth(m); if (d > best) { best = d; label = m; } }
     return { objects: sorted, label };
-  }).sort((x, y) => x.label.localeCompare(y.label));
+  }).sort((x, y) => compareStrings(x.label, y.label));
 
   return { split: clusters.length > 1, clusters, pairs };
 }

package/src/domain/syllogise.mjs

@@ -20,11 +20,25 @@
 // `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";
+
+/** Codepoint order, never localeCompare. Every candidate list below is sorted
+ *  and then cut at the budget, so the comparator decides WHICH entailments a
+ *  pass derives. It also decides which premise each one cites: dedup keeps the
+ *  first candidate per key, so a derivation's `via` slot holds whichever middle
+ *  term sorted first. Sorting either by the reader's OS locale would let two
+ *  machines forward-chain one graph into two different fact sets. */
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
 
 /** The two persisting entry points (syllogise, retractSubClassOf) take the
  *  memory store's read/write functions through a required `store` option —
@@ -122,8 +136,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,12 +170,13 @@ 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]);
         }
       }
     }
     if (!additions.length) break; // fixpoint reached
-    additions.sort((x, y) => x[0].localeCompare(y[0]) || x[2].localeCompare(y[2]) || x[1].localeCompare(y[1]));
+    additions.sort((x, y) => byCodepoint(x[0], y[0]) || byCodepoint(x[2], y[2]) || byCodepoint(x[1], y[1]));
     let progressed = false;
     for (const [a, b, c, key] of additions) {
       if (derivedKeys.has(key)) continue; // an earlier addition this round covered it
@@ -183,7 +204,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 +237,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) {
@@ -223,7 +245,7 @@ export function deriveSubClassClosureDelta(allEdges, deltaEdges, { depth = 32, b
       for (const z of pred.get(a) || []) consider(z, a, b);   // R∘Δ
     }
     if (!additions.length) break; // fixpoint reached
-    additions.sort((x, y) => x[0].localeCompare(y[0]) || x[2].localeCompare(y[2]) || x[1].localeCompare(y[1]));
+    additions.sort((x, y) => byCodepoint(x[0], y[0]) || byCodepoint(x[2], y[2]) || byCodepoint(x[1], y[1]));
     let progressed = false;
     const nextDelta = [];
     for (const [a, b, c, key] of additions) {
@@ -336,8 +358,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,10 +384,11 @@ 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]);
     }
   }
-  candidates.sort((p, q) => p[0].localeCompare(q[0]) || p[2].localeCompare(q[2]) || p[1].localeCompare(q[1]));
+  candidates.sort((p, q) => byCodepoint(p[0], q[0]) || byCodepoint(p[2], q[2]) || byCodepoint(p[1], q[1]));
   const derived = [];
   const derivedKeys = new Set();
   for (const [x, c, d, key] of candidates) {
@@ -426,7 +454,7 @@ export function deriveDisjointViolations(typeEdges, subClassEdges, disjointEdges
       }
     }
   }
-  candidates.sort((p, q) => p[0].localeCompare(q[0]) || p[3].localeCompare(q[3]) || p[2].localeCompare(q[2]) || p[1].localeCompare(q[1]));
+  candidates.sort((p, q) => byCodepoint(p[0], q[0]) || byCodepoint(p[3], q[3]) || byCodepoint(p[2], q[2]) || byCodepoint(p[1], q[1]));
   const derived = [];
   const derivedKeys = new Set();
   for (const [x, c, d, e, key] of candidates) {
@@ -506,7 +534,7 @@ export function deriveSomeValuesFromApplication(propertyEdges, typeEdges, subCla
       }
     }
   }
-  candidates.sort((a, b) => a[0].localeCompare(b[0]) || a[6].localeCompare(b[6]) || a[1].localeCompare(b[1]) || a[3].localeCompare(b[3]));
+  candidates.sort((a, b) => byCodepoint(a[0], b[0]) || byCodepoint(a[6], b[6]) || byCodepoint(a[1], b[1]) || byCodepoint(a[3], b[3]));
   const derived = [];
   const derivedKeys = new Set();
   for (const [x, p, pKey, y, c, target, r, key] of candidates) {
@@ -555,7 +583,7 @@ export function buildCardinalityRestrictions(rows) {
     if (!onClass) continue;
     restrictions.push({ restriction, kind, n, onClass });
   }
-  restrictions.sort((a, b) => a.restriction.localeCompare(b.restriction));
+  restrictions.sort((a, b) => byCodepoint(a.restriction, b.restriction));
   return restrictions;
 }
 
@@ -607,7 +635,7 @@ export function deriveSomeValuesFromSubsumption(restrictionEdges, subClassEdges,
       }
     }
   }
-  candidates.sort((a, b) => a[0].localeCompare(b[0]) || a[1].localeCompare(b[1]));
+  candidates.sort((a, b) => byCodepoint(a[0], b[0]) || byCodepoint(a[1], b[1]));
   const derived = [];
   const derivedKeys = new Set();
   for (const [c1, c2, y1, y2, key] of candidates) {
@@ -775,7 +803,7 @@ export function findConsistencyViolations(typeEdges, subClassEdges, disjointEdge
       }
     }
   }
-  candidates.sort((p, q) => p[0].localeCompare(q[0]) || p[1].localeCompare(q[1]) || p[2].localeCompare(q[2]));
+  candidates.sort((p, q) => byCodepoint(p[0], q[0]) || byCodepoint(p[1], q[1]) || byCodepoint(p[2], q[2]));
   const derived = [];
   for (const [x, ta, tb, viaA, viaB] of candidates) {
     if (derived.length >= budget) break;
@@ -820,7 +848,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 +860,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 +887,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 +937,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 +993,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
@@ -1115,7 +1154,7 @@ export async function syllogise(repoDir, {
       environments: environmentsOf(r), provenance: r.provenance,
     }));
   const alternateCandidates = [...conclusionCandidates, ...storedCandidates]
-    .sort((a, b) => a.subject.localeCompare(b.subject) || a.predicate.localeCompare(b.predicate) || a.object.localeCompare(b.object));
+    .sort((a, b) => byCodepoint(a.subject, b.subject) || byCodepoint(a.predicate, b.predicate) || byCodepoint(a.object, b.object));
   let environmentsAdded = 0;
   let alternatesTruncated = false;
   let examined = 0;
@@ -1399,7 +1438,7 @@ function buildSupportEnumerator(rows) {
       if (rec) {
         const edges = [...(propertyEdgesOf.get(row.subject) || [])]
           .filter(([p]) => normFactTerm(p) === rec.propertyKey)
-          .sort((a, b) => a[0].localeCompare(b[0]) || a[1].localeCompare(b[1]));
+          .sort((a, b) => byCodepoint(a[0], b[0]) || byCodepoint(a[1], b[1]));
         for (const [p, y] of edges) {
           if (out.length >= maxEnvironments) break;
           for (const c of [...(typesOf.get(y) || [])].sort()) {
@@ -1426,7 +1465,7 @@ function buildSupportEnumerator(rows) {
           if ((disjointOf.get(d) || new Set()).has(row.object)) pairs.push([c, d]);
         }
       }
-      pairs.sort((a, b) => a[0].localeCompare(b[0]) || a[1].localeCompare(b[1]));
+      pairs.sort((a, b) => byCodepoint(a[0], b[0]) || byCodepoint(a[1], b[1]));
       for (const [c, d] of pairs) {
         if (out.length >= maxEnvironments) break;
         const dwStoredForward = disjointForward.has(`${d}${SEP}${row.object}`);
@@ -1622,7 +1661,7 @@ export async function retractSubClassOf(repoDir, subject, object, {
         }
       }
       const candidates = [...candidateIds].map((id) => byId.get(id))
-        .sort((a, b) => a.subject.localeCompare(b.subject) || a.predicate.localeCompare(b.predicate) || a.object.localeCompare(b.object));
+        .sort((a, b) => byCodepoint(a.subject, b.subject) || byCodepoint(a.predicate, b.predicate) || byCodepoint(a.object, b.object));
       if (!candidates.length) break; // fixpoint — nothing cites what just fell
 
       // The surviving fact set for THIS round excludes every candidate's own
@@ -1688,7 +1727,7 @@ export async function retractSubClassOf(repoDir, subject, object, {
   if (appendFactsFn) {
     const regroundWrites = [...reground.entries()]
       .filter(([id]) => !removed.has(id))
-      .sort((a, b) => a[0].localeCompare(b[0]))
+      .sort((a, b) => byCodepoint(a[0], b[0]))
       .map(([id, environments]) => {
         const row = byId.get(id);
         return {