@hviana/sema 0.5.8 → 0.6.0

package/dist/src/mind/attention.js

@@ -1169,7 +1169,7 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
     const floor = consensusFloor(N);
     const placed = [];
     const roots = [];
-    const recordAnchor = (point, rank, status, dominant, passesNaturalBreak, passesConsensusFloor, pastLeadingSaturation, rejectionReasons) => {
+    const recordAnchor = (point, rank, status, dominant, passesNaturalBreak, passesConsensusFloor, pastLeadingSaturation, tiedWithDominant, rejectionReasons) => {
         if (!td)
             return;
         td.anchors.push({
@@ -1189,6 +1189,7 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
                 passesNaturalBreak,
                 passesConsensusFloor,
                 pastLeadingSaturation,
+                tiedWithDominant,
                 rejectionReasons,
             },
         });
@@ -1204,6 +1205,7 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
         let passesNaturalBreak;
         let passesConsensusFloor;
         let pastLeadingSaturation;
+        let tiedWithDominant;
         const rejectionReasons = [];
         if (absorbed) {
             status = "overlap";
@@ -1229,7 +1231,45 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
             else {
                 passesNaturalBreak = vote >= rootCut;
                 passesConsensusFloor = vote >= floor;
-                if (passesNaturalBreak && passesConsensusFloor && pastLeading) {
+                // CO-DOMINANT — an anchor the estimator cannot separate from the
+                // dominant inherits the dominant's exemption, because that exemption's
+                // only warrant is being TOP, and "top" is not a fact about the corpus
+                // when the ordering moves with the seed.
+                //
+                // The dominant bypasses both vote gates ("it always grounds"); the
+                // runner-up is held to an absolute ln(N)+1/2 floor the dominant never
+                // had to clear.  Which of them gets the exemption is then decided by a
+                // sort over ESTIMATED quantities.  Measured on test/29 D1's corpus,
+                // 60 seeds per D — true separation 0.54s / 0.75s / 1.04s:
+                //
+                //     D      s=1/sqrt(D)   vote SD (estimated anchor)  SD/s   flips
+                //     256    0.0625        0.0561                      0.90   19/60
+                //    1024    0.0313        0.0268                      0.86   12/60
+                //    4096    0.0156        0.0074                      0.48    2/60
+                //
+                // The SD tracks 1/sqrt(D) and the flip rate collapses with it, so the
+                // reordering is the ESTIMATOR's, not the corpus's.  The loser was then
+                // refused by a floor at 1.599 that neither anchor could ever reach
+                // (corpusN 3) — a coin flip decided which single structure the query
+                // was allowed to have settled on.
+                //
+                // THE BAND IS sqrt(k)*s, NOT s.  A vote is a SUM over the anchor's own
+                // contributing regions, so its noise grows as sqrt(k); pricing a summed
+                // margin against one s would be the category error chooseNext's comment
+                // warns about.  k is `regionAxioms`, already in hand; s is
+                // `estimatorNoise(D)`, already derived.  No constant is introduced.
+                // Verified conservative: measured SD/(sqrt(k)*s) never exceeded 0.72.
+                //
+                // BOUNDED BY CONSTRUCTION: admission requires indistinguishability from
+                // an anchor ALREADY admitted, so it can only admit what the ordinary
+                // rule would have admitted had the noise fallen the other way.  It is
+                // N-independent for the same reason — a statement about the estimator,
+                // not about corpus size.
+                const tieBand = Math.sqrt(Math.max(1, regionAxioms.get(point.anchor) ?? 1)) * estimatorNoise(ctx.store.D);
+                const dominantVote = votesIdf.get(roots[0].anchor) ?? 0;
+                tiedWithDominant = dominantVote - vote < tieBand;
+                if (((passesNaturalBreak && passesConsensusFloor) || tiedWithDominant) &&
+                    pastLeading) {
                     status = "root";
                 }
                 else {
@@ -1247,11 +1287,11 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
                 roots.push(point);
             }
             else {
-                recordAnchor(point, rank, status, dominant, passesNaturalBreak, passesConsensusFloor, pastLeadingSaturation, rejectionReasons);
+                recordAnchor(point, rank, status, dominant, passesNaturalBreak, passesConsensusFloor, pastLeadingSaturation, tiedWithDominant, rejectionReasons);
                 continue;
             }
         }
-        recordAnchor(point, rank, status, dominant, passesNaturalBreak, passesConsensusFloor, pastLeadingSaturation, rejectionReasons);
+        recordAnchor(point, rank, status, dominant, passesNaturalBreak, passesConsensusFloor, pastLeadingSaturation, tiedWithDominant, rejectionReasons);
         placed.push(point);
     }
     traceAttention(ctx, regions, regionVoter, roots, steps, td, cfg ? { ...cfg, naturalBreak: rootCut, consensusFloor: floor } : undefined, ranked);

package/dist/src/mind/learning.js

@@ -7,8 +7,9 @@ import { bindSeat, companySignature, isChunk } from "../sema.js";
 import { changedNodes } from "./types.js";
 import { inputBytes, perceiveDeposit, resolve, } from "./primitives.js";
 import { canonicalWindows, leafIdPrefix } from "./canonical.js";
+import { rItem, rNode } from "./trace.js";
 import { hubBound } from "./traverse.js";
-import { dominates } from "../geometry.js";
+import { dominates, estimatorNoise, profileCapacity } from "../geometry.js";
 import { fold as foldVecs } from "../sema.js";
 /** Intern a perceived tree into node ids, bottom-up, sharing equal subtrees.
  *  Returns the root node id and a map from tree nodes to their ids.
@@ -191,14 +192,98 @@ async function propagateSuffixes(ctx, src, dst) {
         await ctx.store.link(id, dst);
     }
 }
-/** How many constituents one profile may VISIT.  A partner's constituent tree
- *  is O(len/W) nodes, so an uncapped descent would make a pour cost grow with
- *  the partner's LENGTH — and a partner is a whole deposit, which may be a
- *  paragraph.  The budget is what keeps a pour O(1) in the input, the property
- *  that lets {@link companyProfile} claim no new cost class.  It binds only on
- *  long partners whose constituents are all corpus-unique; the descent's own
- *  stop rule (below) reaches recurring units far sooner on a trained store. */
-const PROFILE_VISITS = 64;
+/** Deterministic priority of a node for bottom-k selection — a fixed integer
+ *  mix of the node id, NOT a function of the config seed.
+ *
+ *  Seed-independence is the point: the sketch is a property of the STORE, so
+ *  two Minds over one store must agree on it, and a rebuilt sketch must match
+ *  a stored one.  (Contrast {@link companySignature}, which is seeded — that is
+ *  the VECTOR, this is only the CHOICE of which vectors to superpose.)
+ *
+ *  Selecting the k smallest priorities makes the sketch a bottom-k sample keyed
+ *  on each constituent's own identity, so a unit shared by two partners is kept
+ *  by BOTH or neither, whatever its depth or position in either fold.  That is
+ *  what removes the traversal-order dependence a visit budget necessarily had. */
+function unitPriority(id) {
+    let h = (id ^ 0x9e3779b9) >>> 0;
+    h = Math.imul(h ^ (h >>> 16), 0x85ebca6b) >>> 0;
+    h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;
+    return (h ^ (h >>> 16)) >>> 0;
+}
+/** Whether `n` is a MINIMAL UNIT: a stored branch, at least one fold window
+ *  wide, no constituent of its own at or above W.  Every clause is INTRINSIC —
+ *  a property of the node's own subtree — which is what lets a sketch be stored
+ *  once and stay valid as the corpus grows.  The two corpus-relative readings
+ *  (half-dominance of the PARTNER, and the hub test) are deliberately excluded
+ *  and applied by {@link companyProfile} at pour time. */
+function isMinimalUnit(ctx, n, W) {
+    if (n < 0)
+        return false; // byte atom — fan-in is the alphabet's
+    const kids = ctx.store.get(n)?.kids;
+    if (kids == null)
+        return false; // stored kid-less node: also an atom
+    if (ctx.store.contentLen(n, W) < W)
+        return false;
+    for (const kid of kids) {
+        if (kid >= 0 && ctx.store.contentLen(kid, W) >= W)
+            return false; // composite
+    }
+    return true;
+}
+/** The BOTTOM-K CONSTITUENT SKETCH of a node: the `k = profileCapacity(D)`
+ *  minimal units of its subtree with the smallest {@link unitPriority}.
+ *
+ *  COMPOSABLE, WHICH IS WHY IT COSTS NOTHING TWICE.  Bottom-k of a union is
+ *  the bottom-k of the children's bottom-k sets, so a node's sketch is built
+ *  from its kids' sketches and each recursive result is stored on the way out.
+ *  A partner met again reads O(k); an accumulated conversation, where turn k's
+ *  context is a prefix of turn k+1's, reuses every unchanged child and pays
+ *  O(changed) instead of O(context) — the quadratic that made a visit budget
+ *  look necessary in the first place.
+ *
+ *  It is DURABLE DERIVED STATE, not a cache (see Store.sketchGet): a miss must
+ *  cost time only, and this decides which terms enter a halo.  A backend
+ *  without the capability recomputes per pour and loses only the amortisation.
+ *
+ *  Recursion depth is the fold's, O(log_W len), and each level does O(k·arity)
+ *  work, so construction is one pass over the subtree — the same pass the
+ *  deposit that interned it already performed. */
+function constituentSketch(ctx, id, k) {
+    const stored = ctx.store.sketchGet?.(id);
+    if (stored != null)
+        return stored; // [] is a real answer; null is "unknown"
+    const W = ctx.space.maxGroup;
+    const kids = id < 0 ? null : ctx.store.get(id)?.kids;
+    let out;
+    if (kids == null) {
+        out = [];
+    }
+    else {
+        const pool = [];
+        for (const kid of kids) {
+            if (isMinimalUnit(ctx, kid, W))
+                pool.push(kid);
+            else if (kid >= 0) {
+                for (const g of constituentSketch(ctx, kid, k))
+                    pool.push(g);
+            }
+        }
+        // Bottom-k by identity, then by id so ties are corpus-determined (§2.1).
+        pool.sort((a, b) => (unitPriority(a) - unitPriority(b)) || (a - b));
+        const seen = new Set();
+        out = [];
+        for (const n of pool) {
+            if (seen.has(n))
+                continue;
+            seen.add(n);
+            out.push(n);
+            if (out.length >= k)
+                break;
+        }
+    }
+    ctx.store.sketchPut?.(id, out);
+    return out;
+}
 /** The COMPANY PROFILE of a partner: its own identity signature superposed
  *  with the signatures of its RECURRING content-defined constituents.
  *
@@ -298,54 +383,53 @@ function companyProfile(ctx, id) {
     const acc = zeros(ctx.space.D);
     addInto(acc, companySignature(ctx.space, id));
     const bound = hubBound(ctx);
-    const W = ctx.space.maxGroup;
+    const k = profileCapacity(ctx.space.D);
     const whole = Math.max(1, ctx.store.contentLen(id));
-    const frontier = [];
-    const seen = new Set([id]);
-    const descend = (n) => {
-        const kids = ctx.store.get(n)?.kids;
-        if (!kids)
-            return;
-        for (const kid of kids)
-            if (!seen.has(kid))
-                frontier.push(kid);
-    };
-    descend(id);
-    for (let visits = 0; visits < PROFILE_VISITS && frontier.length > 0;) {
-        const n = frontier.shift();
-        if (seen.has(n))
-            continue;
-        seen.add(n);
-        visits++;
-        // Atoms in both representations — negative id, or a stored kid-less node.
-        if (n < 0 || ctx.store.get(n)?.kids == null)
-            continue;
-        descend(n);
+    const sketch = constituentSketch(ctx, id, k);
+    // The two CORPUS-RELATIVE readings, applied here and never stored: which
+    // terms count as scaffolding moves as N grows, which is the drift documented
+    // above, while the sketch itself must stay intrinsic to remain valid.
+    let accepted = 0, hubDropped = 0, dominating = 0;
+    for (const n of sketch) {
         const len = ctx.store.contentLen(n, whole);
-        if (len < W || dominates(len, whole))
+        if (dominates(len, whole)) {
+            dominating++;
             continue;
-        // MINIMAL units only: a constituent that still has a constituent of its
-        // own at or above W is a composite, and superposing it as well as its
-        // parts would count the same content twice.  Nested partners — an
-        // accumulated conversation, where turn k's context is a prefix of turn
-        // k+1's — share their large chunks structurally rather than
-        // distributionally, so those composites are exactly the terms that make
-        // adjacent turns read as synonyms (measured: consecutive turns at 0.809
-        // and 0.740 against a 0.516 concept threshold).  The smallest units at or
-        // above the fold's own window are the word-sized types company should be
-        // keyed at.
-        const kids = ctx.store.get(n).kids;
-        let composite = false;
-        for (const kid of kids) {
-            if (kid >= 0 && ctx.store.contentLen(kid, W) >= W)
-                composite = true;
         }
-        if (composite)
-            continue;
-        if (ctx.store.parentsFirst(n, bound + 1).length > bound)
+        if (ctx.store.parentsFirst(n, bound + 1).length > bound) {
+            hubDropped++;
             continue;
+        }
         addInto(acc, companySignature(ctx.space, n));
+        accepted++;
     }
+    // FALSIFIABILITY.  The claim this function makes is that it stops because the
+    // representation is FULL, never because a budget ran out — so the diagnostics
+    // report the capacity, the mass actually reached, and what the frontier still
+    // held.  `residual` is the evidence NOT superposed; `marginal` is what one
+    // more term would have contributed to a downstream cosine (1/mass), and
+    // `saturated` says whether that had fallen to or below `noiseFloor`.  A run
+    // that reports `saturated: false` with `residual > 0` is this design being
+    // WRONG, not tuning: it would mean readable evidence was dropped.
+    const mass = accepted + 1; // the node's own signature counts
+    const marginal = 1 / mass;
+    const noiseFloor = estimatorNoise(ctx.space.D);
+    ctx.trace?.step("companyProfile", [rNode(ctx, id, "partner")], [rItem(new Uint8Array(0), "profile", id)], `superposed ${accepted} of ${sketch.length} sketched constituents ` +
+        `(capacity ${k}); marginal ${marginal.toFixed(4)} vs noise floor ` +
+        `${noiseFloor.toFixed(4)}`, undefined, {
+        capacity: k,
+        sketched: sketch.length,
+        accepted,
+        hubDropped,
+        dominating,
+        residual: sketch.length - accepted,
+        mass,
+        marginal,
+        noiseFloor,
+        saturated: sketch.length >= k,
+        stopReason: sketch.length >= k ? "capacity" : "constituents-exhausted",
+        wholeLen: whole,
+    });
     return normalize(acc);
 }
 /** Ingest a pair (context, continuation) — learn an edge and pour halos.

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

@@ -301,6 +301,36 @@ export async function counterfactualTransfer(ctx, query, pre) {
         }
     }
     const isRoot = (id) => roots.some((r) => r.anchor === id);
+    // VOICEABLE — a structure whose own learnt content a schema may SPEAK.
+    //
+    // The gate below asks only that the weave TOUCH a committed point.  That is
+    // the right question for MEMBERSHIP — a weave needs uncommitted structure to
+    // compare against; that is what an analogy IS — and the wrong one for
+    // VOICING: satisfied by any committed bystander, it lets every OTHER aligned
+    // point put its own learnt content into the answer while a root that
+    // contributed nothing holds the door open.  The refusal note below already
+    // states the principle — "CAST refuses to transfer through content the climb
+    // itself never settled on" — it was simply never asked of the structure a
+    // schema actually transfers THROUGH.
+    //
+    // Measured on a two-hop question over dialogue filler (N ~ 103,
+    // consensusFloor 5.13): the climb committed ONE root at vote 8.13, and
+    // substitution then voiced a filler deposit at vote 0.15 together with a
+    // second structure at 0.57 — neither committed, both an order of magnitude
+    // below the floor, while the licensing root supplied no bytes at all.
+    //
+    // OR THE QUERY NAMED IT.  Commitment is not the only warrant: a structure the
+    // asker QUOTED is content the query did ask about, whoever the climb settled
+    // on.  The naming test is the one redirection's own `named` list uses — an
+    // aligned run starting at the structure's OPENING bytes (`cs === 0`) — and
+    // NOT merely "has an aligned run", which every weave point has by
+    // construction.  Without this disjunct the gate refuses test/29 B3 ("what if
+    // the capital of France were Lyon?" must answer about Lyon), where the
+    // substitute is named outright and the climb never commits it.  This mirrors
+    // the pairing the comparison gate already makes with
+    // `!rootTrusted && !namedByQuery`.
+    const namedFromOpening = (p) => p.runs.some((r) => r.cs === 0 && usable(r.qs, r.qe));
+    const voiceable = (p) => isRoot(p.anchor) || namedFromOpening(p);
     // The weave must touch a COMMITTED point of attention: the dominant
     // structure itself, or another aligned point the climb committed to.
     if (!points.some((p) => isRoot(p.anchor))) {
@@ -450,6 +480,15 @@ export async function counterfactualTransfer(ctx, query, pre) {
         if (r.cs < quantum || !usable(r.qs, r.qe)) {
             return null;
         }
+        // The DISPLACED STRUCTURE is what this schema speaks — the answer is its
+        // tail past the seat plus its own continuation — so it must be
+        // voiceable.  Filtered HERE rather than after the argmax so an eligible
+        // structure with less depth still fires the schema, instead of an
+        // ineligible deepest candidate suppressing it outright.  The SUBJECT is
+        // deliberately not gated: `fillerOf` reads the QUERY's own bytes for it,
+        // so it contributes what the asker already said, not learnt content.
+        if (!voiceable(p))
+            return null;
         const before = beforeOf(p, r);
         if (before === undefined)
             return null;
@@ -534,7 +573,12 @@ export async function counterfactualTransfer(ctx, query, pre) {
     const domNext = ctx.store.nextFirst(dominant.anchor, hubBound(ctx));
     const displaced = domNext
         .every((n) => indexOf(query, read(ctx, n), 0) < 0);
-    if (last !== undefined && last.point !== dominant && displaced) {
+    // The SUBSTITUTE is what redirection speaks — the answer IS `project(last)`,
+    // its own fact — so the same bar applies.  The displaced structure is only
+    // recognised as the slot being overridden and is never voiced, so it is
+    // deliberately not gated here.
+    if (last !== undefined && last.point !== dominant && displaced &&
+        voiceable(last.point)) {
         const g = await project(ctx, last.point.anchor, qv);
         if (g !== null) {
             ctx.trace?.step("projectCounterfactual", [

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

@@ -282,7 +282,7 @@ export declare class Mind implements MindContext {
      *     "what byte separates two turns?" because nothing downstream finds
      *     boundaries by looking at content at all.
      *  2. A separator in a CORPUS is ordinary content.  If a trainer joins
-     *     turns with "\n" (example/train_base.ts does), those newlines are
+     *     turns with "\n" (example/train_base does), those newlines are
      *     simply bytes inside the stream, folded like every other byte.  They
      *     are a property of that corpus, not of this API and not of the fold.
      *  3. This API can therefore reproduce ANY corpus exactly, with no
@@ -345,7 +345,12 @@ export declare class Mind implements MindContext {
     /** See {@link import("./learning.js").ingest} — `onDeposit`, when given,
      *  reports each ingested item's deposited root node ids
      *  ({@link DepositReport}); purely observational. */
-    ingest(input: Input | (Input | [Input, Input])[], second?: Input, onDeposit?: (report: import("./learning.js").DepositReport) => void): Promise<(Sema & {
+    ingest(input: Input | (Input | [Input, Input])[], second?: Input, onDeposit?: (report: import("./learning.js").DepositReport) => void, 
+    /** Witness the DEPOSIT path the way {@link respond}'s callback witnesses
+     *  inference — `companyProfile` reports its saturation diagnostics here.
+     *  Without it the tracer is never constructed and the emit sites cost
+     *  nothing (§ rationale.ts), exactly as on the inference path. */
+    inspectRationale?: InspectRationale): Promise<(Sema & {
         id: number;
     }) | undefined>;
     private extensionHost;

package/dist/src/mind/mind.js

@@ -479,7 +479,7 @@ export class Mind {
      *     "what byte separates two turns?" because nothing downstream finds
      *     boundaries by looking at content at all.
      *  2. A separator in a CORPUS is ordinary content.  If a trainer joins
-     *     turns with "\n" (example/train_base.ts does), those newlines are
+     *     turns with "\n" (example/train_base does), those newlines are
      *     simply bytes inside the stream, folded like every other byte.  They
      *     are a property of that corpus, not of this API and not of the fold.
      *  3. This API can therefore reproduce ANY corpus exactly, with no
@@ -644,10 +644,22 @@ export class Mind {
     /** See {@link import("./learning.js").ingest} — `onDeposit`, when given,
      *  reports each ingested item's deposited root node ids
      *  ({@link DepositReport}); purely observational. */
-    async ingest(input, second, onDeposit) {
+    async ingest(input, second, onDeposit, 
+    /** Witness the DEPOSIT path the way {@link respond}'s callback witnesses
+     *  inference — `companyProfile` reports its saturation diagnostics here.
+     *  Without it the tracer is never constructed and the emit sites cost
+     *  nothing (§ rationale.ts), exactly as on the inference path. */
+    inspectRationale) {
         invalidateStructuralCaches(this);
         invalidateJunctionCache(this);
-        return ingest(this, input, second, onDeposit);
+        const prevTrace = this.trace;
+        this.trace = inspectRationale ? new Rationale(inspectRationale) : null;
+        try {
+            return await ingest(this, input, second, onDeposit);
+        }
+        finally {
+            this.trace = prevTrace;
+        }
     }
     // ── Extension Surface ────────────────────────────────────────────────────
     extensionHost() {

package/dist/src/mind/reasoning.js

@@ -39,7 +39,6 @@ export async function reason(ctx, query, answer, preConsumed, pre, voiced = [])
     const qId = pre.queryResolved;
     if (qId !== null && ctx.store.prevCount(qId) > 0)
         return answer;
-    const consumed = new Set();
     // Consume a node and its neighbours for pivot-cycle prevention — CAPPED at
     // the hub bound, via the store's LIMITed edge reads: a common continuation's
     // reverse fan-in (and a hub context's forward fan-out) is corpus-sized, and
@@ -48,11 +47,64 @@ export async function reason(ctx, query, answer, preConsumed, pre, voiced = [])
     // read order); a pivot suppressed only by a beyond-cap neighbour may now
     // fire — the same visibility trade chooseNext documents.
     const bound = hubBound(ctx);
-    const consumeNode = (id) => {
+    // ANSWERED DIRECTLY — the echo guard's other half, and the same principle:
+    // the QUERY's own position in the graph, not the answer's content, says the
+    // read-out is complete.  Above: the query is itself a learnt CONTINUATION.
+    // Here: the query is a learnt CONTEXT and the grounded answer is one of ITS
+    // OWN continuations.  Either way the question was answered directly and there
+    // is nothing left to chain for.
+    //
+    // Every stopping condition in the loop below judges the ANSWER (`consumed` /
+    // `restatesQuery` / `bytesEqual`); none asks whether the QUESTION was
+    // satisfied.  So a single-hop question whose answer happens to name another
+    // learnt context extends past a correct answer and REPLACES it:
+    //
+    //   asked  "<subj> father"
+    //   hop 1  "The father of <subj> is Ernest I of Anhalt-Dessau."   <- correct
+    //   pivot  "Ernest I of Anhalt-Dessau"                <- a learnt context too
+    //   got    "The date of death of Ernest I of Anhalt-Dessau is 12 June 1516."
+    //
+    // Any store holding a bare-entity context alongside a relation fact has that
+    // shape; it is not exotic.
+    //
+    // Checked ONCE, before the loop, and ahead of BOTH extension branches:
+    // `absorbForward` extends the answer too, and nothing about the defect is
+    // specific to pivoting, so a guard between them would gate one arbitrary half
+    // of the same step.  Hop 0 is also the only hop at which the question can be
+    // answered directly at all — after a hop, `cur` is no longer the query's own
+    // continuation, so re-testing per hop could only cost reads.
+    //
+    // Read from the ANSWER's side (`prevFirst`) rather than the query's
+    // (`nextFirst`).  Same relation, but a CONTEXT's fan-out is hub-sized while
+    // this is one answer's establishing-context fan-in.  Both the resolve and the
+    // reverse read are exactly what hop 0 of the loop below would perform, so
+    // they are computed ONCE here and handed down (`groundedId`, `groundedPrev`)
+    // — the guard then costs nothing when it does not fire.  Stated because the
+    // naive placement does NOT: `resolve` re-folds the answer bytes on every call
+    // (no memo) and `prevFirst` is a direct read (no memo), so a guard that
+    // recomputed them would add one fold plus one √N-bounded read per ask.
+    // The √N cap carries the file-wide visibility trade, and fails SAFE in the
+    // direction that matters: a missed guard costs an over-extended answer, never
+    // a suppressed chain.
+    //
+    // A genuine multi-hop query is not a deposited context at all ("What is the
+    // capital of the country of Eiffel Tower?" resolves to nothing), so this can
+    // never gate a real chain.
+    const groundedId = resolve(ctx, answer);
+    const groundedPrev = groundedId === null
+        ? null
+        : ctx.store.prevFirst(groundedId, bound);
+    if (qId !== null && groundedPrev !== null && groundedPrev.includes(qId)) {
+        return answer;
+    }
+    const consumed = new Set();
+    /** `prev` lets a caller hand in an already-read reverse-edge list — hop 0
+     *  reuses the guard's, above, instead of re-reading it. */
+    const consumeNode = (id, prev) => {
         if (id === null)
             return;
         consumed.add(id);
-        for (const p of ctx.store.prevFirst(id, bound))
+        for (const p of prev ?? ctx.store.prevFirst(id, bound))
             consumed.add(p);
     };
     const consumeAll = (id) => {
@@ -92,8 +144,10 @@ export async function reason(ctx, query, answer, preConsumed, pre, voiced = [])
     let t;
     const startedFrom = answer;
     for (let hop = 0; hop < ctx.cfg.recallQueryK; hop++) {
-        const curId = resolve(ctx, cur);
-        consumeNode(curId);
+        // Hop 0's `cur` IS `answer`, so the guard above already resolved it and
+        // read its reverse edges — reuse both rather than repeat them.
+        const curId = hop === 0 ? groundedId : resolve(ctx, cur);
+        consumeNode(curId, hop === 0 ? groundedPrev ?? undefined : undefined);
         // Forward-absorb: follow only UNCONSUMED continuations.  The gate below
         // checks an unconsumed edge EXISTS, but follow()'s chooseNext knows
         // nothing of `consumed` and may still walk to a consumed fixpoint —

package/dist/src/mind/recognition.js

@@ -6,7 +6,7 @@
 //   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 { atomIsHub, corpusN, leadsSomewhere } from "./traverse.js";
+import { atomIsHub, bearsEdge, corpusN, leadsSomewhere } from "./traverse.js";
 import { chainReach, leafIdAt, leafIdRun } from "./canonical.js";
 import { canonHash } from "../canon.js";
 import { isChunk } from "../sema.js";
@@ -585,6 +585,31 @@ function recogniseImpl(ctx, bytes) {
     // "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.
+    //
+    // THE REPLACEMENT SIGNAL (2026-08-13): `leadsSomewhere` on the BYTE-EXACT
+    // branch the chain already found.  The blanket off-boundary suppression is
+    // a decision that CHANGES WITH CORPUS SIZE — `atomsAreHubs` flips at
+    // N = 4096 (atomReach = ⌈N·W/256⌉ exceeds √N there) — so a store crossing
+    // that point silently loses interior sites it used to have.  Measured: with
+    // the two-hop chain deposited, `recognise("The country of Eiffel Tower is
+    // France.")` yields 4 sites including `France` at N = 3920 and 2 sites
+    // without it at N = 4227; the pivot dies with the site and multi-hop goes
+    // silent from there up (the trained store is N = 325,615).
+    //
+    // The honest gate is the one `emit` already applies, moved EARLIER and paid
+    // for with existence probes instead of a fold: `findBranch` has already
+    // proved these bytes are a stored branch, so the only remaining question is
+    // whether that branch is a deposited whole (bears an edge or a halo) or an
+    // interned fragment.  "hi" out of "W[hi]ch" leads nowhere and is still
+    // suppressed; `France` bears both and is admitted.  Structural, not scalar
+    // — no constant enters and nothing reads N, so the verdict no longer moves
+    // when the corpus grows.
+    //
+    // COST: `bearsEdge` is the response-MEMOISED edge probe, not the full
+    // `leadsSomewhere` — its uncached `hasHalo` tier took haloProbes from 922 to
+    // 9,144 on a nine-query battery over the trained store, which is not a price
+    // this pass may charge.  `emit` still applies the full predicate, so this is
+    // a pre-filter that never widens what is admitted.
     const tryChain = (p, maxIds, boundary) => {
         const first = leafFrom(p);
         if (!first)
@@ -599,9 +624,10 @@ function recogniseImpl(ctx, bytes) {
                 break;
             ids.push(nx.id);
             pos = nx.end;
-            if (store.findBranch(ids) === null)
+            const branch = store.findBranch(ids);
+            if (branch === null)
                 continue;
-            if (!boundary && atomsAreHubs)
+            if (!boundary && atomsAreHubs && !bearsEdge(ctx, branch))
                 continue;
             const id = resolveSpan(p, pos);
             if (id === null || id === prevId)

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

@@ -42,6 +42,22 @@ export declare function atomReach(ctx: MindContext, contextCount: number): numbe
  *  atom votes and is recognised exactly as any stored form; above it the
  *  alphabet is scaffolding everywhere and abstains. */
 export declare function atomIsHub(ctx: MindContext, contextCount: number): boolean;
+/** Cached "does this node bear a continuation edge?" — the CHEAP half of
+ *  {@link leadsSomewhere}, exported for hot paths that must PRE-FILTER a
+ *  candidate before paying for a fold and cannot afford the halo tier.
+ *
+ *  `leadsSomewhere`'s second tier (`hasHalo`) is deliberately uncached — one
+ *  indexed point probe per candidate, which is right where candidates are
+ *  already few.  On recognition's off-boundary chain pass they are not few:
+ *  using the full predicate there took haloProbes from 922 to 9,144 on a
+ *  nine-query battery over the trained store.  The edge tier alone is memoised
+ *  for the response, so it is ~free, and a node bearing an edge is exactly the
+ *  "deposited whole, not an interned fragment" claim that pass needs.
+ *
+ *  Strictly NARROWER than `leadsSomewhere` — a halo-only node reads false — so
+ *  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 (HOW_IT_WORKS
  *  §15.3): a form that leads nowhere contributes nothing to any derivation.

package/dist/src/mind/traverse.js

@@ -407,6 +407,24 @@ export function atomReach(ctx, contextCount) {
 export function atomIsHub(ctx, contextCount) {
     return atomReach(ctx, contextCount) > boundFor(contextCount);
 }
+/** Cached "does this node bear a continuation edge?" — the CHEAP half of
+ *  {@link leadsSomewhere}, exported for hot paths that must PRE-FILTER a
+ *  candidate before paying for a fold and cannot afford the halo tier.
+ *
+ *  `leadsSomewhere`'s second tier (`hasHalo`) is deliberately uncached — one
+ *  indexed point probe per candidate, which is right where candidates are
+ *  already few.  On recognition's off-boundary chain pass they are not few:
+ *  using the full predicate there took haloProbes from 922 to 9,144 on a
+ *  nine-query battery over the trained store.  The edge tier alone is memoised
+ *  for the response, so it is ~free, and a node bearing an edge is exactly the
+ *  "deposited whole, not an interned fragment" claim that pass needs.
+ *
+ *  Strictly NARROWER than `leadsSomewhere` — a halo-only node reads false — so
+ *  it is sound as a pre-filter before a consumer that applies the full
+ *  predicate, and never as a replacement for it. */
+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 (HOW_IT_WORKS
  *  §15.3): a form that leads nowhere contributes nothing to any derivation.

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

@@ -46,6 +46,8 @@ export declare class SQliteStore extends AbstractStore implements Store {
     private _insCanon;
     private _selCanon;
     private _cntCanon;
+    private _insSketch;
+    private _selSketch;
     private _selContentFrom;
     private _delMeta;
     private _insSnapshot;
@@ -136,6 +138,8 @@ export declare class SQliteStore extends AbstractStore implements Store {
     protected _dbDeleteMeta(key: string): void;
     canonAdd(h: number, id: number): void;
     canonFind(h: number): number[];
+    sketchGet(id: number): number[] | null;
+    sketchPut(id: number, ids: readonly number[]): void;
     canonCount(): number;
     eachContent(cb: (id: number, bytes: Uint8Array) => void, fromId?: number): void;
     protected _dbSaveSnapshot(bytes: Uint8Array): void;