@hviana/sema 0.5.8 → 0.5.9

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://jsr.io/schema/config-file.v1.json",
   "name": "@hviana/sema",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "exports": "./src/index.ts"
 }

package/package.json

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

package/src/geometry.ts

@@ -132,6 +132,29 @@ export function dominates(partLen: number, wholeLen: number): boolean {
  *  recallByResonance trusting a climb anchor, and commitVotes admitting a
  *  further point of attention.  Defined once here so the two can never
  *  drift apart.  Derived from N, never tuned. */
+/** SUPERPOSITION CAPACITY — how many quasi-orthogonal terms one vector can
+ *  carry before an individual term stops being readable.  `√D`.
+ *
+ *  A superposition of m unit signatures has ‖acc‖² ≈ m, so one term's
+ *  contribution to any cosine taken against that vector is ≈ 1/m.  Setting
+ *  that against the representation's own floor {@link estimatorNoise} = 1/√D:
+ *
+ *      1/m < 1/√D   ⟺   m > √D
+ *
+ *  Past √D terms a single shared constituent can no longer move a halo cosine
+ *  above quantisation noise — and because the result is normalized, each extra
+ *  term also shrinks every ALREADY-accepted term toward that floor.  So this is
+ *  not a budget that trades accuracy for time: beyond capacity, more evidence
+ *  makes the representation strictly worse.  It composes with
+ *  {@link significanceBar} (3/√D) as it should — three shared units of √D is
+ *  exactly the significance bar.
+ *
+ *  Consumer: `companyProfile` (mind/learning.ts), which sizes its constituent
+ *  sketch at this capacity instead of a visit budget. */
+export function profileCapacity(D: number): number {
+  return Math.max(1, Math.floor(Math.sqrt(D)));
+}
+
 export function consensusFloor(N: number): number {
   return Math.log(N) + 1 / 2;
 }

package/src/mind/attention.ts

@@ -193,6 +193,12 @@ export interface ConsensusAnchorTrace {
     passesNaturalBreak?: boolean;
     passesConsensusFloor?: boolean;
     pastLeadingSaturation?: boolean;
+    /** Committed because its margin from the dominant is inside the estimator's
+     *  own resolution — the co-dominant band in {@link commitVotes}.  Recorded
+     *  because commit decisions are kept in the exact shape the gates applied
+     *  them: a root admitted this way must never read, in the trace, as one
+     *  that cleared the two vote gates. */
+    tiedWithDominant?: boolean;
     rejectionReasons: AnchorRejectionReason[];
   };
 }
@@ -1703,6 +1709,7 @@ export function commitVotes(
     passesNaturalBreak: boolean | undefined,
     passesConsensusFloor: boolean | undefined,
     pastLeadingSaturation: boolean | undefined,
+    tiedWithDominant: boolean | undefined,
     rejectionReasons: AnchorRejectionReason[],
   ) => {
     if (!td) return;
@@ -1723,6 +1730,7 @@ export function commitVotes(
         passesNaturalBreak,
         passesConsensusFloor,
         pastLeadingSaturation,
+        tiedWithDominant,
         rejectionReasons,
       },
     });
@@ -1738,6 +1746,7 @@ export function commitVotes(
     let passesNaturalBreak: boolean | undefined;
     let passesConsensusFloor: boolean | undefined;
     let pastLeadingSaturation: boolean | undefined;
+    let tiedWithDominant: boolean | undefined;
     const rejectionReasons: AnchorRejectionReason[] = [];
     if (absorbed) {
       status = "overlap";
@@ -1760,7 +1769,49 @@ export function commitVotes(
       } 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 {
           status = "rejected";
@@ -1782,6 +1833,7 @@ export function commitVotes(
           passesNaturalBreak,
           passesConsensusFloor,
           pastLeadingSaturation,
+          tiedWithDominant,
           rejectionReasons,
         );
         continue;
@@ -1795,6 +1847,7 @@ export function commitVotes(
       passesNaturalBreak,
       passesConsensusFloor,
       pastLeadingSaturation,
+      tiedWithDominant,
       rejectionReasons,
     );
     placed.push(point);

package/src/mind/learning.ts

@@ -15,8 +15,9 @@ import {
   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.
@@ -235,14 +236,90 @@ export interface DepositReport {
   continuationId?: number;
 }
 
-/** 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: number): number {
+  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: MindContext, n: number, W: number): boolean {
+  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: MindContext, id: number, k: number): number[] {
+  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: number[];
+  if (kids == null) {
+    out = [];
+  } else {
+    const pool: number[] = [];
+    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<number>();
+    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.
@@ -343,45 +420,62 @@ function companyProfile(ctx: MindContext, id: number): Vec {
   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: number[] = [];
-  const seen = new Set<number>([id]);
-  const descend = (n: number) => {
-    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)) 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 (dominates(len, whole)) {
+      dominating++;
+      continue;
+    }
+    if (ctx.store.parentsFirst(n, bound + 1).length > bound) {
+      hubDropped++;
+      continue;
     }
-    if (composite) continue;
-    if (ctx.store.parentsFirst(n, bound + 1).length > bound) 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);
 }
 

package/src/mind/mechanisms/cast.ts

@@ -358,6 +358,38 @@ export async function counterfactualTransfer(
     }
   }
   const isRoot = (id: number) => 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: Point): boolean =>
+    p.runs.some((r) => r.cs === 0 && usable(r.qs, r.qe));
+  const voiceable = (p: Point): boolean =>
+    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))) {
@@ -540,6 +572,14 @@ export async function counterfactualTransfer(
       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;
       if (r.cs > fillerOf(before.point, before.run).length + quantum) {
@@ -640,7 +680,14 @@ export async function counterfactualTransfer(
   const domNext = ctx.store.nextFirst(dominant.anchor, hubBound(ctx));
   const displaced = domNext
     .every((n) => indexOf(query, read(ctx, n), 0) < 0);
-  if (last !== 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(

package/src/mind/mind.ts

@@ -1011,10 +1011,21 @@ export class Mind implements MindContext {
     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> {
     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 ────────────────────────────────────────────────────

package/src/mind/reasoning.ts

@@ -52,7 +52,6 @@ export async function reason(
   const qId = pre.queryResolved;
   if (qId !== null && ctx.store.prevCount(qId) > 0) return answer;
 
-  const consumed = new Set<number>();
   // 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
@@ -61,10 +60,68 @@ export async function reason(
   // 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: number | null) => {
+
+  // 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<number>();
+  /** `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: number | null,
+    prev?: readonly number[],
+  ) => {
     if (id === null) return;
     consumed.add(id);
-    for (const p of ctx.store.prevFirst(id, bound)) consumed.add(p);
+    for (const p of prev ?? ctx.store.prevFirst(id, bound)) consumed.add(p);
   };
   const consumeAll = (id: number | null) => {
     if (id === null) return;
@@ -99,8 +156,10 @@ export async function reason(
   let t: ReturnType<Rationale["enter"]> | undefined;
   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

package/src/mind/recognition.ts

@@ -15,7 +15,7 @@ import {
   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, type Sema } from "../sema.js";
@@ -594,6 +594,31 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
   // "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: number,
     maxIds: number,
@@ -610,8 +635,9 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
       if (!nx) break;
       ids.push(nx.id);
       pos = nx.end;
-      if (store.findBranch(ids) === null) continue;
-      if (!boundary && atomsAreHubs) continue;
+      const branch = store.findBranch(ids);
+      if (branch === null) continue;
+      if (!boundary && atomsAreHubs && !bearsEdge(ctx, branch)) continue;
       const id = resolveSpan(p, pos);
       if (id === null || id === prevId) continue;
       prevId = id;

package/src/mind/traverse.ts

@@ -461,6 +461,25 @@ export function atomIsHub(ctx: MindContext, contextCount: number): boolean {
   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: MindContext, id: number): boolean {
+  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.