@hviana/sema 0.2.7 → 0.2.9

package/dist/src/mind/attention.d.ts

@@ -2,6 +2,7 @@ import type { DerivationStep } from "./graph-search.js";
 import type { AncestorReach, Attention, AttentionRead, DFMode, MindContext, Region, RegionVote, SaturationInfo, SaturationStop } from "./types.js";
 import { type StructuralPart } from "../geometry.js";
 import { type JunctionSynonymSides } from "./junction.js";
+import type { Vec } from "../vec.js";
 /** How the newly-added graded junction ladder (junction.ts / attention.ts's
  *  {@link CrossRegionTier}) is reported on a `junctionVotes` entry.  The
  *  instrumentation spec this implements predates that ladder and only knew
@@ -357,11 +358,23 @@ export interface StructuralResonanceProposal {
     leftSiblingId?: number;
     rightSiblingId?: number;
 }
+/** A sibling gist cached in the shared, climb-wide memo alongside the
+ *  COMPLETE stored byte length it was reconstructed from — the length is
+ *  required to tell whether a cache hit is still valid under a probe whose
+ *  `maxSiblingBytes` bound is smaller than the one that first cached it. */
+interface CachedSiblingGist {
+    gist: Vec;
+    length: number;
+}
 /** Build, bound and order every mandatory structural variant (§7-8): the
  *  exact/exact composition is always kept; up to `ctx.cfg.haloQueryK`
  *  synonym variants (single- and double-synonym combined, one shared
- *  budget) are appended, ordered by confidence, then kind, then sibling id. */
-export declare function buildStructuralVariants(ctx: MindContext, ra: Region, rb: Region, sides: JunctionSynonymSides): {
+ *  budget) are appended, ordered by confidence, then kind, then sibling id.
+ *  Variant selection is entirely lightweight (see {@link
+ *  buildStructuralVariantSpecs}); a sibling's bytes are read and perceived
+ *  only for specs actually retained, and at most once per sibling id per
+ *  climb via `siblingGistMemo`. */
+export declare function buildStructuralVariants(ctx: MindContext, ra: Region, rb: Region, sides: JunctionSynonymSides, siblingGistMemo: Map<number, CachedSiblingGist>): {
     variants: StructuralVariant[];
     exactLeft: StructuralPart;
     exactRight: StructuralPart;
@@ -370,7 +383,7 @@ export declare function buildStructuralVariants(ctx: MindContext, ra: Region, rb
  *  ANN-query each, merge proposals by candidate id, and validate the winner
  *  through the SAME structural gates every other tier answers to (saturation,
  *  roots, IDF, contrastive margin).  Returns null when nothing survives. */
-export declare function structuralResonance(ctx: MindContext, query: Uint8Array, ra: Region, rb: Region, sides: JunctionSynonymSides, k: number, N: number, reachMemo: Map<number, AncestorReach>, 
+export declare function structuralResonance(ctx: MindContext, query: Uint8Array, ra: Region, rb: Region, sides: JunctionSynonymSides, siblingGistMemo: Map<number, CachedSiblingGist>, k: number, N: number, reachMemo: Map<number, AncestorReach>, 
 /** Each side's OWN individual climb roots (from voteRegions), when it cast
  *  one — the self-evidence backstop structural-resonance needs and the
  *  exact tier gets for free from literal byte containment (§11's whole

package/dist/src/mind/attention.js

@@ -916,67 +916,99 @@ const VARIANT_KIND_ORDER = {
     "right-synonym": 1,
     "double-synonym": 2,
 };
-/** A node's structural gist, read directly from its own stored bytes — the
- *  repository's node → gist accessor: content is immutable and perception is
- *  a pure function of bytes, so re-perceiving a node's full stored bytes
- *  reproduces exactly the gist it was interned with.  Never concatenates
- *  the sibling's bytes with anything else. */
-function storedNodeGist(ctx, id) {
-    return gistOf(ctx, read(ctx, id));
-}
-/** A halo sibling's structural part, occupying the ORIGINAL query-region
- *  slot length — the sibling replaces only the DIRECTION, never the query's
- *  own bytes, position, or gap (see §6 of the spec this implements). */
-function siblingPart(ctx, sibling, originalRegion) {
-    return {
-        v: storedNodeGist(ctx, sibling.id),
-        len: originalRegion.end - originalRegion.start,
-    };
+/** Same deterministic ordering the old implementation applied to already-
+ *  materialized variants (§8): semantic confidence desc, then kind
+ *  (left-synonym, right-synonym, double-synonym), then sibling ids asc. */
+function compareStructuralVariantSpecs(a, b) {
+    return b.semanticConfidence - a.semanticConfidence ||
+        VARIANT_KIND_ORDER[a.kind] - VARIANT_KIND_ORDER[b.kind] ||
+        (a.leftSiblingId ?? -1) - (b.leftSiblingId ?? -1) ||
+        (a.rightSiblingId ?? -1) - (b.rightSiblingId ?? -1);
 }
-/** Build, bound and order every mandatory structural variant (§7-8): the
- *  exact/exact composition is always kept; up to `ctx.cfg.haloQueryK`
- *  synonym variants (single- and double-synonym combined, one shared
- *  budget) are appended, ordered by confidence, then kind, then sibling id. */
-export function buildStructuralVariants(ctx, ra, rb, sides) {
-    const exactLeft = { v: ra.v, len: ra.end - ra.start };
-    const exactRight = { v: rb.v, len: rb.end - rb.start };
-    const synonymVariants = [];
-    for (const ls of sides.leftSiblings) {
-        synonymVariants.push({
-            left: siblingPart(ctx, ls, ra),
-            right: exactRight,
+/** Every single- and double-synonym combination, as cost-free descriptors —
+ *  no `read`, `gistOf`, `perceive` or `StructuralPart` allocation.  Both
+ *  sibling lists are already bounded by `haloQueryK`, so the O(haloQueryK²)
+ *  cross-product here is cheap; only the SELECTED specs go on to pay for
+ *  sibling reconstruction. */
+function buildStructuralVariantSpecs(sides) {
+    const specs = [];
+    for (const left of sides.leftSiblings) {
+        specs.push({
             kind: "left-synonym",
-            semanticConfidence: ls.score,
-            leftSiblingId: ls.id,
+            semanticConfidence: left.score,
+            leftSiblingId: left.id,
         });
     }
-    for (const rs of sides.rightSiblings) {
-        synonymVariants.push({
-            left: exactLeft,
-            right: siblingPart(ctx, rs, rb),
+    for (const right of sides.rightSiblings) {
+        specs.push({
             kind: "right-synonym",
-            semanticConfidence: rs.score,
-            rightSiblingId: rs.id,
+            semanticConfidence: right.score,
+            rightSiblingId: right.id,
         });
     }
-    for (const ls of sides.leftSiblings) {
-        for (const rs of sides.rightSiblings) {
-            synonymVariants.push({
-                left: siblingPart(ctx, ls, ra),
-                right: siblingPart(ctx, rs, rb),
+    for (const left of sides.leftSiblings) {
+        for (const right of sides.rightSiblings) {
+            specs.push({
                 kind: "double-synonym",
-                semanticConfidence: Math.min(ls.score, rs.score),
-                leftSiblingId: ls.id,
-                rightSiblingId: rs.id,
+                semanticConfidence: Math.min(left.score, right.score),
+                leftSiblingId: left.id,
+                rightSiblingId: right.id,
             });
         }
     }
-    // §8: semantic confidence desc, then kind (left-synonym, right-synonym,
-    // double-synonym), then left sibling id asc, then right sibling id asc.
-    synonymVariants.sort((a, b) => b.semanticConfidence - a.semanticConfidence ||
-        VARIANT_KIND_ORDER[a.kind] - VARIANT_KIND_ORDER[b.kind] ||
-        (a.leftSiblingId ?? -1) - (b.leftSiblingId ?? -1) ||
-        (a.rightSiblingId ?? -1) - (b.rightSiblingId ?? -1));
+    specs.sort(compareStructuralVariantSpecs);
+    return specs;
+}
+/** A halo sibling's structural gist, bounded to `maxBytes` of stored content
+ *  and reused across the whole climb.  `positiveMemo` (shared across every
+ *  probe in the climb, passed in by the caller) remembers only successfully
+ *  reconstructed complete gists together with their complete byte length —
+ *  a sibling rejected here for being too large for THIS pair's phrase-scale
+ *  bound may still be admissible for a larger-spanning pair later, so a
+ *  rejection is never memoized globally, and a sibling cached by a LARGER
+ *  probe is only reused here when its length still fits THIS probe's
+ *  (possibly smaller) bound — eligibility must never depend on which probe
+ *  happened to cache the sibling first.  `localMemo` is scoped to one
+ *  `buildStructuralVariants` call, where every variant shares the same
+ *  bound, so a `null` there is safe to reuse. */
+function loadBoundedSiblingGist(ctx, id, maxBytes, positiveMemo, localMemo) {
+    if (localMemo.has(id)) {
+        return localMemo.get(id) ?? null;
+    }
+    const cached = positiveMemo.get(id);
+    if (cached !== undefined) {
+        const result = cached.length <= maxBytes ? cached.gist : null;
+        localMemo.set(id, result);
+        return result;
+    }
+    const length = ctx.store.contentLen(id, maxBytes + 1);
+    if (length <= 0 || length > maxBytes) {
+        localMemo.set(id, null);
+        return null;
+    }
+    const bytes = read(ctx, id, maxBytes + 1);
+    if (bytes.length === 0 || bytes.length > maxBytes) {
+        localMemo.set(id, null);
+        return null;
+    }
+    const gist = gistOf(ctx, bytes);
+    positiveMemo.set(id, { gist, length });
+    localMemo.set(id, gist);
+    return gist;
+}
+/** Build, bound and order every mandatory structural variant (§7-8): the
+ *  exact/exact composition is always kept; up to `ctx.cfg.haloQueryK`
+ *  synonym variants (single- and double-synonym combined, one shared
+ *  budget) are appended, ordered by confidence, then kind, then sibling id.
+ *  Variant selection is entirely lightweight (see {@link
+ *  buildStructuralVariantSpecs}); a sibling's bytes are read and perceived
+ *  only for specs actually retained, and at most once per sibling id per
+ *  climb via `siblingGistMemo`. */
+export function buildStructuralVariants(ctx, ra, rb, sides, siblingGistMemo) {
+    const leftLen = ra.end - ra.start;
+    const rightLen = rb.end - rb.start;
+    const exactLeft = { v: ra.v, len: leftLen };
+    const exactRight = { v: rb.v, len: rightLen };
     const variants = [
         {
             left: exactLeft,
@@ -984,8 +1016,43 @@ export function buildStructuralVariants(ctx, ra, rb, sides) {
             kind: "exact-exact",
             semanticConfidence: 1,
         },
-        ...synonymVariants.slice(0, ctx.cfg.haloQueryK),
     ];
+    // Same phrase-scale bound the cross-region junction ladder uses
+    // (`maxInterior`): a sibling whose complete stored content exceeds it is
+    // not materialized as a structural-resonance endpoint, keeping sibling
+    // reconstruction phrase-scale even for a large deposit or conversation
+    // root that merely appeared in a halo result.
+    const maxSiblingBytes = (leftLen + rightLen) * ctx.space.maxGroup;
+    const specs = buildStructuralVariantSpecs(sides);
+    const localGistMemo = new Map();
+    let retainedSynonyms = 0;
+    for (const spec of specs) {
+        if (retainedSynonyms >= ctx.cfg.haloQueryK)
+            break;
+        let left = exactLeft;
+        let right = exactRight;
+        if (spec.leftSiblingId !== undefined) {
+            const gist = loadBoundedSiblingGist(ctx, spec.leftSiblingId, maxSiblingBytes, siblingGistMemo, localGistMemo);
+            if (gist === null)
+                continue;
+            left = { v: gist, len: leftLen };
+        }
+        if (spec.rightSiblingId !== undefined) {
+            const gist = loadBoundedSiblingGist(ctx, spec.rightSiblingId, maxSiblingBytes, siblingGistMemo, localGistMemo);
+            if (gist === null)
+                continue;
+            right = { v: gist, len: rightLen };
+        }
+        variants.push({
+            left,
+            right,
+            kind: spec.kind,
+            semanticConfidence: spec.semanticConfidence,
+            leftSiblingId: spec.leftSiblingId,
+            rightSiblingId: spec.rightSiblingId,
+        });
+        retainedSynonyms++;
+    }
     return { variants, exactLeft, exactRight };
 }
 /** Deterministic best-of tie-break for two proposals ranked for the SAME
@@ -1012,7 +1079,7 @@ function betterProposal(a, b) {
  *  ANN-query each, merge proposals by candidate id, and validate the winner
  *  through the SAME structural gates every other tier answers to (saturation,
  *  roots, IDF, contrastive margin).  Returns null when nothing survives. */
-export async function structuralResonance(ctx, query, ra, rb, sides, k, N, reachMemo, 
+export async function structuralResonance(ctx, query, ra, rb, sides, siblingGistMemo, k, N, reachMemo, 
 /** Each side's OWN individual climb roots (from voteRegions), when it cast
  *  one — the self-evidence backstop structural-resonance needs and the
  *  exact tier gets for free from literal byte containment (§11's whole
@@ -1021,7 +1088,7 @@ export async function structuralResonance(ctx, query, ra, rb, sides, k, N, reach
  *  evidence of a joint whole; it is that side's resonance rediscovering
  *  itself through a synthetic gist still dominated by its own direction. */
 ownRootsA, ownRootsB, trace) {
-    const { variants } = buildStructuralVariants(ctx, ra, rb, sides);
+    const { variants } = buildStructuralVariants(ctx, ra, rb, sides, siblingGistMemo);
     if (trace)
         trace.variantBudget = ctx.cfg.haloQueryK;
     const middleBytes = query.subarray(ra.end, rb.start);
@@ -1177,6 +1244,10 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo, td) {
     //
     // Only MAXIMAL spans compose: a span contained in another candidate is a
     // fragment of that candidate's evidence, never independent of it.
+    // Shared across every cross-region probe in this climb: a sibling
+    // successfully reconstructed while probing one pair must not be read and
+    // perceived again while probing another pair in the same climb.
+    const siblingGistMemo = new Map();
     const votedSpans = new Set();
     for (const rv of rvs.votes)
         votedSpans.add(`${rv.start},${rv.end}`);
@@ -1425,7 +1496,7 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo, td) {
                     }
                     const ownRootsA = rvs.votes.find((v) => v.start === ra.start && v.end === ra.end)?.roots;
                     const ownRootsB = rvs.votes.find((v) => v.start === rb.start && v.end === rb.end)?.roots;
-                    structuralPick = await structuralResonance(ctx, query, ra, rb, sides, k, N, reachMemo, ownRootsA, ownRootsB, resonanceTrace);
+                    structuralPick = await structuralResonance(ctx, query, ra, rb, sides, siblingGistMemo, k, N, reachMemo, ownRootsA, ownRootsB, resonanceTrace);
                 }
                 if (structuralPick === null) {
                     pushProbe(reasons.length > 0 ? "resonance-ineligible" : "resonance-rejected");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "type": "module",
   "main": "dist/src/index.js",

package/src/mind/attention.ts

@@ -1549,86 +1549,151 @@ const VARIANT_KIND_ORDER: Record<StructuralVariant["kind"], number> = {
   "double-synonym": 2,
 };
 
-/** A node's structural gist, read directly from its own stored bytes — the
- *  repository's node → gist accessor: content is immutable and perception is
- *  a pure function of bytes, so re-perceiving a node's full stored bytes
- *  reproduces exactly the gist it was interned with.  Never concatenates
- *  the sibling's bytes with anything else. */
-function storedNodeGist(ctx: MindContext, id: number): Vec {
-  return gistOf(ctx, read(ctx, id));
+/** A lightweight, cost-free descriptor of one candidate structural variant —
+ *  enough to rank it, but with no bytes read and no vector materialized. */
+interface StructuralVariantSpec {
+  kind: "left-synonym" | "right-synonym" | "double-synonym";
+  semanticConfidence: number;
+  leftSiblingId?: number;
+  rightSiblingId?: number;
+}
+
+/** Same deterministic ordering the old implementation applied to already-
+ *  materialized variants (§8): semantic confidence desc, then kind
+ *  (left-synonym, right-synonym, double-synonym), then sibling ids asc. */
+function compareStructuralVariantSpecs(
+  a: StructuralVariantSpec,
+  b: StructuralVariantSpec,
+): number {
+  return b.semanticConfidence - a.semanticConfidence ||
+    VARIANT_KIND_ORDER[a.kind] - VARIANT_KIND_ORDER[b.kind] ||
+    (a.leftSiblingId ?? -1) - (b.leftSiblingId ?? -1) ||
+    (a.rightSiblingId ?? -1) - (b.rightSiblingId ?? -1);
+}
+
+/** Every single- and double-synonym combination, as cost-free descriptors —
+ *  no `read`, `gistOf`, `perceive` or `StructuralPart` allocation.  Both
+ *  sibling lists are already bounded by `haloQueryK`, so the O(haloQueryK²)
+ *  cross-product here is cheap; only the SELECTED specs go on to pay for
+ *  sibling reconstruction. */
+function buildStructuralVariantSpecs(
+  sides: JunctionSynonymSides,
+): StructuralVariantSpec[] {
+  const specs: StructuralVariantSpec[] = [];
+
+  for (const left of sides.leftSiblings) {
+    specs.push({
+      kind: "left-synonym",
+      semanticConfidence: left.score,
+      leftSiblingId: left.id,
+    });
+  }
+
+  for (const right of sides.rightSiblings) {
+    specs.push({
+      kind: "right-synonym",
+      semanticConfidence: right.score,
+      rightSiblingId: right.id,
+    });
+  }
+
+  for (const left of sides.leftSiblings) {
+    for (const right of sides.rightSiblings) {
+      specs.push({
+        kind: "double-synonym",
+        semanticConfidence: Math.min(left.score, right.score),
+        leftSiblingId: left.id,
+        rightSiblingId: right.id,
+      });
+    }
+  }
+
+  specs.sort(compareStructuralVariantSpecs);
+
+  return specs;
 }
 
-/** A halo sibling's structural part, occupying the ORIGINAL query-region
- *  slot length — the sibling replaces only the DIRECTION, never the query's
- *  own bytes, position, or gap (see §6 of the spec this implements). */
-function siblingPart(
+/** A sibling gist cached in the shared, climb-wide memo alongside the
+ *  COMPLETE stored byte length it was reconstructed from — the length is
+ *  required to tell whether a cache hit is still valid under a probe whose
+ *  `maxSiblingBytes` bound is smaller than the one that first cached it. */
+interface CachedSiblingGist {
+  gist: Vec;
+  length: number;
+}
+
+/** A halo sibling's structural gist, bounded to `maxBytes` of stored content
+ *  and reused across the whole climb.  `positiveMemo` (shared across every
+ *  probe in the climb, passed in by the caller) remembers only successfully
+ *  reconstructed complete gists together with their complete byte length —
+ *  a sibling rejected here for being too large for THIS pair's phrase-scale
+ *  bound may still be admissible for a larger-spanning pair later, so a
+ *  rejection is never memoized globally, and a sibling cached by a LARGER
+ *  probe is only reused here when its length still fits THIS probe's
+ *  (possibly smaller) bound — eligibility must never depend on which probe
+ *  happened to cache the sibling first.  `localMemo` is scoped to one
+ *  `buildStructuralVariants` call, where every variant shares the same
+ *  bound, so a `null` there is safe to reuse. */
+function loadBoundedSiblingGist(
   ctx: MindContext,
-  sibling: Hit,
-  originalRegion: { start: number; end: number },
-): StructuralPart {
-  return {
-    v: storedNodeGist(ctx, sibling.id),
-    len: originalRegion.end - originalRegion.start,
-  };
+  id: number,
+  maxBytes: number,
+  positiveMemo: Map<number, CachedSiblingGist>,
+  localMemo: Map<number, Vec | null>,
+): Vec | null {
+  if (localMemo.has(id)) {
+    return localMemo.get(id) ?? null;
+  }
+
+  const cached = positiveMemo.get(id);
+  if (cached !== undefined) {
+    const result = cached.length <= maxBytes ? cached.gist : null;
+    localMemo.set(id, result);
+    return result;
+  }
+
+  const length = ctx.store.contentLen(id, maxBytes + 1);
+  if (length <= 0 || length > maxBytes) {
+    localMemo.set(id, null);
+    return null;
+  }
+
+  const bytes = read(ctx, id, maxBytes + 1);
+  if (bytes.length === 0 || bytes.length > maxBytes) {
+    localMemo.set(id, null);
+    return null;
+  }
+
+  const gist = gistOf(ctx, bytes);
+  positiveMemo.set(id, { gist, length });
+  localMemo.set(id, gist);
+  return gist;
 }
 
 /** Build, bound and order every mandatory structural variant (§7-8): the
  *  exact/exact composition is always kept; up to `ctx.cfg.haloQueryK`
  *  synonym variants (single- and double-synonym combined, one shared
- *  budget) are appended, ordered by confidence, then kind, then sibling id. */
+ *  budget) are appended, ordered by confidence, then kind, then sibling id.
+ *  Variant selection is entirely lightweight (see {@link
+ *  buildStructuralVariantSpecs}); a sibling's bytes are read and perceived
+ *  only for specs actually retained, and at most once per sibling id per
+ *  climb via `siblingGistMemo`. */
 export function buildStructuralVariants(
   ctx: MindContext,
   ra: Region,
   rb: Region,
   sides: JunctionSynonymSides,
+  siblingGistMemo: Map<number, CachedSiblingGist>,
 ): {
   variants: StructuralVariant[];
   exactLeft: StructuralPart;
   exactRight: StructuralPart;
 } {
-  const exactLeft: StructuralPart = { v: ra.v, len: ra.end - ra.start };
-  const exactRight: StructuralPart = { v: rb.v, len: rb.end - rb.start };
+  const leftLen = ra.end - ra.start;
+  const rightLen = rb.end - rb.start;
 
-  const synonymVariants: StructuralVariant[] = [];
-  for (const ls of sides.leftSiblings) {
-    synonymVariants.push({
-      left: siblingPart(ctx, ls, ra),
-      right: exactRight,
-      kind: "left-synonym",
-      semanticConfidence: ls.score,
-      leftSiblingId: ls.id,
-    });
-  }
-  for (const rs of sides.rightSiblings) {
-    synonymVariants.push({
-      left: exactLeft,
-      right: siblingPart(ctx, rs, rb),
-      kind: "right-synonym",
-      semanticConfidence: rs.score,
-      rightSiblingId: rs.id,
-    });
-  }
-  for (const ls of sides.leftSiblings) {
-    for (const rs of sides.rightSiblings) {
-      synonymVariants.push({
-        left: siblingPart(ctx, ls, ra),
-        right: siblingPart(ctx, rs, rb),
-        kind: "double-synonym",
-        semanticConfidence: Math.min(ls.score, rs.score),
-        leftSiblingId: ls.id,
-        rightSiblingId: rs.id,
-      });
-    }
-  }
-
-  // §8: semantic confidence desc, then kind (left-synonym, right-synonym,
-  // double-synonym), then left sibling id asc, then right sibling id asc.
-  synonymVariants.sort((a, b) =>
-    b.semanticConfidence - a.semanticConfidence ||
-    VARIANT_KIND_ORDER[a.kind] - VARIANT_KIND_ORDER[b.kind] ||
-    (a.leftSiblingId ?? -1) - (b.leftSiblingId ?? -1) ||
-    (a.rightSiblingId ?? -1) - (b.rightSiblingId ?? -1)
-  );
+  const exactLeft: StructuralPart = { v: ra.v, len: leftLen };
+  const exactRight: StructuralPart = { v: rb.v, len: rightLen };
 
   const variants: StructuralVariant[] = [
     {
@@ -1637,8 +1702,60 @@ export function buildStructuralVariants(
       kind: "exact-exact",
       semanticConfidence: 1,
     },
-    ...synonymVariants.slice(0, ctx.cfg.haloQueryK),
   ];
+
+  // Same phrase-scale bound the cross-region junction ladder uses
+  // (`maxInterior`): a sibling whose complete stored content exceeds it is
+  // not materialized as a structural-resonance endpoint, keeping sibling
+  // reconstruction phrase-scale even for a large deposit or conversation
+  // root that merely appeared in a halo result.
+  const maxSiblingBytes = (leftLen + rightLen) * ctx.space.maxGroup;
+
+  const specs = buildStructuralVariantSpecs(sides);
+  const localGistMemo = new Map<number, Vec | null>();
+  let retainedSynonyms = 0;
+
+  for (const spec of specs) {
+    if (retainedSynonyms >= ctx.cfg.haloQueryK) break;
+
+    let left = exactLeft;
+    let right = exactRight;
+
+    if (spec.leftSiblingId !== undefined) {
+      const gist = loadBoundedSiblingGist(
+        ctx,
+        spec.leftSiblingId,
+        maxSiblingBytes,
+        siblingGistMemo,
+        localGistMemo,
+      );
+      if (gist === null) continue;
+      left = { v: gist, len: leftLen };
+    }
+
+    if (spec.rightSiblingId !== undefined) {
+      const gist = loadBoundedSiblingGist(
+        ctx,
+        spec.rightSiblingId,
+        maxSiblingBytes,
+        siblingGistMemo,
+        localGistMemo,
+      );
+      if (gist === null) continue;
+      right = { v: gist, len: rightLen };
+    }
+
+    variants.push({
+      left,
+      right,
+      kind: spec.kind,
+      semanticConfidence: spec.semanticConfidence,
+      leftSiblingId: spec.leftSiblingId,
+      rightSiblingId: spec.rightSiblingId,
+    });
+    retainedSynonyms++;
+  }
+
   return { variants, exactLeft, exactRight };
 }
 
@@ -1675,6 +1792,7 @@ export async function structuralResonance(
   ra: Region,
   rb: Region,
   sides: JunctionSynonymSides,
+  siblingGistMemo: Map<number, CachedSiblingGist>,
   k: number,
   N: number,
   reachMemo: Map<number, AncestorReach>,
@@ -1692,7 +1810,13 @@ export async function structuralResonance(
   | { proposal: StructuralResonanceProposal; reach: AncestorReach; idf: number }
   | null
 > {
-  const { variants } = buildStructuralVariants(ctx, ra, rb, sides);
+  const { variants } = buildStructuralVariants(
+    ctx,
+    ra,
+    rb,
+    sides,
+    siblingGistMemo,
+  );
   if (trace) trace.variantBudget = ctx.cfg.haloQueryK;
 
   const middleBytes = query.subarray(ra.end, rb.start);
@@ -1864,6 +1988,10 @@ async function crossRegionVotes(
   //
   // Only MAXIMAL spans compose: a span contained in another candidate is a
   // fragment of that candidate's evidence, never independent of it.
+  // Shared across every cross-region probe in this climb: a sibling
+  // successfully reconstructed while probing one pair must not be read and
+  // perceived again while probing another pair in the same climb.
+  const siblingGistMemo = new Map<number, CachedSiblingGist>();
   const votedSpans = new Set<string>();
   for (const rv of rvs.votes) votedSpans.add(`${rv.start},${rv.end}`);
   const seen = new Set<string>();
@@ -2155,6 +2283,7 @@ async function crossRegionVotes(
             ra,
             rb,
             sides,
+            siblingGistMemo,
             k,
             N,
             reachMemo,

package/test/51-structural-resonance-ladder.test.mjs

@@ -381,6 +381,7 @@ test("7/8/9. buildStructuralVariants always includes exact-exact, left-synonym,
     ra,
     rb,
     sides,
+    new Map(),
   );
   assert.equal(variants[0].kind, "exact-exact");
   assert.equal(variants[0].semanticConfidence, 1);
@@ -410,7 +411,7 @@ test("11. synonym variants are bounded to haloQueryK, in addition to the always-
     enc("crimson"),
     enc("square"),
   );
-  const { variants } = buildStructuralVariants(m, ra, rb, sides);
+  const { variants } = buildStructuralVariants(m, ra, rb, sides, new Map());
   assert.ok(variants.length <= 1 + m.cfg.haloQueryK);
   await m.store.close();
 });
@@ -428,7 +429,7 @@ test("12. a sibling's structural part keeps the ORIGINAL query-region slot lengt
     enc("crimson"),
     enc("square"),
   );
-  const { variants } = buildStructuralVariants(m, ra, rb, sides);
+  const { variants } = buildStructuralVariants(m, ra, rb, sides, new Map());
   for (const v of variants) {
     assert.equal(
       v.left.len,
@@ -483,6 +484,7 @@ test("13/18. structuralResonance composes the real middle query bytes and applie
     ra,
     rb,
     sides,
+    new Map(),
     12,
     N,
     new Map(),
@@ -520,7 +522,7 @@ test("15. two variants proposing the SAME candidate keep only the higher-effecti
     enc("crimson"),
     enc("square"),
   );
-  const { variants } = buildStructuralVariants(m, ra, rb, sides);
+  const { variants } = buildStructuralVariants(m, ra, rb, sides, new Map());
   // Directly exercise the merge logic's contract: build two synthetic
   // proposals for the SAME id with different effectiveScore and confirm the
   // higher one is what a caller keeps (mirrors betterProposal's tie-break,
@@ -533,6 +535,7 @@ test("15. two variants proposing the SAME candidate keep only the higher-effecti
     ra,
     rb,
     sides,
+    new Map(),
     12,
     N,
     new Map(),