@hviana/sema 0.9.0 → 0.9.2

package/dist/src/mind/recognition.js

@@ -5,10 +5,11 @@
 //               that leads somewhere (has a continuation edge or a halo).
 //   segment   — leaf-parent segmentation using the geometry's own groupings.
 import { rItem } from "./trace.js";
-import { canonResolve, foldTree, gistOf, latin1Key, perceive, resolve, } from "./primitives.js";
+import { canonResolve, foldTree, gistOf, perceive, resolve, } from "./primitives.js";
 import { atomIsHub, bearsEdge, corpusN, leadsSomewhere } from "./traverse.js";
 import { chainReach, leafIdAt, leafIdRun } from "./canonical.js";
 import { canonHash } from "../canon.js";
+import { latin1 } from "../bytes.js";
 import { isChunk } from "../sema.js";
 /** Decompose a byte stream into every stored form that leads somewhere
  *  (has a continuation edge or a halo).  Two complementary readings:
@@ -77,7 +78,7 @@ export function recognise(ctx, bytes) {
     // not silent), so it is emitted here directly rather than only inside
     // recogniseImpl.
     if (ctx.recogniseMemo) {
-        const key = latin1Key(bytes);
+        const key = latin1(bytes);
         const hit = ctx.recogniseMemo.get(key);
         if (hit !== undefined) {
             if (ctx.meter)
@@ -483,9 +484,21 @@ function recogniseImpl(ctx, bytes) {
             // encoding is the identity, so the span's bytes ARE the branch key.
             // `subarray` is a view — this allocates nothing per probe, and the
             // bloom filter answers the misses without touching the database.
-            const flatProbe = (start, end) => store.findFlatBranch
-                ? store.findFlatBranch(bytes.subarray(start, end))
-                : store.findBranch(allLeafIds.slice(start, end));
+            //
+            // Through ONE span prober (Store.flatSpans), because hashing the key was
+            // itself the quadratic: every probe hashed its span from the start, and
+            // the interior pass below sweeps up to `reach` ends past each endpoint —
+            // O(n · reach²) bytes hashed.  Measured on the 31.7M-node store, one
+            // composition-regime response (#97 of the battery) probed 2,079,400
+            // spans and hashed 251,660,406 bytes for them.  The prober extends each
+            // start's hash instead, so the same probes, answered identically, cost
+            // O(n · reach).
+            const spans = store.flatSpans?.(bytes) ?? null;
+            const flatProbe = (start, end) => spans !== null
+                ? spans(start, end)
+                : store.findFlatBranch
+                    ? store.findFlatBranch(bytes.subarray(start, end))
+                    : store.findBranch(allLeafIds.slice(start, end));
             // THE TWO ROUTES COST DIFFERENT THINGS, SO THEY ARE PRICED SEPARATELY.
             //
             // The exact route is a bloom-gated hash over a subarray VIEW: no
@@ -627,13 +640,17 @@ function recogniseImpl(ctx, bytes) {
                 const reach = chainReach(W) * W * W + 2 * radius;
                 if (ctx.meter)
                     ctx.meter.recogniseInteriorGaps += ordered.length;
+                // Each end pairs only with the starts in [end − reach, end − W], in
+                // ascending order — the pairs, and the order the budget is spent in,
+                // of the all-pairs scan, without its O(n²) enumeration.
+                let lo = 0;
                 for (const end of ordered) {
-                    for (const start of ordered) {
-                        if (start >= end)
-                            continue;
-                        const span = end - start;
-                        if (span < W || span > reach)
-                            continue;
+                    while (ordered[lo] < end - reach)
+                        lo++;
+                    for (let i = lo; i < ordered.length; i++) {
+                        const start = ordered[i];
+                        if (end - start < W)
+                            break;
                         if (ctx.meter)
                             ctx.meter.recogniseInteriorPairs++;
                         spend(start, end);
@@ -672,8 +689,7 @@ function recogniseImpl(ctx, bytes) {
     // arithmetic, not evidence.  Removing it wholesale was measured and
     // REVERTED: it also drops legitimate multi-byte chains (the 12-byte
     // "Eiffel Tower" site vanished with it).  The premise is wrong but the
-    // trust it stood in for is real; a replacement signal is still open work.
-    // See bench/README.md.
+    // trust it stood in for is real; the replacement signal follows.
     //
     // THE REPLACEMENT SIGNAL (2026-08-13): `leadsSomewhere` on the BYTE-EXACT
     // branch the chain already found.  The blanket off-boundary suppression is

package/dist/src/mind/resonance.js

@@ -6,7 +6,7 @@
 import { rItem } from "./trace.js";
 import { cosine } from "../vec.js";
 import { mergeThreshold } from "../geometry.js";
-import { concat2, concatBytes, indexOf } from "../bytes.js";
+import { concat2, concatBytes, indexOf, latin1 } from "../bytes.js";
 import { gistOf, read, resolve, walkTree } from "./primitives.js";
 import { perceive } from "./primitives.js";
 import { argmaxCosine, candidateGist, hubBound } from "./traverse.js";
@@ -107,16 +107,6 @@ function junctionEdges(ctx, left, right, maxContainer) {
     }
     return out;
 }
-/** A byte string as a string, ONE code unit per byte — injective, so it is
- *  safe to build a cache key from.  Chunked to keep the spread within the
- *  engine's argument limit on long contexts. */
-function latin1(b) {
-    let s = "";
-    for (let i = 0; i < b.length; i += 4096) {
-        s += String.fromCharCode(...b.subarray(i, i + 4096));
-    }
-    return s;
-}
 /** Per-response memo of bridge results, keyed by the response's lifecycle
  *  object (ctx.climbMemo — created fresh by respond() and nulled after, so
  *  entries can never outlive the read-only window they are valid in).  The

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

@@ -1,5 +1,6 @@
 import { Vec } from "../vec.js";
 import type { AncestorReach, MindContext } from "./types.js";
+import { type WindowIndex } from "./evidence.js";
 /** The reach memo this ask should use — see the note above.
  *
  *  A TRACED response always gets a fresh, empty one. `AncestorReach`'s
@@ -58,9 +59,9 @@ export declare function atomIsHub(ctx: MindContext, contextCount: number): boole
  *  it is sound as a pre-filter before a consumer that applies the full
  *  predicate, and never as a replacement for it. */
 export declare function bearsEdge(ctx: MindContext, id: number): boolean;
-/** Whether a node LEADS SOMEWHERE — it bears a continuation edge or a halo.
- * The admission predicate recognition filters sites with (cover.md): a form
- * that
+/** Whether a node LEADS SOMEWHERE — the store's admission predicate
+ * ({@link Store.leadsSomewhere}: edge or halo) with its edge tier memoised for
+ * the response.  Recognition filters sites with it (cover.md): a form that
  * leads nowhere contributes nothing to any derivation. Runs once per candidate
  * span on the recognition hot path — `hasNext` is cached per response (the same
  * flat-branch ids are probed across prefix variants by canonicalChunkId).
@@ -140,8 +141,10 @@ export declare function argmaxCosine<T>(query: Vec, items: Iterable<T>, vecOf: (
  *  formRules all share.  undefined when the node has no continuation. */
 export declare function guidedFirst(ctx: MindContext, id: number): number | undefined;
 export declare function guidedNext(ctx: MindContext, node: number): number | undefined;
-/** Disambiguate among a node's learnt continuations by distributional
- *  support.  NOTE the `guide` contract: its VALUE is deliberately unused —
+/** Disambiguate among a node's learnt continuations: first by the question's
+ *  own witness of an establishing context (the exact tier, see
+ *  {@link askedContinuations}), then by distributional support.  NOTE the
+ *  `guide` contract: its VALUE is deliberately unused —
  *  only its PRESENCE gates disambiguation (a null guide means no query is in
  *  flight, so structural walkers keep plain first-edge behaviour).  The
  *  gist-cosine of short answer candidates against a query guide is dominated
@@ -153,6 +156,26 @@ export declare function guidedNext(ctx: MindContext, node: number): number | und
  *  therefore scores by guide cosine.  The two directions consult different
  *  halves of the evidence on purpose. */
 export declare function chooseNext(ctx: MindContext, id: number, guide?: Vec | null): number | undefined;
+/** The response canonicalizer's reading of `bytes` when it keeps every offset
+ *  — so a window found in the canonical bytes sits at the same place in the
+ *  asker's — else the bytes themselves.  Text canon is offset-preserving on
+ *  ASCII without interior whitespace runs; where it is not, the raw bytes are
+ *  read and a case-variant window simply does not match. */
+export declare function offsetCanon(ctx: MindContext, bytes: Uint8Array): Uint8Array;
+/** The continuations of `id` that `asked` NAMES (see {@link
+ *  askedContinuations}) — for a caller holding material other than the whole
+ *  question: the multi-hop walk asks with what of the question no product has
+ *  restated yet.  null when none is named. */
+export declare function namedContinuations(ctx: MindContext, id: number, asked: {
+    bytes: Uint8Array;
+    index: WindowIndex;
+}): number[] | null;
+/** The question spans that NAMED `pick` among `id`'s continuations — the
+ *  evidence a projection through that pick stands on, so a mechanism can
+ *  account for what the question said about it (mechanism-market.md:
+ *  evidence travels).  Empty when the question names no continuation of `id`
+ *  or names others. */
+export declare function askedEvidence(ctx: MindContext, id: number, pick: number): Array<[number, number]>;
 /** The perceived gist of a candidate node, through the session gist cache.
  *  Re-gisting a candidate is a full river fold of its bytes — the measured
  *  recall bottleneck (a hub context offers up to √N continuations, EACH
@@ -198,6 +221,23 @@ export declare function chooseAmong(ctx: MindContext, candidates: readonly numbe
  * NOT scaffolding-only — it has no evidence either way, and its callers already
  * refuse it on their own terms. */
 export declare function allWindowsAreScaffolding(ctx: MindContext, query: Uint8Array): boolean;
+/** Per offset of `bytes`: 1 when the W-window there is a stored form contained
+ *  in more than √N places (corpus-global scaffolding; see the floor below),
+ *  else 0.  Memoised per
+ *  byte array for the life of the store's read-only response. */
+export declare function hubWindows(ctx: MindContext, bytes: Uint8Array): Uint8Array;
+/** The query's SCAFFOLDING CORE, as spans: the bytes every W-window over which
+ *  is a hub (see {@link hubWindows}) — what is nothing but frame, where
+ *  {@link scaffoldExtents} is what a frame window reaches. */
+export declare function scaffoldSpans(ctx: MindContext, query: Uint8Array): Array<[number, number]>;
+/** The EXTENTS of the query's SCAFFOLDING windows, merged: every byte some
+ *  W-window reaches that is a stored form contained in more than √N places —
+ *  corpus-global commonality (commonality.md), the same "hub" reading as
+ *  {@link allWindowsAreScaffolding} and the bridge's `explainedSpan`.  A window
+ *  the store never saw is NOT scaffolding.  The extent, not the core, is what
+ *  a coverage test needs: a span that still holds one hub window can be
+ *  "carried" by any fact that holds that window. */
+export declare function scaffoldExtents(ctx: MindContext, query: Uint8Array): Array<[number, number]>;
 /** Trained forms the query may OPEN, proposed from the write side's own
  *  leaf-id window index — the supply of last resort for prefix completion.
  *

package/dist/src/mind/traverse.js

@@ -7,13 +7,15 @@
 // project) live in match.ts — the elementary match-and-project operation.
 import { cosine } from "../vec.js";
 import { gistOf, read } from "./primitives.js";
-import { canonicalWindows, leafIdPrefix, leafIdRun } from "./canonical.js";
+import { canonicalWindows, chainReach, leafIdPrefix, leafIdRun, } from "./canonical.js";
 // Imported at the TOP, where every other import is.  They used to sit 800 lines
 // down under a note claiming the position mattered ("before trace module is
 // loaded") — it does not: an ES module's static imports are HOISTED, so the
 // file's line order never decides load order.  The note described an intention
 // the runtime does not honour; the imports move and the claim goes.
 import { decodeText } from "./rationale.js";
+import { latin1 } from "../bytes.js";
+import { windowIndex, witness } from "./evidence.js";
 //
 // Budgeted on the same terms as the reach memo below (caches.md): these three
 // maps are cleared on every write, but a long read-only session over a large
@@ -432,9 +434,9 @@ export function atomIsHub(ctx, contextCount) {
 export function bearsEdge(ctx, id) {
     return cachedHasNext(ctx, id, getStructCache(ctx));
 }
-/** Whether a node LEADS SOMEWHERE — it bears a continuation edge or a halo.
- * The admission predicate recognition filters sites with (cover.md): a form
- * that
+/** Whether a node LEADS SOMEWHERE — the store's admission predicate
+ * ({@link Store.leadsSomewhere}: edge or halo) with its edge tier memoised for
+ * the response.  Recognition filters sites with it (cover.md): a form that
  * leads nowhere contributes nothing to any derivation. Runs once per candidate
  * span on the recognition hot path — `hasNext` is cached per response (the same
  * flat-branch ids are probed across prefix variants by canonicalChunkId).
@@ -599,8 +601,10 @@ export function guidedNext(ctx, node) {
         ctx._edgeChoice.set(node, pick ?? -1);
     return pick;
 }
-/** Disambiguate among a node's learnt continuations by distributional
- *  support.  NOTE the `guide` contract: its VALUE is deliberately unused —
+/** Disambiguate among a node's learnt continuations: first by the question's
+ *  own witness of an establishing context (the exact tier, see
+ *  {@link askedContinuations}), then by distributional support.  NOTE the
+ *  `guide` contract: its VALUE is deliberately unused —
  *  only its PRESENCE gates disambiguation (a null guide means no query is in
  *  flight, so structural walkers keep plain first-edge behaviour).  The
  *  gist-cosine of short answer candidates against a query guide is dominated
@@ -621,13 +625,30 @@ export function chooseNext(ctx, id, guide) {
         return undefined;
     if (nx.length === 1 || !guide)
         return nx[0];
+    // THE EXACT TIER — the continuation the QUESTION names.  Every other
+    // disambiguation below reads popularity, and is right to refuse the gist (see
+    // the doc above); but the corpus also wrote down, for each continuation,
+    // WHICH QUESTIONS IT ANSWERS — its establishing contexts — and a question is
+    // not a gist.  When one of them is witnessed by the asker's bytes plus the
+    // node's own, that continuation is the one being asked for.  Measured on the
+    // 31.7M-node store: `Who is the father of Frederick II?` answered the
+    // citizenship fact (the most-poured of eight) while `Frederick II father` —
+    // one of the father fact's own establishing contexts — lay wholly inside the
+    // question.  Exact, so it ranks first (exact-vs-approximate.md); when nothing
+    // is witnessed the ladder below decides exactly as before.
+    const asked = ctx._edgeAsked;
+    const named = asked === null ? null : askedContinuations(ctx, id, nx, asked);
+    if (named !== null && named.length === 1)
+        return named[0];
     // Cap candidates at √N — the same bound the original chooseAmong used.
     // A hub context can accumulate thousands of continuations; the best-fit
     // one is among the first √N by insertion order (edges are never deleted,
     // so the oldest are the most established).  A strongly-supported edge
     // inserted beyond the cap is invisible here — the deliberate trade
-    // against paying O(fan-out) count reads on every disambiguation.
-    const capped = nx; // already the hub-capped prefix, by the read above
+    // against paying O(fan-out) count reads on every disambiguation.  Several
+    // continuations named EQUALLY by the question are told apart by the same
+    // ladder, over them alone.
+    const capped = named ?? nx; // already the hub-capped prefix, by the read above
     // Distributional-evidence disambiguation, consulting BOTH read-outs of the
     // evidence the training poured:
     //   1. prevCount — how many DISTINCT contexts predict this candidate (one
@@ -691,6 +712,184 @@ export function chooseNext(ctx, id, guide) {
     }
     return best;
 }
+/** The response canonicalizer's reading of `bytes` when it keeps every offset
+ *  — so a window found in the canonical bytes sits at the same place in the
+ *  asker's — else the bytes themselves.  Text canon is offset-preserving on
+ *  ASCII without interior whitespace runs; where it is not, the raw bytes are
+ *  read and a case-variant window simply does not match. */
+export function offsetCanon(ctx, bytes) {
+    if (ctx.canon === null)
+        return bytes;
+    const c = ctx.canon(bytes);
+    return c.length === bytes.length ? c : bytes;
+}
+/** The continuations of `id` that `asked` NAMES (see {@link
+ *  askedContinuations}) — for a caller holding material other than the whole
+ *  question: the multi-hop walk asks with what of the question no product has
+ *  restated yet.  null when none is named. */
+export function namedContinuations(ctx, id, asked) {
+    const nx = ctx.store.nextFirst(id, hubBound(ctx));
+    return nx.length === 0 ? null : askedContinuations(ctx, id, nx, asked);
+}
+/** The continuations of `id` (among `nx`) that the question NAMES: one of
+ *  their establishing contexts — a predecessor other than `id` itself — is
+ *  wholly witnessed by the question plus `id`'s own bytes (evidence.ts), with
+ *  the question supplying at least one window the node does not.  Ranked by
+ *  how much of the question witnesses it; null when none is named.
+ *
+ *  THE NODE'S OWN BYTES ARE MATERIAL because a derivation stands on them.  On
+ *  the second hop of `Where was the place of death of the director of film
+ *  Beat Girl?` the node is `Edmond T. Gréville` — reached, never written — and
+ *  its fact's establishing context `Edmond T. Gréville place of death` is held
+ *  by neither the question nor the node, only by both.  Measured over 5,236
+ *  held-out 2Wiki questions: such a context is wholly witnessed by the
+ *  question alone 69 times, by the question and the first hop 2,153 times.
+ *
+ *  BOUNDED: predecessor reads share one √N budget across the candidates (see
+ *  the loop below), asked cheapest first; past it the tier abstains for the
+ *  rest, metered, and the ladder decides as before.
+ *  Each form is read at most to the material's length — a form longer than
+ *  everything at hand cannot be wholly witnessed without repeating it. */
+function askedContinuations(ctx, id, nx, asked) {
+    return askedEntry(ctx, id, nx, asked).named;
+}
+/** The question spans that NAMED `pick` among `id`'s continuations — the
+ *  evidence a projection through that pick stands on, so a mechanism can
+ *  account for what the question said about it (mechanism-market.md:
+ *  evidence travels).  Empty when the question names no continuation of `id`
+ *  or names others. */
+export function askedEvidence(ctx, id, pick) {
+    const asked = ctx._edgeAsked;
+    if (asked === null)
+        return [];
+    const nx = ctx.store.nextFirst(id, hubBound(ctx));
+    const entry = askedEntry(ctx, id, nx, asked);
+    return entry.named?.includes(pick) ? entry.spans.get(pick) ?? [] : [];
+}
+function askedEntry(ctx, id, nx, asked) {
+    let memo = askedMemo.get(asked);
+    if (memo === undefined)
+        askedMemo.set(asked, memo = new Map());
+    const hit = memo.get(id);
+    if (hit !== undefined && !ctx.trace)
+        return hit;
+    const entry = askedContinuationsImpl(ctx, id, nx, asked);
+    memo.set(id, entry);
+    return entry;
+}
+/** One pick per node per question — every mechanism of a response asks the
+ *  same node about the same question (the guided-pick memo's own reason). */
+const askedMemo = new WeakMap();
+function askedContinuationsImpl(ctx, id, nx, asked) {
+    const none = { named: null, spans: new Map() };
+    const W = ctx.space.maxGroup;
+    // A SATURATED READ IS NOT A CANDIDATE SET.  When the continuations came back
+    // at the √N cap the read may have cut the named one off, so "none of these is
+    // named" and "this is the named one" are both unfounded — and this is exactly
+    // where witnessing would read most.  The tier abstains, metered, and the
+    // distributional ladder decides as it always has.
+    if (nx.length >= hubBound(ctx)) {
+        if (ctx.meter)
+            ctx.meter.askedReadsSaturated++;
+        return none;
+    }
+    const cache = getStructCache(ctx);
+    const ownCap = asked.bytes.length * W;
+    const own = offsetCanon(ctx, read(ctx, id, ownCap));
+    const ownIndex = windowIndex(own, W);
+    // Naming needs the question to say at least one window the node does not:
+    // when the node already holds every window of the question (the question IS
+    // this context, or a piece of it), nothing can be named, and nothing is read.
+    let beyond = false;
+    for (const key of asked.index.keys()) {
+        if (!ownIndex.has(key)) {
+            beyond = true;
+            break;
+        }
+    }
+    if (!beyond)
+        return none;
+    const indexes = [asked.index, ownIndex];
+    const formCap = asked.bytes.length + own.length;
+    // BOUNDED READS (bounded-reads.md): the decision reads at most √N
+    // establishing contexts — floored at the write side's own arity `chainReach(W)`
+    // so a store too small for √N to cover one fact's questions still decides.
+    // Candidates are asked CHEAPEST FIRST (fewest establishing contexts): a common
+    // reply established by hundreds of contexts would otherwise spend the whole
+    // allowance alone.  The order changes what is READ, never what wins: scores
+    // are compared afterwards in the continuations' own order.
+    let budget = Math.max(hubBound(ctx), chainReach(W));
+    const order = nx
+        .map((n, at) => ({ n, at, support: cachedPrevCount(ctx, n, cache) }))
+        .filter((c) => c.support >= 2) // only `id` establishes the rest
+        .sort((a, b) => a.support - b.support || a.at - b.at);
+    const scored = [];
+    for (const { n, at, support } of order) {
+        if (support > budget) {
+            if (ctx.meter)
+                ctx.meter.askedReadsSaturated++;
+            break;
+        }
+        budget -= support;
+        if (ctx.meter)
+            ctx.meter.askedPredecessorReads += support;
+        let score = 0;
+        let by = -1;
+        let spans = [];
+        for (const c of ctx.store.prevFirst(n, support)) {
+            if (c === id)
+                continue;
+            // The form's FIRST window decides most refusals: one short prefix read
+            // before the whole form is reconstructed (a conversation-length
+            // predecessor would otherwise be read in full to fail on its opening).
+            const head = offsetCanon(ctx, read(ctx, c, W));
+            if (head.length < W)
+                continue;
+            if (!indexes.some((ix) => ix.has(latin1(head))))
+                continue;
+            const form = read(ctx, c, formCap + 1);
+            if (form.length < W || form.length > formCap)
+                continue;
+            const w = witness(offsetCanon(ctx, form), indexes, W);
+            if (!w.complete || w.bytes < W)
+                continue;
+            if (w.bytes > score) {
+                score = w.bytes;
+                by = c;
+                spans = w.spans;
+            }
+        }
+        if (score > 0)
+            scored.push({ n, at, score, by, spans });
+    }
+    scored.sort((a, b) => a.at - b.at);
+    let best = [];
+    let bestBytes = 0;
+    let witnessed = null;
+    for (const { n, score, by } of scored) {
+        if (score > bestBytes) {
+            best = [n];
+            bestBytes = score;
+            witnessed = by;
+        }
+        else if (score === bestBytes)
+            best.push(n);
+    }
+    if (best.length === 0)
+        return none;
+    if (ctx.meter)
+        ctx.meter.askedContinuations++;
+    if (ctx.trace && witnessed !== null) {
+        ctx.trace.step("askedContinuation", [rItemShort(ctx, id, "node"), rItemShort(ctx, witnessed, "asked")], best.map((n) => rItemShort(ctx, n, "named")), `${nx.length} continuations — the question witnesses ` +
+            `${best.length === 1 ? "one's" : `${best.length}'`} own establishing ` +
+            `context (${bestBytes} question byte(s) beyond the node)`);
+    }
+    const evidence = new Map();
+    for (const c of scored)
+        if (best.includes(c.n))
+            evidence.set(c.n, c.spans);
+    return { named: best, spans: evidence };
+}
 /** The perceived gist of a candidate node, through the session gist cache.
  *  Re-gisting a candidate is a full river fold of its bytes — the measured
  *  recall bottleneck (a hub context offers up to √N continuations, EACH
@@ -776,6 +975,84 @@ export function allWindowsAreScaffolding(ctx, query) {
     }
     return sawOne;
 }
+/** Per offset of `bytes`: 1 when the W-window there is a stored form contained
+ *  in more than √N places (corpus-global scaffolding; see the floor below),
+ *  else 0.  Memoised per
+ *  byte array for the life of the store's read-only response. */
+export function hubWindows(ctx, bytes) {
+    const hit = hubWindowMemo.get(bytes);
+    if (hit !== undefined)
+        return hit;
+    const W = ctx.space.maxGroup;
+    // Floored at the write side's arity: inside ONE deposit's fold a window is
+    // already contained by up to `chainReach(W)` chunks and branches, so on a
+    // store of a few facts the √N reading would call every window frame — that
+    // is fold structure, not corpus commonality.
+    const bound = Math.max(hubBound(ctx), chainReach(W));
+    const hub = new Uint8Array(Math.max(0, bytes.length - W + 1));
+    for (let o = 0; o < hub.length; o++) {
+        const ids = leafIdRun(ctx, bytes, o, o + W);
+        const id = ids === null ? null : ctx.store.findBranch(ids);
+        if (id !== null && ctx.store.containersSlice(id, bound, 1).length > 0) {
+            hub[o] = 1;
+        }
+    }
+    hubWindowMemo.set(bytes, hub);
+    return hub;
+}
+const hubWindowMemo = new WeakMap();
+/** The query's SCAFFOLDING CORE, as spans: the bytes every W-window over which
+ *  is a hub (see {@link hubWindows}) — what is nothing but frame, where
+ *  {@link scaffoldExtents} is what a frame window reaches. */
+export function scaffoldSpans(ctx, query) {
+    const W = ctx.space.maxGroup;
+    const hub = hubWindows(ctx, query);
+    const n = hub.length;
+    if (n <= 0)
+        return [];
+    const spans = [];
+    let start = -1;
+    for (let i = 0; i < query.length; i++) {
+        let all = true;
+        for (let o = Math.max(0, i - W + 1); o <= Math.min(i, n - 1); o++) {
+            if (!hub[o]) {
+                all = false;
+                break;
+            }
+        }
+        if (all && start < 0)
+            start = i;
+        if (!all && start >= 0) {
+            spans.push([start, i]);
+            start = -1;
+        }
+    }
+    if (start >= 0)
+        spans.push([start, query.length]);
+    return spans;
+}
+/** The EXTENTS of the query's SCAFFOLDING windows, merged: every byte some
+ *  W-window reaches that is a stored form contained in more than √N places —
+ *  corpus-global commonality (commonality.md), the same "hub" reading as
+ *  {@link allWindowsAreScaffolding} and the bridge's `explainedSpan`.  A window
+ *  the store never saw is NOT scaffolding.  The extent, not the core, is what
+ *  a coverage test needs: a span that still holds one hub window can be
+ *  "carried" by any fact that holds that window. */
+export function scaffoldExtents(ctx, query) {
+    const W = ctx.space.maxGroup;
+    const hub = hubWindows(ctx, query);
+    const spans = [];
+    for (let o = 0; o < hub.length; o++) {
+        if (!hub[o])
+            continue;
+        const last = spans[spans.length - 1];
+        if (last !== undefined && o <= last[1])
+            last[1] = o + W;
+        else
+            spans.push([o, o + W]);
+    }
+    return spans;
+}
 // ── THE PREFIX SUPPLY ───────────────────────────────────────────────────────
 //
 // A RETRIEVAL capability, not a grounding one: "which trained forms does this

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

@@ -7,6 +7,7 @@ import type { MindConfig } from "../config.js";
 import type { Meter } from "../meter.js";
 import type { GraphSearch, Leaf, Seg, Site } from "./graph-search.js";
 import type { Rationale } from "./rationale.js";
+import type { WindowIndex } from "./evidence.js";
 import type { ContentFold, Grid } from "../geometry.js";
 /** One {@link MindContext._depositTrees} entry — see that field's doc.
  *
@@ -157,7 +158,13 @@ export interface Attention {
      *  a genuine further topic is named in its own distinctive wording
      *  somewhere the query's scaffolding does not reach, always a SEPARATE
      *  cluster from whatever else corroborates it.  See
-     *  test/37-cluster-dispersion-fusion.test.mjs. */
+     *  test/37-cluster-dispersion-fusion.test.mjs.
+     *
+     *  Read from the VOTES, this is a lossy witness: a region votes once, for its
+     *  top anchor, so a place can be lost to a tie or won through an accident.
+     *  Fusion therefore also asks the root's CONTEXT the same question at window
+     *  scale (reasoning.ts `sharedPlaces`) and trusts a root that either reading
+     *  finds in two places. */
     clusters: number;
 }
 /** Both read-outs of one consensus climb. */
@@ -364,6 +371,14 @@ export interface MindContext extends GraphSearchHost {
      *  ordinary respond() and for the first turn of a conversation. */
     currentTurnStart: number;
     _edgeGuide: Vec | null;
+    /** The question currently being answered, as the material `chooseNext`'s
+     *  exact tier witnesses a continuation's establishing contexts against —
+     *  its bytes (canonical when the response's canon preserves offsets) and
+     *  their window index.  Set and cleared with `_edgeGuide`. */
+    _edgeAsked: {
+        bytes: Uint8Array;
+        index: WindowIndex;
+    } | null;
     _edgeChoice: Map<number, number>;
     _prevSeen: Set<number> | null;
     /** Session cache of node-id → perceived gist, for candidate scoring

package/dist/src/store-sqlite.d.ts

@@ -28,6 +28,20 @@ export declare class SQliteStore extends AbstractStore implements Store {
     private _bloom;
     /** Dedup probes answered by the filter alone this session (observability). */
     bloomSkips: number;
+    /** The same negative filter over the CANON index's key hashes.  Recognition's
+     *  canonical admission and the join's canonical entity scan ask `canonFind`
+     *  once per probed span, and almost every answer is "no such key" — on an
+     *  index that is often EMPTY (it is built only by `buildCanonIndex`).
+     *  Loaded on first use from `canon_bloom` when its stamp matches the meta,
+     *  else built by one sequential scan of the h column; kept exact on
+     *  `canonAdd` (rebuilt bigger from the table, uncommitted rows included,
+     *  when growth saturates it) and persisted with the commit that wrote the
+     *  rows.  The canon table is never deleted from, so the filter can never
+     *  hold a false negative: a miss it reports is a miss the query would have
+     *  returned. */
+    private _canonBloom;
+    /** The in-memory canon filter differs from the persisted one. */
+    private _canonBloomDirty;
     private _insertNode;
     private _insertKid;
     private _selContain;
@@ -79,6 +93,9 @@ export declare class SQliteStore extends AbstractStore implements Store {
     protected _dbGetNode(id: NodeId): NodeRec | null;
     protected _dbFindLeaf(h: number, bytes: Uint8Array): NodeId | null;
     protected _dbFindBranchByLeaf(h: number, bytes: Uint8Array): NodeId | null;
+    /** The node filter alone: never a false negative (every inserted hash is
+     *  added before any probe can see it), so `false` is exact. */
+    protected _dbFlatMayExist(h: number, bytes: Uint8Array): boolean;
     protected _dbFindBranchByKids(h: number, packed: Uint8Array): NodeId | null;
     protected _dbInsertKid(child: NodeId, parent: NodeId): void;
     protected _dbGetParents(id: NodeId): NodeId[];
@@ -137,6 +154,14 @@ export declare class SQliteStore extends AbstractStore implements Store {
     protected _dbSetMeta(key: string, val: string): void;
     protected _dbDeleteMeta(key: string): void;
     canonAdd(h: number, id: number): void;
+    /** The canon filter: the persisted one when its stamp matches the meta,
+     *  else built from the index as it stands. */
+    private _canonFilter;
+    private _canonScan;
+    /** What a persisted canon filter is stamped with: the incremental build's
+     *  cursor, which every canon writer advances in the transaction it writes. */
+    private _canonStamp;
+    private _canonBloomPersist;
     canonFind(h: number): number[];
     sketchGet(id: number): number[] | null;
     sketchPut(id: number, ids: readonly number[]): void;