@hviana/sema 0.4.4 → 0.4.7

package/dist/src/mind/mechanisms/cast.js

@@ -11,8 +11,8 @@
 // gate = the frame gate below + analogyStrength, projection = insert / project /
 // juxtapose.
 import { read } from "../primitives.js";
-import { argmaxBy, corpusN, hubBound } from "../traverse.js";
-import { analogyStrength, follow, project, reverseContext, } from "../match.js";
+import { argmaxBy, corpusN, edgeAncestors, hubBound, sharedReachMemo, } from "../traverse.js";
+import { analogyStrength, follow, project, reverseContext, sharedFrameStrengthOf, } from "../match.js";
 import { joinWithBridge } from "../resonance.js";
 import { restatesQuery } from "../reasoning.js";
 import { CONCEPT, STEP } from "../graph-search.js";
@@ -21,6 +21,7 @@ import { consensusFloor, dominates } from "../../geometry.js";
 import { unexplainedLabel, unexplainedSpans, } from "../rationale.js";
 import { rItem, rNode } from "../trace.js";
 import { dismissedKnownContent } from "../bridge.js";
+import { leafIdRun } from "../canonical.js";
 // ── CAST gates ────────────────────────────────────────────────────────────
 //
 // The frame gate has TWO components, both derived from the weave itself:
@@ -173,7 +174,94 @@ export async function counterfactualTransfer(ctx, query, pre) {
     const weave = await pre.weave();
     const points = weave.points;
     const depth = weave.depth;
-    const aligned = points.length;
+    // CAST'S OWN SINGLE-VS-MULTI TEST, MEASURED FROM THE QUERY.
+    //
+    // `points.length >= 2` reads as "two structures to transfer between", but
+    // measured, it functions as "the query is about more than one thing" — and
+    // it only discriminates because the weave's exclusivity eliminates hard
+    // enough that a single-topic query cannot reach two points.  The condition
+    // is carried by the elimination, not by anything CAST measures.  Traced on
+    // test/24 3.1 ("the importance of gender equality in the workplace"): the
+    // climb is byte-identical either way (16 of 31 sub-regions, one context),
+    // and relaxing the weave alone makes CAST fire and answer about the 1992
+    // Dream Team.
+    //
+    // What actually separates 3.1 from a genuine comparison (test/29 C2, "How is
+    // Shakespeare like Leonardo da Vinci?") is CONTENT: C2's two points are
+    // evidenced by DIFFERENT query spans, while 3.1's extra points align to the
+    // same shared frame the first one already explains.  So require two points
+    // that explain genuinely different parts of the query — a second point must
+    // contribute at least one perception quantum of query bytes the
+    // best-covered point does not.  Derived from the runs themselves, order-free,
+    // and independent of how many points survived.
+    const coveredBy = (p) => {
+        const set = new Set();
+        for (const r of p.runs)
+            for (let i = r.qs; i < r.qe; i++)
+                set.add(i);
+        return set;
+    };
+    let widest = points[0];
+    let widestN = -1;
+    for (const p of points) {
+        const n = coveredBy(p).size;
+        if (n > widestN) {
+            widestN = n;
+            widest = p;
+        }
+    }
+    const widestSet = widest === undefined
+        ? new Set()
+        : coveredBy(widest);
+    let distinct = points.length === 0 ? 0 : 1;
+    for (const p of points) {
+        if (p === widest)
+            continue;
+        let own = 0;
+        for (const i of coveredBy(p))
+            if (!widestSet.has(i))
+                own++;
+        if (own >= quantum) {
+            distinct = 2;
+            break;
+        }
+    }
+    // THE CLIMB ANSWERS THE SAME QUESTION, AND IT ANSWERS IT ORDER-FREE.  Runs
+    // are literal W-gram agreement, so two structures the query names in its own
+    // words can share no run at all: on `How is ice like steel?` the query's
+    // `ice` and the stored `Ice is cold` agree on nothing but the ` is `
+    // scaffolding `Steel is hard` also matches, and the run test above reads one
+    // topic.  The climb had already read two — it elected `Ice is cold` from
+    // q4-9 and `Steel is hard` from q16-20, two disjoint places — and DISPERSION
+    // (Attention.clusters) is exactly that reading: not how much evidence, but
+    // how many separate places in the query corroborate it.  Measured against
+    // the case this gate exists to refuse, test/24 3.1: a genuinely single-topic
+    // query reads clusters 1, while C1's single committed root reads 2.
+    //
+    // Either source is sufficient — bytes the other point does not explain, or
+    // places the climb found the query's evidence in — and neither is a count of
+    // weave survivors.
+    // Dispersion alone is a property of the QUERY, not of the pair being woven,
+    // so it is read together with the pair's own elected spans: two points count
+    // as two topics when the climb found the query dispersed AND it elected them
+    // from places at least a quantum apart.  (Dispersion alone was measured and
+    // is too weak — it let CAST into test/33's near-tie and test/24's list
+    // skill, whose points the climb elects from the same place.)
+    const dispersed = roots.length >= MIN_WEAVE ||
+        roots.some((r) => r.clusters >= MIN_WEAVE);
+    const apart = points.some((a) => points.some((b) => a !== b &&
+        (b.start - a.end >= quantum || a.start - b.end >= quantum)));
+    // …and only where there is something left to transfer.  When ONE point
+    // already explains the query down to the last quantum there is no analogy to
+    // draw — the query is that structure, restated or truncated — and the
+    // dispersion the climb reports is the SAME topic corroborated twice, not two
+    // topics.  Measured on test/33's `steel is hard so steel is`, a prefix of one
+    // stored fact: its root disperses into 2 clusters purely because the fact
+    // repeats `steel is`, while that one point's runs cover all 25 query bytes.
+    const unexplained = query.length - widestN;
+    const aligned = distinct >= 2 || (dispersed && apart && unexplained >= quantum)
+        ? points.length
+        : 1;
     if (aligned < 2) {
         return fail(`only ${aligned} structure(s) aligned across the query — CAST needs ` +
             `at least two to transfer between`);
@@ -235,7 +323,39 @@ export async function counterfactualTransfer(ctx, query, pre) {
         });
         return [];
     }
-    const woven = points.some((p) => p.runs.some((r) => !pre.rec.sites.some((s) => r.qs >= s.start && r.qe <= s.end)));
+    // WOVEN — is anything actually brought TOGETHER?  A run restating a site
+    // the query already contains is not, by itself, evidence of that; but TWO
+    // points restating DIFFERENT sites is exactly a comparison ("How is
+    // Michelangelo like Homer?" names both entities, recognition finds both,
+    // and the weave aligns each to its own stored structure).  The escape
+    // clause alone called that unwoven — a reading that held only while
+    // recognition UNDER-reported sites, and test/29 A2 started failing the
+    // moment recognition's interior chains stopped dying mid-form.
+    //
+    // Both points must be evidenced in what the asker JUST SAID.  A multi-turn
+    // query is the whole transcript, so the earlier turns' own questions are
+    // aligned points too — traced on test/48, the weave for `And what is the
+    // capital of Spain?` holds `What is the capital of France?` (runs q0-61,
+    // entirely inside the previous turn and its answer) beside the new question
+    // (q65-94).  Two points, two named sites, and nothing woven at all: one of
+    // them is conversation history.  The current turn is the bytes past the last
+    // answered span — the same `askerBytes` notion computeWeave prices its read
+    // budget with — so requiring both points to have evidence THERE separates a
+    // genuine two-place weave from a follow-up.  Single-turn queries have no
+    // answered spans, so the current turn is the whole query and nothing changes.
+    const turnStart = ctx.answeredSpans.reduce((n, [, e]) => Math.max(n, e), 0);
+    const inTurn = points.filter((p) => p.runs.some((r) => r.qe > turnStart));
+    const siteAt = (r) => pre.rec.sites.findIndex((s) => r.qs >= s.start && r.qe <= s.end);
+    const namedSites = new Set();
+    for (const p of inTurn) {
+        for (const r of p.runs) {
+            const i = siteAt(r);
+            if (i >= 0)
+                namedSites.add(i);
+        }
+    }
+    const woven = points.some((p) => p.runs.some((r) => siteAt(r) < 0)) ||
+        (inTurn.length >= MIN_WEAVE && namedSites.size >= MIN_WEAVE);
     if (!woven) {
         return fail(`every aligned run restates a recognised query site — nothing was ` +
             `actually WOVEN across structures, so there is nothing to transfer`);
@@ -278,11 +398,30 @@ export async function counterfactualTransfer(ctx, query, pre) {
     const lastRun = (p) => p.runs[p.runs.length - 1];
     const qv = pre.guide;
     // ── SUBSTITUTION ──────────────────────────────────────────────────
-    const fillerOf = (s) => {
-        const r = s.runs[0];
-        return r.cs < quantum
-            ? s.ctx.subarray(0, r.cs + (r.qe - r.qs))
-            : query.subarray(r.qs, r.qe);
+    const fillerOf = (s, r = s.runs[0]) => r.cs < quantum
+        ? s.ctx.subarray(0, r.cs + (r.qe - r.qs))
+        : query.subarray(r.qs, r.qe);
+    // THE FILLER IS WHAT THE SUBJECT CONTRIBUTES BEFORE THE SEAT — CLIPPED HERE,
+    // NOT ARBITRATED BY RANK.  A subject whose alignment runs INTO the seat span
+    // agrees with the displaced structure there; those shared bytes are frame,
+    // and only the part before the seat is the subject's own contribution.
+    // Reading `runs[0]` whole made this schema depend on the weave having
+    // already cut that overlap away for it: on `steel is frigid` the weave's
+    // exclusivity handed `steel is hard so steel is strong` the run q0-5
+    // (`steel`) only because the seat's point ranked higher and took q5-15
+    // first.  Read without that cut the same run is q0-9 (`steel is `), it ends
+    // PAST the seat at q5, and substitution found no subject at all — a schema
+    // silently reading a global elimination order as if it were local evidence.
+    // Clipping at the seat derives the same span from the two points actually
+    // involved, so the reading no longer moves when the weave's order does.
+    const fillerRun = (s, at) => {
+        const r0 = s.runs[0];
+        if (r0.qs >= at)
+            return null;
+        const qe = Math.min(r0.qe, at);
+        return qe - r0.qs >= Math.min(quantum, s.ctx.length)
+            ? (qe === r0.qe ? r0 : { ...r0, qe })
+            : null;
     };
     // The subject is the closest structure whose FILLER RUN precedes the seat.
     // The gate is on `runs[0]` — the run `fillerOf` actually reads — not on the
@@ -297,9 +436,14 @@ export async function counterfactualTransfer(ctx, query, pre) {
     // analogy — pushed lastRun past the seat and no substitution fired at all.
     // The ordering key follows the gate to the same run, so "closest preceding"
     // still means closest by the evidence actually used.
-    const beforeOf = (p, r) => argmaxBy(points.filter((s) => s !== p && s.runs[0].qe <= r.qs &&
-        s.runs[0].cs < quantum &&
-        usable(s.runs[0].qs, s.runs[0].qe)), (s) => s.runs[0].qs, -Infinity, true)?.item;
+    const beforeOf = (p, r) => argmaxBy(points.flatMap((s) => {
+        if (s === p)
+            return [];
+        const f = fillerRun(s, r.qs);
+        return f !== null && f.cs < quantum && usable(f.qs, f.qe)
+            ? [{ point: s, run: f }]
+            : [];
+    }), (s) => s.run.qs, -Infinity, true)?.item;
     const displacement = points
         .map((p) => {
         const r = p.runs[0];
@@ -309,8 +453,9 @@ export async function counterfactualTransfer(ctx, query, pre) {
         const before = beforeOf(p, r);
         if (before === undefined)
             return null;
-        if (r.cs > fillerOf(before).length + quantum)
+        if (r.cs > fillerOf(before.point, before.run).length + quantum) {
             return null;
+        }
         // SUBSTITUTION MUST ACTUALLY DISPLACE.  The schema's premise is that the
         // displaced structure's seat is held by something ELSE, which the
         // subject then replaces.  When the subject's filler already occurs in
@@ -322,8 +467,9 @@ export async function counterfactualTransfer(ctx, query, pre) {
         // produced `Michelangelo sculpted by Michelangelo.` — then outbid every
         // honest candidate with it (test/29 A2).  Byte containment, the same
         // primitive the self-evidence and contradiction guards use.
-        if (indexOf(p.ctx, fillerOf(before), 0) >= 0)
+        if (indexOf(p.ctx, fillerOf(before.point, before.run), 0) >= 0) {
             return null;
+        }
         return { p, before, depth: p.ctx.length - r.cs };
     })
         .filter((c) => c !== null);
@@ -332,7 +478,7 @@ export async function counterfactualTransfer(ctx, query, pre) {
     const subj = picked?.item.before ?? null;
     if (proj !== null && subj !== null) {
         const seat = proj.runs[0];
-        const filler = fillerOf(subj);
+        const filler = fillerOf(subj.point, subj.run);
         const tail = proj.ctx.subarray(seat.cs);
         let answer = await joinWithBridge(ctx, filler, tail);
         const fwd = await follow(ctx, proj.anchor, qv);
@@ -341,10 +487,10 @@ export async function counterfactualTransfer(ctx, query, pre) {
             answer = concat2(answer, fwd);
         }
         ctx.trace?.step("projectCounterfactual", [
-            rItem(filler, "filler", subj.anchor),
+            rItem(filler, "filler", subj.point.anchor),
             rNode(ctx, proj.anchor, "displaced-structure"),
         ], [rItem(answer, "projection")], "transfer the displaced structure onto the subject filler (seat substitution)");
-        record(answer, "counterfactual substitution — the subject fills the analog's seat", new Set([subj.anchor, proj.anchor]), 
+        record(answer, "counterfactual substitution — the subject fills the analog's seat", new Set([subj.point.anchor, proj.anchor]), 
         // The acts performed: one seat INSERT projection + one edge FOLLOW.
         STEP + STEP, 
         // What substitution actually READ: the two points it transfers
@@ -352,10 +498,34 @@ export async function counterfactualTransfer(ctx, query, pre) {
         // structure whose seat it fills — not every OTHER point the weave
         // happened to align (a third, unrelated point in the same weave
         // contributes nothing to what substitution itself explains).
-        [...runSpans(subj), ...runSpans(proj)]);
+        [...runSpans(subj.point), ...runSpans(proj)]);
     }
     // ── REDIRECTION ────────────────────────────────────────────────────
-    const last = points.reduce((a, b) => lastRun(b).qs > lastRun(a).qs ? b : a);
+    // REDIRECTION IS ABOUT THE SUBSTITUTE THE QUERY NAMES, SO IT LOOKS FOR THE
+    // RUN THAT NAMES ONE.  A structure is named when the query quotes it from
+    // its own opening bytes (`cs === 0`) — `…were Lyon?` against `Lyon is a city
+    // in France`.  Reading that off `runs[0]` assumed the weave had already
+    // eliminated everything the point shares with the dominant, which is the
+    // elimination deciding the schema again: relaxed, the same point also aligns
+    // the query's trailing ` France` (cs 17, frame it shares with `what is the
+    // capital of France?`), that run sorts FIRST, and redirection stopped seeing
+    // a named substitute at all.  Scanning the point's runs for the naming one
+    // is the same reading, taken from the runs rather than from their order, and
+    // "latest named" then means latest by the run actually relied on.
+    const named = points.flatMap((p) => {
+        const r = p.runs.find((r) => r.cs === 0 && usable(r.qs, r.qe));
+        return r !== undefined ? [{ point: p, run: r }] : [];
+    });
+    // …and it must be named AFTER what it displaces.  Redirection replaces the
+    // ANSWER, so the substitute is the newest thing the query says — `…of France
+    // were Lyon?` names Lyon past everything the displaced structure aligned.
+    // The old `latest last run` reduce encoded this implicitly and only held
+    // while trimming kept the dominant's runs latest; stated on the naming run
+    // it is the same reading without that dependency.  Measured on test/29 D1
+    // (`steel is frigid`), where the point with a naming run is the SUBJECT at
+    // q0-9, ahead of the dominant's q5-15: redirection must not fire, and
+    // substitution — which is what that shape is — keeps the case.
+    const last = argmaxBy(named.filter((n) => n.run.qs > lastRun(dominant).qs), (n) => n.run.qs, -Infinity, true)?.item;
     // Displacement test, capped at the hub bound: a hub anchor can carry a
     // corpus-sized fan-out, and each continuation costs a full byte
     // reconstruction plus an O(|query|·|bytes|) scan.  The first √N edges (the
@@ -364,16 +534,14 @@ export async function counterfactualTransfer(ctx, query, pre) {
     const domNext = ctx.store.nextFirst(dominant.anchor, hubBound(ctx));
     const displaced = domNext
         .every((n) => indexOf(query, read(ctx, n), 0) < 0);
-    if (last !== dominant &&
-        last.runs[0].cs === 0 && displaced &&
-        usable(last.runs[0].qs, last.runs[0].qe)) {
-        const g = await project(ctx, last.anchor, qv);
+    if (last !== undefined && last.point !== dominant && displaced) {
+        const g = await project(ctx, last.point.anchor, qv);
         if (g !== null) {
             ctx.trace?.step("projectCounterfactual", [
                 rNode(ctx, dominant.anchor, "displaced-structure"),
-                rNode(ctx, last.anchor, "substitute"),
+                rNode(ctx, last.point.anchor, "substitute"),
             ], [rItem(g, "projection")], "the substitute's own fact replaces the displaced structure's answer");
-            record(g, "counterfactual redirection — the named substitute's fact is followed", new Set([dominant.anchor, last.anchor]), 
+            record(g, "counterfactual redirection — the named substitute's fact is followed", new Set([dominant.anchor, last.point.anchor]), 
             // One forward projection across the substitute's own fact.
             STEP, 
             // What redirection READ: the displaced structure's own recognized
@@ -381,7 +549,7 @@ export async function counterfactualTransfer(ctx, query, pre) {
             // being overridden, it just doesn't answer from it) plus the named
             // substitute's own aligned run — not every OTHER point the weave
             // happened to align.
-            [...runSpans(dominant), ...runSpans(last)]);
+            [...runSpans(dominant), ...runSpans(last.point)]);
         }
     }
     // ── COMPARISON ─────────────────────────────────────────────────────
@@ -408,7 +576,19 @@ export async function counterfactualTransfer(ctx, query, pre) {
     // distinction perception can make — the same quantum countClusters separates
     // neighbourhoods by — so a context within one quantum of the query's length
     // carries no independently perceivable unit beyond it and is the same scale.
-    const queryScale = (n) => n - query.length < quantum;
+    //
+    // ONE QUANTUM OF EXCESS IS AN ABSOLUTE UNIT, AND SCALE IS NOT ABSOLUTE.
+    // `n - query.length < quantum` calls a 504-byte context the same scale as a
+    // 500-byte query while refusing a 47-byte context on a 42-byte one — the
+    // same 5 bytes, opposite verdicts, because the bar never looks at what it is
+    // measuring against.  Measured on test/29 C3, whose query is C2's verbatim:
+    // the climb elects the exemplar SENTENCE (47) rather than the entity, five
+    // bytes past a 42-byte query, and comparison refused a pair it accepts at
+    // C2's grain.  Read the excess against the query with `dominates` — the same
+    // half-dominance predicate this file uses for frame, and the one scale-free
+    // reading of "the seat sentence must not dominate the comparison" available
+    // without inventing a ratio.
+    const queryScale = (n) => !dominates(n - query.length, query.length);
     const analogs = [];
     for (const p of points) {
         if (p === dominant)
@@ -492,8 +672,85 @@ export async function counterfactualTransfer(ctx, query, pre) {
     // content the query never asked about.  Computed once here; both the
     // hub fallback below and the comparison gate consume it.
     const rootTrusted = roots.some((r) => r.vote >= consensusFloor(corpusN(ctx)));
+    // The context that ESTABLISHES a filler — the same reverse context, under
+    // the same naming test, `seatOfNode` uses to VOICE an analog (a predecessor
+    // whose bytes CONTAIN the node's: it names or describes it, rather than
+    // merely having preceded it somewhere).  Memoised: the analogy loop below
+    // asks about the same dominant every time, and only ever asks at all when
+    // the cheap tiers already read zero.
+    // A NODE NOTHING ESTABLISHES IS ITS OWN ESTABLISHING CONTEXT — the same
+    // reading `seatOfNode` takes one gate up: a bare filler was learnt as some
+    // context's answer and has a predecessor that NAMES it, so no establishing
+    // predecessor means the node already IS a learnt context.  Returning null
+    // there made the tier depend on both sides being elected at the same GRAIN:
+    // test/29 C2's climb elects the entity `Leonardo da Vinci` (established by
+    // `The Mona Lisa was painted by…`) and reads 0.371, while C3's identical
+    // query elects that sentence ITSELF for the same side, whose own
+    // predecessor establishes nothing — the tier read 0.000 and comparison
+    // never fired, on a pair that is strictly MORE explicit about its frame.
+    const estMemo = new Map();
+    const establishing = (id) => {
+        const hit = estMemo.get(id);
+        if (hit !== undefined)
+            return hit;
+        const own = read(ctx, id);
+        const rev = reverseContext(ctx, id, pre.guide);
+        const out = rev !== null && indexOf(rev, own, 0) >= 0 ? rev : own;
+        estMemo.set(id, out);
+        return out;
+    };
+    // COMPARISON VOICES WHAT IT COMPARED.  When the frame tier decided the
+    // analogy, the two establishing contexts it read ARE the roles being
+    // compared, so the schema below voices those same bytes instead of
+    // re-deriving a seat that can land somewhere else entirely.  Measured on
+    // test/29 C3: the dominant is the exemplar sentence `The Mona Lisa was
+    // painted by Leonardo da Vinci.`, nothing establishes it, so `seatOf`
+    // took its FORWARD continuation and voiced `Leonardo was a Renaissance
+    // polymath` — the analog's own biography, exactly what C2 pins comparison
+    // must never leak, from the branch whose own doc says forward completion
+    // is right for a DOMINANT (true when the dominant is a bare name whose
+    // continuation establishes it; false when it already IS the establishing
+    // context).  Only frame-tier pairs are affected: a halo-tier analogy was
+    // never measured on these bytes and keeps the seat it always had.
+    const frameSeats = new Map();
     for (const c of analogs) {
-        const { score: sim, halo } = await analogyStrength(ctx, dominant.anchor, c.anchor);
+        const ev = await analogyStrength(ctx, dominant.anchor, c.anchor);
+        let sim = ev.score;
+        const halo = ev.halo;
+        // ROLE IS ESTABLISHED BY CONTEXT, NOT BY A NAME.  When neither halo tier
+        // fired and the two anchors' own bytes share no learnt frame either, the
+        // anchors are FILLERS — bare entity names — not the frame-bearing
+        // structures the tier is about.  Read the tier on what establishes each
+        // one instead: the aligned point's own context (or, for a hop-reached
+        // candidate, the point whose continuation edge reached it — the same
+        // context `cmpAccounted` already prices as that hop's query evidence).
+        // Both are ALREADY IN HAND, so this costs no extra read.
+        //
+        // Measured on test/29's corpus: "Michelangelo" vs "Homer" reads 0.000
+        // while "The David was sculpted by Michelangelo." vs "The Iliad was
+        // written by Homer." reads 0.452 — and a context in a different frame
+        // ("Water boils at one hundred degrees.") still reads 0.000.  The tier
+        // was never failing to discriminate; it was reading the fillers.
+        //
+        // Still the FRAME tier (`halo` stays false), so this evidence remains
+        // subject to the naming / trusted-root bar the comparison gate holds all
+        // frame evidence to — a wider READING of the same tier, not a new licence.
+        // Containment is excluded for the same reason the generator excludes it:
+        // a context that contains the other establishes nothing independent.
+        if (!halo && sim === 0) {
+            // For a hop-reached candidate the thing whose ROLE is in question is
+            // the point the query named, not the fact one edge past it: "Homer"
+            // was named and "The Iliad was written by Homer." establishes it,
+            // while the hop's own destination ("Homer was an ancient Greek poet")
+            // has no establishing predecessor at all.  The same reading
+            // `namedByQuery` and `cmpAccounted` already take of a hop.
+            const da = establishing(dominant.anchor);
+            const ca = establishing(c.point !== null ? c.anchor : c.src.anchor);
+            if (indexOf(da, ca, 0) < 0 && indexOf(ca, da, 0) < 0) {
+                sim = sharedFrameStrengthOf(ctx, da, ca);
+                frameSeats.set(c, [da, ca]);
+            }
+        }
         ctx.trace?.step("tryAnalog", [
             rNode(ctx, dominant.anchor, "dominant"),
             rNode(ctx, c.anchor, "candidate", sim),
@@ -649,7 +906,59 @@ export async function counterfactualTransfer(ctx, query, pre) {
     // FRAME-tier or fallback analog — whose "similarity" is an unbarred
     // coverage fraction or nothing — needs the query's naming or the climb's
     // trust.
-    const analogNamed = bestAnalog !== null && namedByQuery(bestAnalog);
+    // A NAMING MUST NAME SOMETHING.  `analogNamed` licences comparison on the
+    // claim that the query's own bytes evidence the analog — but that claim is
+    // only worth what those bytes discriminate.  `edgeAncestors` already has the
+    // system's verdict for content that discriminates nothing: SATURATION, the
+    // √N parent-fan-out abstention `explainedSpan` (bridge.ts) and the climb
+    // both respect.  A window in too many places to discriminate cannot be
+    // evidence that the query meant THIS analog rather than any other.
+    //
+    // So the naming must rest on at least ONE window that is not saturated —
+    // not every window, which would be far too strong: test/29 C1's naming is
+    // [" is "=SAT, "teel"=1, " is "=SAT], and the one discriminative run is
+    // exactly what makes it a naming.  Measured over the accounted runs of
+    // every `analogNamed` comparison in the suite (contextsReached per window):
+    //
+    //   C1  " cold"=1  "teel "=1                    N=4    → names
+    //   C2  "Leonardo da Vinci"=4  " Shakespeare"=5 N=22   → names
+    //   C3  " Leonardo da Vinci"=3 " Shakespeare"=4 N=13   → names
+    //       "what i"=2 " the capital of France"=2 "Lyon"=1 → names
+    //       " is "=SAT "teel"=1 " is "=SAT                 → names
+    //       "The "=3 " painted by "=3 "Michelangelo"=2     → names
+    //   50  " name"=SAT " the "=SAT "ing "=SAT
+    //       " the "=SAT "he b"=SAT  "ing "=SAT      N=205  → names NOTHING
+    //
+    // test/50's junk comparison is the only one in the suite whose naming is
+    // saturated end to end: it "names" its analog with " the " and "ing ".  The
+    // ignored-known principle cannot reach that case — the planet probe's gaps
+    // ("planet", "biggest", "sun") are genuinely untrained, so
+    // `dismissedKnownContent` correctly returns false and there is no ignored
+    // known content to find.  This is a different question: not "did the
+    // comparison ignore what the store knows" but "did the query name this
+    // analog at all".  Derived, never tuned — the saturation limit is
+    // `edgeAncestors`' own √N, computed nowhere new.
+    const namingDiscriminates = () => {
+        const N = corpusN(ctx);
+        const W = ctx.space.maxGroup;
+        const memo = sharedReachMemo(ctx);
+        for (const [from, to] of cmpAccounted) {
+            for (let o = from; o + W <= to; o++) {
+                const ids = leafIdRun(ctx, query, o, o + W);
+                if (ids === null)
+                    continue;
+                const wid = ctx.store.findBranch(ids);
+                if (wid === null)
+                    continue;
+                const r = edgeAncestors(ctx, wid, N, memo);
+                if (!r.saturated && r.roots.length > 0)
+                    return true;
+            }
+        }
+        return false;
+    };
+    const analogNamed = bestAnalog !== null && namedByQuery(bestAnalog) &&
+        namingDiscriminates();
     // NOTE — two further gates were tried here and empirically REFUTED,
     // recorded so they are not re-tried:
     //   • dominant self-coverage (dominant's aligned runs must dominate its
@@ -677,7 +986,27 @@ export async function counterfactualTransfer(ctx, query, pre) {
     // while a scrap-matched junk pair leaves the query's own trained content
     // ("…songs…times…", "…planet…sun.") dismissed as gaps.  Halo-tier and
     // trusted-root comparisons are exempt — their evidence already stands.
-    const cmpDismisses = !(bestHalo || rootTrusted) &&
+    // A TRUSTED ROOT IS NOT A LICENCE TO IGNORE WHAT THE STORE KNOWS.  This
+    // exemption used to read `!(bestHalo || rootTrusted)`, so a root clearing
+    // consensusFloor discarded the ignored-known verdict entirely — and that
+    // verdict is the one piece of evidence in this gate that actually sees the
+    // failure: measured on test/50's probes, `dismissedKnownContent` returns
+    // TRUE for both ("songs"/"times"/"planet"-class trained content left in the
+    // comparison's gaps) while `rootTrusted` is also true, so the gate read
+    // false and comparison fired on a junk analog.
+    //
+    // The root's trust says the CLIMB settled on something; it says nothing
+    // about whether THIS comparison's own evidence covers the query's known
+    // content, which is a different question about a different quantity.  Halo
+    // stays exempt — halo-tier company is independent evidence in its own right
+    // (test/33 1b's nickname-corroborated analog), which is exactly what a
+    // pooled consensus vote is not.
+    //
+    // Measured cost, and it is a candidate COUNT, not an answer: test/33 1b
+    // ("expected at least two CAST candidates") loses one of its two, because
+    // the comparison schema now honestly declines. The junk analogs it used to
+    // supply were never the ones that test is about.
+    const cmpDismisses = !bestHalo &&
         dismissedKnownContent(ctx, query, cmpAccounted);
     if (bestAnalog !== null &&
         (bestHalo || analogNamed || rootTrusted) &&
@@ -690,7 +1019,8 @@ export async function counterfactualTransfer(ctx, query, pre) {
             rNode(ctx, dominant.anchor, "analog", bestSim),
             rNode(ctx, bestAnalog.anchor, "analog", bestSim),
         ], [], "the two structures keep distributional company beyond chance — genuine analogs");
-        const a = await seatOf(dominant);
+        const seats = frameSeats.get(bestAnalog);
+        const a = seats !== undefined ? seats[0] : await seatOf(dominant);
         // The analog is only being CITED for comparison — the query never asked
         // about it — so its seat never chases a FORWARD continuation (see
         // seatOfNode's `allowForward`): only reverse (if a predecessor genuinely
@@ -703,9 +1033,11 @@ export async function counterfactualTransfer(ctx, query, pre) {
         // [...] context will be the seat") — its own bytes ARE that seat
         // directly, with no predecessor to even check (it was found by a
         // forward edge, not matched in the query).
-        const b = bestAnalog.point !== null
-            ? await seatOf(bestAnalog.point, false)
-            : read(ctx, bestAnalog.anchor);
+        const b = seats !== undefined
+            ? seats[1]
+            : bestAnalog.point !== null
+                ? await seatOf(bestAnalog.point, false)
+                : read(ctx, bestAnalog.anchor);
         const answer = await joinWithBridge(ctx, a, b);
         record(answer, "analogical comparison — each analog voiced by the context that establishes its role", new Set([dominant.anchor, bestAnalog.anchor]), 
         // A halo-mediated act (the analogy gate) plus two seat projections.

package/dist/src/mind/mechanisms/confluence.js

@@ -188,9 +188,25 @@ export async function confluenceJoin(ctx, query, pre) {
                         reach = Math.min(reach, reachOf(ctx, wid, N, reachMemo));
                     }
                 }
+                // ONE WINDOW IS NOT AN ENTITY.  The reach above is read at the
+                // finest grain the fold can address, where content-defined window
+                // identity is at its most phase-sensitive: a scaffolding phrase
+                // whose cut happens to land in a rare phase reads as rare content.
+                // Measured on test/29 C3, a 13-context store: the meet of `The Mona
+                // Lisa was painted by Leonardo da Vinci.` and `Hamlet was written by
+                // William Shakespeare.` came out as ` by ` at reach 3 — pure frame,
+                // priced as the corpus's third-rarest content, and voiced as the
+                // entity where the two evidence streams meet.  A single quantum
+                // agrees with half the corpus by accident (the same argument
+                // pipeline-mechanism.ts's proposed-run gate makes about a 4-byte
+                // span), so a meet must clear the two-quantum floor this file's own
+                // entry gate uses — the smallest span that carries a perceivable
+                // unit BEYOND the one being matched.
+                const len = e - s;
+                if (len < 2 * W)
+                    continue;
                 if (!isFinite(reach) || dominates(reach, N))
                     continue;
-                const len = e - s;
                 if (met === null || reach < met.reach ||
                     (reach === met.reach && len > met.len)) {
                     met = { bytes: aBytes.subarray(s, e), reach, len, a, b };

package/dist/src/mind/mechanisms/recall.js

@@ -4,7 +4,7 @@
 // index and grounds the nearest learned form.  Four tiers, orderly degrading
 // from exact self-match to honest echo.
 import { cosine } from "../../vec.js";
-import { consensusFloor, identityBar, reachThreshold, significanceBar, } from "../../geometry.js";
+import { conceptThreshold, consensusFloor, identityBar, reachThreshold, significanceBar, } from "../../geometry.js";
 import { gistOf, read, resolve } from "../primitives.js";
 import { bytesEqual, indexOf } from "../../bytes.js";
 import { corpusN, hubBound } from "../traverse.js";
@@ -240,8 +240,22 @@ export async function recallByResonance(ctx, query, pre) {
             // bridge's structural channels (junction walks, anchor climbs) are the
             // correct proposal source for a query whose gist has no clean match;
             // the ANN cannot propose what the gist cannot rank.
-            const marketScale = k * ctx.space.maxGroup;
-            if (corpusN(ctx) <= marketScale ** 3) {
+            // The condition above is the SCORE of the top hit, not the size of the
+            // corpus.  It used to be spelled `corpusN(ctx) <= (k · W)³`, which asks
+            // a different question and answers it wrongly at exactly the scale the
+            // note was written from: on the trained store N = 325,608 with k = 24
+            // and W = 4 puts the cube at 884,736, so that store took the exhaustive
+            // branch — the very branch measured here as 38K–40K annVectorReads.
+            // Measured cost of the mismatch: substitutionBridge 8,544ms of a
+            // 19,548ms think (44%), against 1,248ms and 14,218ms without it, with
+            // every answer in the battery byte-identical and the suite unchanged
+            // at 445/445.  Corpus size was never the discriminator; whether the
+            // gist ranks ANYTHING at concept level is.
+            //
+            // Reading it as the note states also removes a duplicated (k · W)³ —
+            // the same cube gates crossRegionVotes' walk budget, where it likewise
+            // never engages at real scale (see attention.ts).
+            if (whole.length > 0 && whole[0].score >= conceptThreshold(ctx.store.D)) {
                 const exhaustive = await ctx.store.resonate(queryGist, hubBound(ctx), true);
                 return exhaustive.map((h) => h.id);
             }

package/dist/src/mind/pipeline-mechanism.d.ts

@@ -90,6 +90,10 @@ export interface WeaveInfo {
         vote: number;
         ctx: Uint8Array;
         runs: GradedRun[];
+        /** The query span the CLIMB elected this anchor from — its evidence,
+         *  independent of any literal run alignment (see Attention.start/end). */
+        start: number;
+        end: number;
     }>;
     /** Weighted depth at each query byte — sum of alignment weights.
      *  `depth[i]` is the total evidence that byte i is shared among the