@hviana/sema 0.2.3 → 0.2.5

package/src/mind/junction.ts

@@ -12,6 +12,7 @@
 // adjacent ANSWER pieces) and cross-region attention (the joint CONTEXT of two
 // non-adjacent QUERY regions) ascend by the same disciplined, bounded walk.
 
+import type { Hit } from "../store.js";
 import type { MindContext } from "./types.js";
 import { read, resolve } from "./primitives.js";
 import { windowIds } from "./canonical.js";
@@ -27,6 +28,52 @@ export interface Junction {
   interior: Uint8Array;
 }
 
+/** Which relaxation produced a {@link SynonymJunction}: one side replaced by
+ *  a distributional halo sibling (`single-synonym`), or both (`double-
+ *  synonym`) — the two remaining rungs of the graded ladder below exact DAG
+ *  containment (see the module doc atop {@link junctionSynonyms}). */
+export type SynonymJunctionTier =
+  | "single-synonym"
+  | "double-synonym";
+
+export interface SynonymJunction extends Junction {
+  tier: SynonymJunctionTier;
+  /** Sibling score for a single-synonym junction; min(left, right) sibling
+   *  score for a double-synonym junction. */
+  confidence: number;
+}
+
+/** The exact node ids and halo siblings resolved for one junction call's two
+ *  sides — computed ONCE and reused by every ladder rung that needs them
+ *  (junctionSynonyms' two tiers, and the structural-resonance tier beyond
+ *  it).  A failed synonym junction means only "no common DAG container was
+ *  proven" — it does NOT mean the loaded siblings stop being useful. */
+export interface JunctionSynonymSides {
+  leftId: number | null;
+  rightId: number | null;
+  leftSiblings: Hit[];
+  rightSiblings: Hit[];
+}
+
+/** Resolve `left`/`right` to their exact node ids (when known) and load each
+ *  resolved side's halo siblings once — deterministic (haloSiblings already
+ *  ranks nearest-first) and shared by every ladder rung that consults
+ *  siblings, so no ladder rung repeats a halo ANN query the previous one
+ *  already paid for. */
+export async function loadJunctionSynonymSides(
+  ctx: MindContext,
+  left: Uint8Array,
+  right: Uint8Array,
+): Promise<JunctionSynonymSides> {
+  const leftId = resolve(ctx, left);
+  const rightId = resolve(ctx, right);
+  const leftSiblings = leftId !== null ? await haloSiblings(ctx, leftId) : [];
+  const rightSiblings = rightId !== null
+    ? await haloSiblings(ctx, rightId)
+    : [];
+  return { leftId, rightId, leftSiblings, rightSiblings };
+}
+
 /** Seed node ids to ascend from for one side of a junction: the side's own
  *  node when it is a stored form, plus — when the node has no structural
  *  parents — its canonical window ids.  A non-W-aligned node may have no
@@ -292,20 +339,32 @@ export async function junctionSynonyms(
   right: Uint8Array,
   maxInterior: number,
   unordered = false,
-): Promise<Junction[]> {
-  const out: Junction[] = [];
-
-  const lId = resolve(ctx, left);
-  const rId = resolve(ctx, right);
-  if (lId === null && rId === null) return out;
+  sides?: JunctionSynonymSides,
+): Promise<SynonymJunction[]> {
+  const s = sides ?? await loadJunctionSynonymSides(ctx, left, right);
+  if (s.leftId === null && s.rightId === null) return [];
 
-  const budget = { n: hubBound(ctx) * ctx.space.maxGroup };
+  // ── Tier 2.5a: single-synonym — one side replaced by a halo sibling ──────
+  // ONE shared expansion budget across BOTH directions of this tier.
+  const singleBudget = { n: hubBound(ctx) * ctx.space.maxGroup };
+  const singleOut = new Map<number, SynonymJunction>();
+  const keepBest = (
+    map: Map<number, SynonymJunction>,
+    j: Junction,
+    tier: SynonymJunctionTier,
+    confidence: number,
+  ) => {
+    const prev = map.get(j.id);
+    if (prev === undefined || confidence > prev.confidence) {
+      map.set(j.id, { ...j, tier, confidence });
+    }
+  };
 
   // Left-side synonyms: containers of sibling+right.  `right`'s seeds are
   // FIXED across every sibling this loop tries.
-  if (lId !== null) {
+  if (s.leftId !== null) {
     const rightSeeds = junctionSeeds(ctx, right);
-    for (const sib of await haloSiblings(ctx, lId)) {
+    for (const sib of s.leftSiblings) {
       const sibBytes = read(ctx, sib.id, maxInterior + 1);
       if (sibBytes.length === 0 || sibBytes.length > maxInterior) continue;
       const containers = junctionContainersFrom(
@@ -315,18 +374,20 @@ export async function junctionSynonyms(
         sibBytes.length + right.length + maxInterior,
         junctionSeeds(ctx, sibBytes),
         rightSeeds,
-        budget,
+        singleBudget,
         unordered,
       );
-      for (const c of containers) out.push(c);
+      for (const c of containers) {
+        keepBest(singleOut, c, "single-synonym", sib.score);
+      }
     }
   }
 
   // Right-side synonyms: containers of left+sibling.  `left`'s seeds are
   // likewise fixed across this loop.
-  if (rId !== null) {
+  if (s.rightId !== null) {
     const leftSeeds = junctionSeeds(ctx, left);
-    for (const sib of await haloSiblings(ctx, rId)) {
+    for (const sib of s.rightSiblings) {
       const sibBytes = read(ctx, sib.id, maxInterior + 1);
       if (sibBytes.length === 0 || sibBytes.length > maxInterior) continue;
       const containers = junctionContainersFrom(
@@ -336,12 +397,60 @@ export async function junctionSynonyms(
         left.length + sibBytes.length + maxInterior,
         leftSeeds,
         junctionSeeds(ctx, sibBytes),
-        budget,
+        singleBudget,
         unordered,
       );
-      for (const c of containers) out.push(c);
+      for (const c of containers) {
+        keepBest(singleOut, c, "single-synonym", sib.score);
+      }
     }
   }
 
-  return out;
+  if (singleOut.size > 0) return [...singleOut.values()];
+
+  // ── Tier 2.5b: double-synonym — BOTH sides replaced, tried only when
+  // single-synonym found NOTHING.  Every (leftSibling, rightSibling) pair,
+  // sorted deterministically, bounded to haloQueryK pairs total, ONE fresh
+  // shared budget for the whole tier. ─────────────────────────────────────
+  if (s.leftSiblings.length === 0 || s.rightSiblings.length === 0) return [];
+
+  const pairs: Array<{ l: Hit; r: Hit; confidence: number }> = [];
+  for (const l of s.leftSiblings) {
+    for (const r of s.rightSiblings) {
+      pairs.push({ l, r, confidence: Math.min(l.score, r.score) });
+    }
+  }
+  pairs.sort((a, b) =>
+    b.confidence - a.confidence ||
+    a.l.id - b.l.id ||
+    a.r.id - b.r.id
+  );
+
+  const doubleOut = new Map<number, SynonymJunction>();
+  const budget = { n: hubBound(ctx) * ctx.space.maxGroup };
+  const tries = Math.min(pairs.length, ctx.cfg.haloQueryK);
+  for (let i = 0; i < tries; i++) {
+    const { l, r, confidence } = pairs[i];
+    const lBytes = read(ctx, l.id, maxInterior + 1);
+    const rBytes = read(ctx, r.id, maxInterior + 1);
+    if (
+      lBytes.length === 0 || lBytes.length > maxInterior ||
+      rBytes.length === 0 || rBytes.length > maxInterior
+    ) continue;
+    const containers = junctionContainersFrom(
+      ctx,
+      lBytes,
+      rBytes,
+      lBytes.length + rBytes.length + maxInterior,
+      junctionSeeds(ctx, lBytes),
+      junctionSeeds(ctx, rBytes),
+      budget,
+      unordered,
+    );
+    for (const c of containers) {
+      keepBest(doubleOut, c, "double-synonym", confidence);
+    }
+  }
+
+  return [...doubleOut.values()];
 }

package/src/mind/match.ts

@@ -325,18 +325,32 @@ export async function haloSiblings(
  *  strength, not a pick.  Returns the direct halo cosine, or failing that the
  *  highest mutual-halo-sibling min-score (second-order analogy), or failing
  *  that the SHARED-FRAME strength (below) — the gate CAST's comparison
- *  schema validates genuine analogs with (bar: significanceBar). */
+ *  schema validates genuine analogs with (bar: significanceBar).
+ *
+ *  The result names its TIER alongside the score: `halo: true` means the
+ *  score cleared a significanceBar-gated HALO tier (direct company cosine
+ *  or mutual-sibling) — genuine distributional evidence; `halo: false`
+ *  means only the structural shared-frame fallback matched, a coverage
+ *  fraction with no bar of its own.  CAST's comparison gate treats the two
+ *  differently (see cast.ts): halo evidence stands alone, frame evidence
+ *  needs the query to have named the analog or the climb root to be
+ *  trusted. */
+export interface AnalogyEvidence {
+  score: number;
+  halo: boolean;
+}
+
 export async function analogyStrength(
   ctx: MindContext,
   a: number,
   b: number,
-): Promise<number> {
+): Promise<AnalogyEvidence> {
   const ha = ctx.store.halo(a);
   const hb = ctx.store.halo(b);
   if (ha && hb) {
     const bar = significanceBar(ctx.store.D);
     const direct = cosine(ha, hb);
-    if (direct >= bar) return direct;
+    if (direct >= bar) return { score: direct, halo: true };
     const sibsA = await haloSiblings(ctx, a, ha, bar);
     const sibsB = await haloSiblings(ctx, b, hb, bar);
     let best = 0;
@@ -347,9 +361,9 @@ export async function analogyStrength(
         best = Math.max(best, Math.min(x.score, y.score));
       }
     }
-    if (best > 0) return best;
+    if (best > 0) return { score: best, halo: true };
   }
-  return sharedFrameStrength(ctx, a, b);
+  return { score: sharedFrameStrength(ctx, a, b), halo: false };
 }
 
 /** The STRUCTURAL analogy tier: two nodes are analogs when their byte

package/src/mind/mechanisms/cast.ts

@@ -12,8 +12,9 @@
 // juxtapose.
 
 import type { MindContext } from "../types.js";
+import type { Vec } from "../../vec.js";
 import { read } from "../primitives.js";
-import { argmaxBy, hubBound } from "../traverse.js";
+import { argmaxBy, corpusN, hubBound } from "../traverse.js";
 import {
   analogyStrength,
   follow,
@@ -22,11 +23,17 @@ import {
   reverseContext,
 } from "../match.js";
 import { joinWithBridge } from "../resonance.js";
+import { restatesQuery } from "../reasoning.js";
 import { CONCEPT, STEP } from "../graph-search.js";
 import { concat2, indexOf } from "../../bytes.js";
-import { dominates } from "../../geometry.js";
-import { decodeText, unexplainedLabel } from "../rationale.js";
+import { consensusFloor, dominates } from "../../geometry.js";
+import {
+  decodeText,
+  unexplainedLabel,
+  unexplainedSpans,
+} from "../rationale.js";
 import { rItem, rNode } from "../trace.js";
+import { dismissedKnownContent } from "../bridge.js";
 
 // ── CAST gates ────────────────────────────────────────────────────────────
 //
@@ -80,6 +87,85 @@ export interface CastResult {
   unexplained: string;
 }
 
+/** The seat that establishes a node's role in an analogical comparison:
+ *  the REVERSE context (what leads to it) when a predecessor genuinely
+ *  ESTABLISHES id — introduces or describes it by name — else the FORWARD
+ *  continuation (what it leads to), else `fallback`.
+ *
+ *  An earlier version gated this purely on `prevCount(id) > 0`: any
+ *  predecessor at all was treated as proof of a genuine named ENTITY
+ *  (seat it by what established it), while no predecessor meant a bare
+ *  learnt CONTEXT (seat it by what it leads to, since voicing it verbatim
+ *  would answer a question with a question).  That test measured the wrong
+ *  thing — a broad sample of this store's own question-shaped nodes showed
+ *  the large majority (≈71%) have at least one predecessor, most of them a
+ *  handful of generic, high-fan-out sentences that recur as an INCIDENTAL
+ *  neighbour to dozens of otherwise-unrelated destinations (a SmolSent-
+ *  style sentence-adjacency artifact, never naming or describing what
+ *  follows).  Traced live: "What is the capital of France?" — whose own
+ *  forward edge unambiguously resolves to "The capital of France is
+ *  Paris." — has exactly one such incidental predecessor ("Create an
+ *  example of a types of questions a GPT model can answer.?"), wrongly
+ *  read as disqualifying proof of "genuine entity."
+ *
+ *  A plain forward-first swap (matching {@link project}'s universal
+ *  priority) over-corrected: test/29's C2/C3 pin that a genuine entity
+ *  analog (e.g. "Leonardo da Vinci", established by "The Mona Lisa was
+ *  painted by Leonardo da Vinci.") must be seated by that establishing
+ *  sentence, NOT by its own biography fact — voicing the bio leaks exactly
+ *  what a comparison must keep out, and loses the embedded "Mona Lisa"
+ *  term C3 relies on for a further hop.
+ *
+ *  The distinguishing signal is content-addressed, not a count: a genuine
+ *  establishing predecessor's bytes CONTAIN id's own bytes — it names or
+ *  describes id ("...painted by Leonardo da Vinci." contains "Leonardo da
+ *  Vinci").  An incidental adjacency predecessor never does — it merely
+ *  preceded id in some unrelated document without ever mentioning it.  No
+ *  new tuned constant: containment is the same primitive `restatesQuery`
+ *  and `dominates`-style checks already use throughout this codebase.
+ *
+ *  `allowForward` (default true) gates the FORWARD branch specifically —
+ *  see the call sites below: the DOMINANT is what the query is actually
+ *  ASKING, so completing it forward is the whole point; an ANALOG is only
+ *  being CITED for comparison; the query never asked about IT, so chasing
+ *  its own further continuation drifts onto whatever coincidentally
+ *  follows it in the corpus.  Traced live: the analog "What is the capital
+ *  of Japan?\nTokyo is the capital of Japan." is ALREADY a complete,
+ *  self-answering unit (prevCount 0, so no establishing predecessor
+ *  either) — its sole forward edge is "And what is the capital of the
+ *  Moon?", an unrelated quiz question sharing nothing but corpus
+ *  adjacency.  With forward disallowed, an analog like this falls through
+ *  to `fallback` — its own bytes, exactly the complete fact that made it a
+ *  genuine analog in the first place.  See
+ *  test/41-seatofnode-direction.test.mjs and
+ *  test/43-cast-analog-seat.test.mjs. */
+export async function seatOfNode(
+  ctx: MindContext,
+  id: number,
+  guide: Vec | null | undefined,
+  fallback: Uint8Array,
+  allowForward = true,
+): Promise<Uint8Array> {
+  const rev = ctx.store.prevFirst(id, hubBound(ctx));
+  if (rev.length > 0) {
+    const own = read(ctx, id);
+    const establishing = rev.some((p) => indexOf(read(ctx, p), own, 0) >= 0);
+    if (establishing) {
+      const back = reverseContext(ctx, id, guide, rev);
+      if (back !== null) return back;
+    }
+  }
+  // The "last resort, non-establishing reverse" fallback below is itself a
+  // LESS CERTAIN projection (the same tier as forward) — an analog
+  // (allowForward: false) must stop at `fallback` (its own bytes) here
+  // rather than fall back to a predecessor that already failed the
+  // establishing check just above.
+  if (!allowForward) return fallback;
+  const fwd = await follow(ctx, id, guide);
+  if (fwd !== null) return fwd;
+  return reverseContext(ctx, id, guide, rev) ?? fallback;
+}
+
 /** CAST's own entry gates, checked once here and reused by
 /** The main CAST entry point.  Given a query and its pre-computed pre.rec.sites,
  *  determine whether the query weaves together multiple independent learnt
@@ -297,7 +383,10 @@ export async function counterfactualTransfer(
     const tail = proj.ctx.subarray(seat.cs);
     let answer = await joinWithBridge(ctx, filler, tail);
     const fwd = await follow(ctx, proj.anchor, qv);
-    if (fwd !== null && indexOf(answer, fwd, 0) < 0) {
+    if (
+      fwd !== null && indexOf(answer, fwd, 0) < 0 &&
+      !restatesQuery(query, fwd)
+    ) {
       answer = concat2(answer, fwd);
     }
     ctx.trace?.step(
@@ -375,36 +464,14 @@ export async function counterfactualTransfer(
   // seed-dependent failure where the climb ranks an exemplar above a
   // person node and the person node is excluded from points by run-
   // overlap trimming.
-  // The seat that establishes a candidate's role: the REVERSE projection
-  // (the context it follows), voiced by the query gist — falling back to the
-  // candidate's own bytes when it follows nothing.  DELIBERATE STRENGTHENING
-  // over the pre-refactor code: reverseContext also returns null when the
-  // picked context READS EMPTY (a dangling id degrades to zero bytes), so a
-  // corrupted-store read now falls back here instead of voicing a hollow
-  // seat into the comparison — the same "empty bytes are no grounding"
-  // invariant project() has always enforced.
-  // A node that only ever CONTINUES — an edge SOURCE with no predecessor —
-  // is a learnt CONTEXT (a stored question-shaped frame), not an entity.
-  // Voicing it verbatim answers a question with a question (the observed
-  // cast echo: two stored questions concatenated as an "answer").  The
-  // context's role is established by what it LEADS TO, so its seat is its
-  // own continuation — the fact — with the reverse projection and the raw
-  // bytes as the ordinary fallbacks for genuine entities.
-  const seatOfNode = async (
-    id: number,
-    fallback: Uint8Array,
-  ): Promise<Uint8Array> => {
-    if (ctx.store.prevCount(id) === 0 && ctx.store.hasNext(id)) {
-      const fwd = await follow(ctx, id, qv);
-      if (fwd !== null) return fwd;
-    }
-    return reverseContext(ctx, id, qv) ?? fallback;
-  };
-  const seatOf = (p: Point): Promise<Uint8Array> => seatOfNode(p.anchor, p.ctx);
+  // The seat that establishes a candidate's role — see {@link seatOfNode}.
+  const seatOf = (p: Point, allowForward = true): Promise<Uint8Array> =>
+    seatOfNode(ctx, p.anchor, qv, p.ctx, allowForward);
   interface AnalogCandidate {
     anchor: number;
     /** The point this candidate came from, or null when it is a nextOf
-     *  descendant — then seatOfNode supplies the seat. */
+     *  descendant — then its own bytes ARE the seat (already one meaningful
+     *  hop from `src`; see the comparison gate below). */
     point: Point | null;
     /** For a nextOf descendant: the aligned point whose continuation edge
      *  named it.  Its runs ARE the query evidence this analog rests on
@@ -447,8 +514,46 @@ export async function counterfactualTransfer(
   }
   let bestAnalog: AnalogCandidate | null = null;
   let bestSim = 0;
+  let bestHalo = false;
+  // Whether the query itself NAMES a candidate.  A directly aligned point
+  // is named by construction — its runs ARE query bytes.  A hop-reached
+  // candidate is named when its own bytes contain the query text of an
+  // aligned run of the point whose continuation edge reached it (that
+  // alignment IS the query evidence the hop rests on — the same reading
+  // cmpAccounted already prices): "William Shakespeare", reached off
+  // "Macbeth was written by William Shakespeare.", contains the src's
+  // 12-byte aligned run " Shakespeare" — test/29 C2/C3.  The run must span
+  // at least TWO perception windows (2·W, the same two-quantum floor
+  // CAST's own entry gate holds the whole query to): a single shared
+  // W-window is exactly the frame tier's own evidence quantum — the level
+  // "half the corpus" shares — and stopword scraps (" the ", "he b",
+  // 4–5 bytes) never reach two windows, while a genuinely named entity
+  // does.  NOT the weave's usable()/frame filter: weave depth counts every
+  // ranked exemplar, so a query's own named entity recurring across
+  // exemplars ("Shakespeare" in Hamlet+Macbeth+…) is wrongly classified as
+  // frame — measured live, it silently disqualified C3's genuine analog.
+  const namedByQuery = (c: AnalogCandidate): boolean => {
+    if (c.point !== null) return true;
+    const bytes = read(ctx, c.anchor);
+    return c.src.runs.some((r) =>
+      r.qe - r.qs >= 2 * quantum &&
+      indexOf(bytes, query.subarray(r.qs, r.qe), 0) >= 0
+    );
+  };
+  // Whether any committed root's consensus vote clears the SAME trust bar
+  // recallByResonance applies before grounding through a climb root:
+  // consensusFloor(N) = ln(N) + 1/2.  The climb's FIRST root is
+  // deliberately floor-free (attention.ts: "the dominant one always
+  // grounds") — fine for ORIENTING mechanisms, not for voicing learnt
+  // 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)));
   for (const c of analogs) {
-    const sim = await analogyStrength(ctx, dominant.anchor, c.anchor);
+    const { score: sim, halo } = await analogyStrength(
+      ctx,
+      dominant.anchor,
+      c.anchor,
+    );
     ctx.trace?.step(
       "tryAnalog",
       [
@@ -456,11 +561,12 @@ export async function counterfactualTransfer(
         rNode(ctx, c.anchor, "candidate", sim),
       ],
       [],
-      `analogy strength ${sim.toFixed(4)}`,
+      `analogy strength ${sim.toFixed(4)}${halo ? " (halo tier)" : ""}`,
     );
     if (sim > bestSim) {
       bestSim = sim;
       bestAnalog = c;
+      bestHalo = halo;
     }
   }
   // When every candidate fails the similarity gates (halo company — now
@@ -489,6 +595,17 @@ export async function counterfactualTransfer(
     let hubMass = -1;
     const fanClamp = hubBound(ctx) + 1;
     for (const c of analogs) {
+      // A fallback comparison carries NO similarity evidence at all.  Its
+      // honesty rests on the grounding decider discounting it against
+      // richer candidates (the design note below) — an assumption that
+      // holds only when the climb itself settled on this query with real
+      // evidence.  Under a root the consensus floor does not trust, an
+      // unnamed, hop-reached hub is pure corpus adjacency: refusing it is
+      // what kept the live wrong echo silent.  A hub the query itself
+      // NAMED stays eligible either way (test/29 C2/C3's "William
+      // Shakespeare"); an unnamed one under a TRUSTED root stays eligible
+      // too (test/33 1b's deliberately weak second candidate).
+      if (!rootTrusted && !namedByQuery(c)) continue;
       // Evidence clamped at the hub bound: beyond √N + 1 the exact fan-out
       // no longer discriminates (every mega-hub ties at the clamp), and
       // counting it exactly would require the corpus-sized read.
@@ -538,10 +655,111 @@ export async function counterfactualTransfer(
   // climb's own forest, never tuned; substitution/redirection stay
   // unaffected — they orient around a displaced seat, not a whole-topic
   // analogy.
+  //
+  // roots.length <= 1 is a PROXY for "the query is about one thing" — it is
+  // only as good as the climb's own root-commitment, which depends on
+  // recognise() having found something to commit a root TO.  When the
+  // query's newest content genuinely isn't recognised (not boundary noise —
+  // real, uncommitted content; see the session's own investigation of the
+  // France→Spain live trace), the climb under-commits roots and this proxy
+  // is fooled: comparison looks licensed to treat the query as one topic
+  // when it is not.
+  //
+  // The direct check is the SAME accounted spans comparison is about to
+  // cite as its evidence: unexplainedSpans (rationale.ts, the same gap
+  // computation the trace's own `unexplained` diagnostic uses) names every
+  // stretch of the query NEITHER the dominant NOR the analog's evidence
+  // touches.  A short comparison query ("How is ice like steel?") legitimately
+  // accounts for only its two short entity spans — the surrounding "How is
+  // ... like ...?" framing is real but SHORT, split into several small gaps,
+  // none of them the bulk of the query.  The live bug's shape is different in
+  // kind, not degree: ONE contiguous, substantial gap — a whole second
+  // question the query added that comparison's two spans never touch at all.
+  //
+  // Two bars, both derived, neither tuned:
+  //   • the largest gap must not DOMINATE the whole query (the same
+  //     predicate CAST's own frame gate uses) — rules out a gap that is
+  //     most of the query outright;
+  //   • the largest gap must be SMALLER than the dominant's own established
+  //     context.  A gap can't be dismissed as mere connective framing once
+  //     it is at least as large as the topic being compared FROM — at that
+  //     scale it isn't glue between two named things, it's substantial
+  //     enough to be a second topic in its own right.  This is what
+  //     actually separates the live bug (a 47-byte gap against a 30-byte
+  //     dominant — the ignored content is bigger than the topic itself)
+  //     from ordinary short comparisons (a 9-byte gap against an 11-byte
+  //     dominant — the gap is smaller than what's being compared): the two
+  //     cases land on the same side of "half the query" often enough
+  //     (both can exceed or clear it) that the query-relative bar alone
+  //     does not reliably separate them — the topic-relative scale does.
+  const cmpAccounted: Array<[number, number]> = bestAnalog !== null
+    ? [...runSpans(dominant), ...runSpans(bestAnalog.point ?? bestAnalog.src)]
+    : [];
+  const cmpGaps = unexplainedSpans(query.length, cmpAccounted);
+  const cmpMaxGap = cmpGaps.reduce((n, [s, e]) => Math.max(n, e - s), 0);
+  // An analog that is not itself a directly ALIGNED point (point !== null —
+  // its own runs are query bytes, the query NAMED it) was only reached
+  // through a continuation hop or the structural-hub fallback.  Voicing
+  // learnt content the query never named is the same act recallByResonance
+  // refuses to perform through a climb root whose consensus vote is below
+  // consensusFloor(N) = ln(N) + 1/2 (recall.ts's minVote), so comparison
+  // holds the climb to that SAME bar before citing a hop-reached analog:
+  // some committed root must clear the floor.  The climb's FIRST root is
+  // deliberately floor-free (attention.ts: "the dominant one always
+  // grounds") — fine for ORIENTING mechanisms, not for transferring
+  // unnamed content through.  The live bug this gates (real trained store,
+  // 325k edge sources, floor 13.2): the query's stopword scraps pooled a
+  // 1.92 vote that committed an unrelated haiku exemplar as the sole root,
+  // and comparison voiced that exemplar's continuation through a
+  // hop-reached analog while every other mechanism honestly refused.  A
+  // directly aligned analog needs no floor — the query's own bytes are its
+  // evidence (test/29 C1's "Steel is hard" for "How is ice like steel?").
+  // See test/50-cast-analog-consensus-floor.
+  // A HALO-tier best analog needs neither: its similarity already cleared
+  // significanceBar-gated distributional company (analogyStrength's
+  // `halo`) — genuine evidence in its own right, the very case the halo
+  // gate exists for (test/33 1b's nickname-corroborated analog).  Only a
+  // 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);
+  // 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
+  //     own ctx): legitimate dominants sit at the same coverage as junk
+  //     ones ("The Mona Lisa was painted by…" 16/47 vs the live junk
+  //     haiku ~10/54) — no separation.
+  //   • denying the shared-frame similarity tier to hop-reached analogs:
+  //     semantically right in isolation, but it merely promoted the next
+  //     junk candidate — an ALIGNED scrap-matched point ("The affluence…",
+  //     frame 0.157) — into bestAnalog on the live store, and the aligned
+  //     configuration is byte-structurally IDENTICAL to test/29 C1's
+  //     legitimate one ("Steel is hard", frame 0.364): every derived
+  //     local separator measured (run length, site overlap, frame
+  //     query-containment, weave-usable classification) falls on the same
+  //     side for both.  Only corpus-scale consensus separates them, which
+  //     is exactly what `rootTrusted` prices.
+  // FRAME-tier evidence under an UNTRUSTED root is comparison's weakest
+  // licence (an unbarred coverage fraction, a climb the consensus floor
+  // does not trust).  There it is additionally held to the IGNORED-KNOWN
+  // principle (dismissedKnownContent, bridge.ts): the two analogs' aligned
+  // runs must account for every STORED window of the query.  This is the
+  // byte-structural separator the refuted-gates note below could not find
+  // locally: a legitimate small-corpus comparison ("How is ice like
+  // steel?") leaves only UNATTESTED spans ("How ", " like ") unexplained,
+  // 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) &&
+    dismissedKnownContent(ctx, query, cmpAccounted);
   if (
     bestAnalog !== null &&
+    (bestHalo || analogNamed || rootTrusted) &&
+    !cmpDismisses &&
     dominant.ctx.length <= query.length &&
-    roots.length <= 1
+    roots.length <= 1 &&
+    !dominates(cmpMaxGap, query.length) &&
+    cmpMaxGap < dominant.ctx.length
   ) {
     ctx.trace?.step(
       "validateAnalogy",
@@ -553,9 +771,21 @@ export async function counterfactualTransfer(
       "the two structures keep distributional company beyond chance — genuine analogs",
     );
     const a = 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
+    // establishes it) or its own bytes.  A DIRECTLY aligned point
+    // (bestAnalog.point !== null) still goes through seatOfNode for that
+    // reverse check (a bare entity NAME like "Leonardo da Vinci" needs it —
+    // test/29's C2/C3).  A nextOf DESCENDANT (point === null) was already
+    // reached by following ONE meaningful hop off another aligned point (the
+    // alignment loop above: "its nextOf is the hub... and the hub's own
+    // [...] 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)
-      : await seatOfNode(bestAnalog.anchor, read(ctx, bestAnalog.anchor));
+      ? await seatOf(bestAnalog.point, false)
+      : read(ctx, bestAnalog.anchor);
     const answer = await joinWithBridge(ctx, a, b);
     record(
       answer,
@@ -568,10 +798,32 @@ export async function counterfactualTransfer(
       // when it was an aligned point, else the source point whose
       // continuation edge reached it (that alignment IS the query evidence
       // the hop rests on).
+      cmpAccounted,
+    );
+  } else if (
+    bestAnalog !== null &&
+    dominant.ctx.length <= query.length &&
+    roots.length <= 1
+  ) {
+    ctx.trace?.step(
+      "validateAnalogy",
       [
-        ...runSpans(dominant),
-        ...runSpans(bestAnalog.point ?? bestAnalog.src),
+        rNode(ctx, dominant.anchor, "analog", bestSim),
+        rNode(ctx, bestAnalog.anchor, "analog", bestSim),
       ],
+      [],
+      !(bestHalo || analogNamed || rootTrusted)
+        ? `the best analog carries no halo-tier company evidence, was never ` +
+          `named by the query, and no committed root's consensus vote ` +
+          `clears the floor, so comparison refuses to voice it`
+        : cmpDismisses
+        ? `a frame-tier analog under an untrusted root dismisses stored ` +
+          `query content its alignment never accounted for — comparison ` +
+          `refuses to ignore what the store knows`
+        : `comparison's own accounted evidence leaves a ${cmpMaxGap}-byte gap in ` +
+          `a ${query.length}-byte query against a ${dominant.ctx.length}-byte ` +
+          `dominant — too large to be mere framing — so it refuses rather ` +
+          `than paper over it with an analog the query never asked about`,
     );
   }
   t?.done(