@hviana/sema 0.4.4 → 0.4.6

package/src/mind/mechanisms/cast.ts

@@ -14,13 +14,20 @@
 import type { MindContext } from "../types.js";
 import type { Vec } from "../../vec.js";
 import { read } from "../primitives.js";
-import { argmaxBy, corpusN, hubBound } from "../traverse.js";
+import {
+  argmaxBy,
+  corpusN,
+  edgeAncestors,
+  hubBound,
+  sharedReachMemo,
+} from "../traverse.js";
 import {
   analogyStrength,
   follow,
   type GradedRun,
   project,
   reverseContext,
+  sharedFrameStrengthOf,
 } from "../match.js";
 import { joinWithBridge } from "../resonance.js";
 import { restatesQuery } from "../reasoning.js";
@@ -34,6 +41,7 @@ import {
 } from "../rationale.js";
 import { rItem, rNode } from "../trace.js";
 import { dismissedKnownContent } from "../bridge.js";
+import { leafIdRun } from "../canonical.js";
 
 // ── CAST gates ────────────────────────────────────────────────────────────
 //
@@ -218,7 +226,94 @@ export async function counterfactualTransfer(
   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: typeof points[0]): Set<number> => {
+    const set = new Set<number>();
+    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<number>()
+    : 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 ` +
@@ -290,11 +385,39 @@ export async function counterfactualTransfer(
     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: GradedRun): number =>
+    pre.rec.sites.findIndex((s) => r.qs >= s.start && r.qe <= s.end);
+  const namedSites = new Set<number>();
+  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 ` +
@@ -357,11 +480,30 @@ export async function counterfactualTransfer(
   const qv = pre.guide;
 
   // ── SUBSTITUTION ──────────────────────────────────────────────────
-  const fillerOf = (s: Point): Uint8Array => {
-    const r = s.runs[0];
-    return r.cs < quantum
+  const fillerOf = (s: Point, r: GradedRun = s.runs[0]): Uint8Array =>
+    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: Point, at: number): GradedRun | null => {
+    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
@@ -376,14 +518,19 @@ export async function counterfactualTransfer(
   // 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: Point, r: GradedRun): Point | undefined =>
+  const beforeOf = (
+    p: Point,
+    r: GradedRun,
+  ): { point: Point; run: GradedRun } | undefined =>
     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,
+      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;
@@ -395,7 +542,9 @@ export async function counterfactualTransfer(
       }
       const before = beforeOf(p, r);
       if (before === undefined) return null;
-      if (r.cs > fillerOf(before).length + quantum) return null;
+      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
@@ -407,7 +556,9 @@ export async function counterfactualTransfer(
       // 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) return null;
+      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 is NonNullable<typeof c> => c !== null);
@@ -416,7 +567,7 @@ export async function counterfactualTransfer(
   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);
@@ -429,7 +580,7 @@ export async function counterfactualTransfer(
     ctx.trace?.step(
       "projectCounterfactual",
       [
-        rItem(filler, "filler", subj.anchor),
+        rItem(filler, "filler", subj.point.anchor),
         rNode(ctx, proj.anchor, "displaced-structure"),
       ],
       [rItem(answer, "projection")],
@@ -438,7 +589,7 @@ export async function counterfactualTransfer(
     record(
       answer,
       "counterfactual substitution — the subject fills the analog's seat",
-      new Set([subj.anchor, proj.anchor]),
+      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
@@ -446,12 +597,41 @@ export async function counterfactualTransfer(
       // 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
@@ -460,18 +640,14 @@ export async function counterfactualTransfer(
   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",
@@ -479,7 +655,7 @@ export async function counterfactualTransfer(
       record(
         g,
         "counterfactual redirection — the named substitute's fact is followed",
-        new Set([dominant.anchor, last.anchor]),
+        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
@@ -487,7 +663,7 @@ export async function counterfactualTransfer(
         // 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)],
       );
     }
   }
@@ -529,7 +705,20 @@ export async function counterfactualTransfer(
   // 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: number): boolean => 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: number): boolean =>
+    !dominates(n - query.length, query.length);
   const analogs: AnalogCandidate[] = [];
   for (const p of points) {
     if (p === dominant) continue;
@@ -616,12 +805,84 @@ export async function counterfactualTransfer(
   // 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<number, Uint8Array>();
+  const establishing = (id: number): Uint8Array => {
+    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<AnalogCandidate, [Uint8Array, Uint8Array]>();
   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",
       [
@@ -790,7 +1051,56 @@ export async function counterfactualTransfer(
   // 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 = (): boolean => {
+    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
@@ -818,7 +1128,27 @@ export async function counterfactualTransfer(
   // 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 &&
@@ -838,7 +1168,8 @@ export async function counterfactualTransfer(
       [],
       "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
@@ -851,7 +1182,9 @@ export async function counterfactualTransfer(
     // [...] 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
+    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);

package/src/mind/mechanisms/confluence.ts

@@ -237,8 +237,23 @@ export async function confluenceJoin(
             reach = Math.min(reach, reachOf(ctx, wid, N, reachMemo));
           }
         }
-        if (!isFinite(reach) || dominates(reach, N)) continue;
+        // 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;
         if (
           met === null || reach < met.reach ||
           (reach === met.reach && len > met.len)

package/src/mind/mechanisms/recall.ts

@@ -6,6 +6,7 @@
 
 import { cosine } from "../../vec.js";
 import {
+  conceptThreshold,
   consensusFloor,
   identityBar,
   reachThreshold,
@@ -328,8 +329,22 @@ export async function recallByResonance(
       // 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),