@hviana/sema 0.8.2 → 0.8.5

package/src/mind/reasoning.ts

@@ -8,29 +8,31 @@ import { bytesEqual, indexOf } from "../bytes.js";
 import type { Attention, MindContext } from "./types.js";
 import { resolve } from "./primitives.js";
 import { corpusN, hubBound } from "./traverse.js";
-import { follow, haloSiblings, project } from "./match.js";
+import { containsSpan, follow, haloSiblings, project } from "./match.js";
 import { joinWithBridge, pivotInto } from "./resonance.js";
+import { admissible, advance, type Continuation } from "./derivation.js";
 import type { Precomputed } from "./pipeline-mechanism.js";
-import type { Rationale } from "./rationale.js";
-
-/** Whether `bytes` is a proper byte-subspan of `query` — already present in
- *  the question, so voicing it back only restates part of what was asked,
- *  never answers it.  The exact guard recallByResonance already applies to
- *  its OWN grounding candidates (tier 1's `restates`, tier 2's subspan
- *  check, tier 0b's argument-binding subspan check) — every mechanism that
- *  walks a LEARNT CONTINUATION EDGE past an already-vetted grounding
- *  (reason()'s own hops below, and CAST's `projectCounterfactual` seat
- *  substitution — see cast.ts) needs the same guard applied to what the
- *  walk turns up, since `follow()`/`chooseNext`/`pivotInto` know nothing of
- *  the query at all — only of what structurally continues what. */
-export function restatesQuery(query: Uint8Array, bytes: Uint8Array): boolean {
-  return bytes.length < query.length && indexOf(query, bytes, 0) >= 0;
-}
+import { type Rationale } from "./rationale.js";
+import {
+  closure,
+  type DerivationState,
+  type Offer,
+  restates,
+  type Span,
+  unaccountedBytes,
+} from "./derivation.js";
+import { STEP } from "./graph-search.js";
 
 /** Extend a grounded answer forward across facts (multi-hop reasoning).
  *  Pivots on the longest unconsumed learnt context each answer contains,
- *  then follows the pivot's continuation to the next fact.  Repeats up
- *  to `cfg.recallQueryK` hops.  `preConsumed` carries node ids already
+ *  then follows the pivot's continuation to the next fact.  **The chain ends
+ *  when it STOPS, never when a count runs out**: every exit is a refusal (no
+ *  pivot, no forward step, no question material carried) and the walk is bounded
+ *  by the material and the graph — `consumed` refuses to revisit a node.  There
+ *  is no hop allowance, so this doc deliberately names no `cfg` capacity: the
+ *  cover prices every hop at `STEP` and lets the search decide the depth, and a
+ *  second count here would be a second decision about the same thing.
+ *  `preConsumed` carries node ids already
  *  spoken for by the grounding stage (cover/extract/CAST).  `voiced` carries
  *  the BYTES of the anchors a mechanism declared it voiced (its `used` set),
  *  when it declared one — see the pivot's own containment rule.  `pre` is the
@@ -39,22 +41,25 @@ export function restatesQuery(query: Uint8Array, bytes: Uint8Array): boolean {
 export async function reason(
   ctx: MindContext,
   query: Uint8Array,
-  answer: Uint8Array,
+  d0: DerivationState,
   preConsumed: ReadonlySet<number>,
   pre: Precomputed,
   voiced: readonly Uint8Array[] = [],
-  /** The query material the GROUNDING left uncovered — the cost ladder's own
-   *  `unaccounted` spans.  Only the reasoner's OWN extensions are judged
-   *  against it; a mechanism carrying its own `used` set owns its shape. */
-  uncovered: readonly (readonly [number, number])[] = [],
-): Promise<Uint8Array> {
+): Promise<DerivationState> {
+  const answer = d0.product;
+  /** The query material the GROUNDING left uncovered — the state's own
+   *  remainder.  Only the reasoner's OWN extensions are judged against it; a
+   *  mechanism carrying its own `used` set owns its shape. */
+  const uncovered = d0.remainder;
   // Echo guard: a query that is ITSELF a learnt continuation (some context's
   // answer) is being asked back at the system — hopping forward from it would
   // chain through the very fact that produced it and echo the conversation
   // back.  The grounded answer alone is the honest read-out.  Deliberately a
   // broad structural gate; pinned by test/31-audit.
   const qId = pre.queryResolved;
-  if (qId !== null && ctx.store.prevCount(qId) > 0) return answer;
+  if (qId !== null && ctx.store.prevCount(qId) > 0) {
+    return d0;
+  }
 
   // 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
@@ -73,7 +78,7 @@ export async function reason(
   // 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
+  // the law's `restates` / `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:
   //
@@ -113,7 +118,7 @@ export async function reason(
     ? null
     : ctx.store.prevFirst(groundedId, bound);
   if (qId !== null && groundedPrev !== null && groundedPrev.includes(qId)) {
-    return answer;
+    return d0;
   }
 
   const consumed = new Set<number>();
@@ -155,21 +160,66 @@ export async function reason(
     await preconsume();
   }
 
-  let cur = answer;
+  // ── THE WALK, AS THE LAW'S ───────────────────────────────────────────
+  //
+  // This function no longer decides whether a step may be taken: it OFFERS a
+  // continuation — a forward step from the answer's own learnt edge, or a pivot
+  // on a learnt context the answer contains — and `derivation.ts`'s law admits
+  // or refuses it.  The state it offers against is the pipeline's own: the
+  // grounding's remainder (what the question still owes), its accounting, its
+  // cost.
+  //
+  // NO ALLOWANCE: THE CHAIN ENDS WHEN IT STOPS.  Every exit below is the law —
+  // no pivot, no forward step, no question material carried — and the walk is
+  // bounded by the material and the graph rather than by a count: the law
+  // requires each step to engage what is left (or to move to new structure),
+  // and `consumed` refuses to revisit a node.  `recallQueryK` no longer bounds
+  // the reasoner here; it keeps its other roles (the bridge's candidate reads,
+  // the pivot's probe budget, the resonance limits).
+  //
+  // Measured before removing the allowance: test/89 — the corpus-cost guard, the
+  // heaviest case in the suite — is green and no slower without it (27 s against
+  // 30 s); and raising it from 12 to 200 changed neither the answer nor
+  // `pivotSteps` on the chain fixtures.
   const qv = pre.guide; // the response-wide guide IS the query's gist
-  let t: ReturnType<Rationale["enter"]> | undefined;
+  const W = ctx.space.maxGroup;
+  // WHOSE EXTENSION IS THIS?  `voiced` is what the mechanism WITHHELD (the
+  // pipeline sends the used anchors' CONTINUATIONS, not their bytes), so a
+  // non-empty `voiced` means exactly what that note says: the grounding came
+  // from a mechanism that carries its own short `used` set (cast/join) and
+  // therefore OWNS the shape of its answer.  The further terms inside such a
+  // seat are legitimately followable (test/29 C3's `Mona Lisa` lives inside the
+  // voiced seat and leads on to a fact about neither analog), which the law
+  // expresses as the identity species of progress — `moves` — declared by the
+  // reporter and never inferred from the mechanism's name.
+  const producerOwnsShape = voiced.length > 0;
   const startedFrom = answer;
-  for (let hop = 0; hop < ctx.cfg.recallQueryK; hop++) {
-    // Hop 0's `cur` IS `answer`, so the guard above already resolved it and
-    // read its reverse edges — reuse both rather than repeat them.
+  let hop = 0;
+  let t: ReturnType<Rationale["enter"]> | undefined;
+  // WHAT THE OFFERED STEP WOULD BE.  The law decides, so the accepted step is
+  // traced where the decision went (`onTaken`) and a refused one is reported as
+  // the law's refusal (`onRefused`) — a step is never reported before it is
+  // admitted.
+  let pending:
+    | { kind: "absorb"; cur: Uint8Array; curId: number | null; fwd: Uint8Array }
+    | { kind: "pivot"; cur: Uint8Array; pivot: number; fc: Uint8Array }
+    | null = null;
+
+  const offer: Offer = async (d) => {
+    const cur = d.product;
+    // The first step's `cur` IS the grounding's product, so the guard above
+    // already resolved it and read its reverse edges — reuse both.
     const curId = hop === 0 ? groundedId : resolve(ctx, cur);
     consumeNode(curId, hop === 0 ? groundedPrev ?? undefined : undefined);
+    hop++;
 
     // 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 —
-    // absorbing it would repeat content the grounding stage already spoke
-    // for, so a consumed fixpoint falls through to the pivot step instead.
+    // checks an unconsumed edge EXISTS, but follow()'s chooseNext knows nothing
+    // of `consumed` and may still walk to a consumed fixpoint — absorbing it
+    // would repeat content the grounding stage already spoke for, so a consumed
+    // fixpoint falls through to the pivot step instead.  Offered with `moves`:
+    // completing the answer's OWN learnt form is an identity step, not a claim
+    // about the asker's material.
     if (
       curId !== null &&
       ctx.store.nextFirst(curId, bound).some((n) => !consumed.has(n))
@@ -179,96 +229,122 @@ export async function reason(
       if (
         fwd !== null && !bytesEqual(fwd, cur) &&
         (fwdId === null || !consumed.has(fwdId)) &&
-        !restatesQuery(query, fwd)
+        !restates(query, fwd, 0, { proper: true })
       ) {
         consumeAll(curId);
-        t ??= ctx.trace?.enter("reason", [
-          rItem(startedFrom, "grounded"),
-        ]);
-        ctx.trace?.step(
-          "absorbForward",
-          [rItem(cur, "answer", curId)],
-          [rItem(fwd, "answer", resolve(ctx, fwd) ?? undefined)],
-          "the answer is itself a learnt fact — follow its continuation to the fixpoint",
-        );
-        cur = fwd;
-        continue;
+        pending = { kind: "absorb", cur, curId, fwd };
+        return { product: fwd, contains: true, reaches: true, cost: STEP };
       }
     }
 
-    // Pivot: find the longest unconsumed learnt context the answer contains.
+    // Pivot: the longest unconsumed learnt context the answer contains.
     consumeAll(curId);
     const pivot = await pivotInto(ctx, cur, consumed, voiced);
-    if (pivot === null) break;
-
+    if (pivot === null) return null;
     const fc = await follow(ctx, pivot, qv);
     consumeAll(pivot);
-    if (fc === null || bytesEqual(fc, cur) || restatesQuery(query, fc)) break;
-    // WHOSE EXTENSION IS THIS?
-    //
-    // `voiced` is what the mechanism WITHHELD (the pipeline sends the used
-    // anchors' CONTINUATIONS, not their bytes — see pipeline's own note), so a
-    // non-empty `voiced` means exactly what that note says: the grounding came
-    // from a mechanism that carries its own short `used` set (cast/join) and
-    // therefore owns the shape of its answer.  The further terms inside such a
-    // seat are legitimately followable — test/29 C3's `Mona Lisa` lives inside
-    // the voiced seat and leads on to a fact about neither analog.
-    //
-    // Every other grounding is ordinary, and an extension of it is the
-    // reasoner's own inference: it is taken only while question material the
-    // grounding left uncovered remains AND the step carries some of it, judged
-    // by the mind's own line between chance and evidence — one W-byte window,
-    // no word notion, no character class, no threshold.  Measured: the drift's
-    // second step (`the Eiffel Tower is in Paris` after `Paris is famous for
-    // the Eiffel Tower`) carries no window of `" famous for"` and is refused,
-    // while the first carries it.  Terminates by a real argument: the uncovered
-    // material is finite and each taken extension must carry some of it.
-    const producerOwnsShape = voiced.length > 0;
-    if (!producerOwnsShape && uncovered.length > 0) {
-      const W = ctx.space.maxGroup;
-      let progress = false;
-      for (const [a, b] of uncovered) {
-        for (let i = a; i + W <= b && !progress; i++) {
-          if (indexOf(fc, query.subarray(i, i + W), 0) >= 0) progress = true;
-        }
-        if (progress) break;
+    if (
+      fc === null || bytesEqual(fc, cur) ||
+      restates(query, fc, 0, { proper: true })
+    ) {
+      return null;
+    }
+    pending = { kind: "pivot", cur, pivot, fc };
+    // Offered with the identity species ONLY when the grounding declared what it
+    // speaks for; otherwise the law requires this step to carry question
+    // material the grounding left unaccounted, which is the drift the extension
+    // tests pin — refused by the law's own measure, not by a private window
+    // test.
+    return {
+      product: fc,
+      contains: true,
+      reaches: producerOwnsShape,
+      cost: STEP,
+    };
+  };
+
+  const closed_ = await closure(
+    d0,
+    query,
+    W,
+    offer,
+    (before, after) => {
+      if (ctx.meter) {
+        ctx.meter.closureDrainedBytes += unaccountedBytes(before.remainder) -
+          unaccountedBytes(after.remainder);
       }
-      if (!progress) {
-        // THE BRAKE, MADE VISIBLE.  The reasoner declines a step that carries
-        // none of the material the grounding left uncovered — the drift the
-        // extension tests pin.  A refusal that leaves no trace is the kind of
-        // silent cut AGENTS §6 forbids: the rationale is where a reader learns
-        // that an extension was declined for want of question material, and
-        // where the next person sees why the chain stopped here.  Measured with
-        // the check disabled, test/110 and test/116 fail — so this brake is the
-        // only thing keeping the extension honest until the pivot reports its
-        // own accounted spans and the ladder can judge it instead.
-        const left = uncovered.reduce((n, [a, b]) => n + (b - a), 0);
+      const p = pending;
+      pending = null;
+      if (p === null) return;
+      t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
+      if (p.kind === "absorb") {
         ctx.trace?.step(
-          "pivotRefused",
-          [rItem(cur, "answer"), rItem(query, "query")],
-          uncovered.map(([a, b]) => rItem(query.subarray(a, b), "uncovered")),
-          `the step carries none of the question material the grounding left ` +
-            `uncovered (${left} byte(s) in ${uncovered.length} span(s)) — refused`,
+          "absorbForward",
+          [rItem(p.cur, "answer", p.curId ?? undefined)],
+          [rItem(p.fwd, "answer", resolve(ctx, p.fwd) ?? undefined)],
+          "the answer is itself a learnt fact — follow its continuation to the fixpoint",
+        );
+      } else {
+        if (ctx.meter) ctx.meter.pivotSteps++;
+        ctx.trace?.step(
+          "pivotStep",
+          [rItem(p.cur, "answer"), rNode(ctx, p.pivot, "pivot")],
+          [rItem(p.fc, "answer", resolve(ctx, p.fc) ?? undefined)],
+          "pivot on the shared span this answer contains, then step forward across that fact",
         );
-        break;
       }
-    }
-    if (ctx.meter) ctx.meter.pivotSteps++;
-    t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
-    ctx.trace?.step(
-      "pivotStep",
-      [rItem(cur, "answer"), rNode(ctx, pivot, "pivot")],
-      [rItem(fc, "answer", resolve(ctx, fc) ?? undefined)],
-      "pivot on the shared span this answer contains, then step forward across that fact",
+    },
+    (at) => {
+      const p = pending;
+      pending = null;
+      if (p === null || p.kind !== "pivot") return;
+      // THE BRAKE, MADE VISIBLE — and it is now the LAW's refusal, reported
+      // where it happened.  The reasoner declines a step that carries none of
+      // the material the grounding left unaccounted.  A refusal that leaves no
+      // trace is the kind of silent cut AGENTS §6 forbids: the rationale is
+      // where a reader learns that an extension was declined for want of
+      // question material, and where the next person sees why the chain stopped
+      // here.  Measured with the check disabled, test/110 and test/116 fail.
+      const left = unaccountedBytes(at.remainder);
+      ctx.trace?.step(
+        "pivotRefused",
+        [rItem(p.cur, "answer"), rItem(query, "query")],
+        at.remainder.map(([a, b]) => rItem(query.subarray(a, b), "uncovered")),
+        `the step carries none of the question material the grounding left ` +
+          `unaccounted (${left} byte(s) in ${at.remainder.length} span(s)) — refused`,
+      );
+    },
+  );
+
+  // INSTRUMENTATION ONLY — the extension's two facts, untraced (meter.ts
+  // contract 1: a counter never reaches a decision).  They are what a caller
+  // needs to PRICE the extension instead of taking it unconditionally, and both
+  // are now read off the state the law advanced rather than accumulated beside
+  // it: the work it did is the cost it accumulated, and the material it carried
+  // is the accounting the law's witnesses added.
+  const steps = closed_.cost - d0.cost;
+  if (ctx.meter) {
+    ctx.meter.reasonSteps += steps;
+    // The accounting the law's witnesses added, summed by the law's own function
+    // over the tail of the state's list — and computed ONLY when a meter is
+    // attached: this used to slice and MAP a fresh array on every response, for a
+    // counter that usually does not exist.  One allocation, under the meter.
+    ctx.meter.reasonCarriedBytes += unaccountedBytes(
+      closed_.accounted.slice(d0.accounted.length),
     );
-    cur = fc;
   }
   t?.done(
-    [rItem(cur, "answer", resolve(ctx, cur) ?? undefined)],
+    [rItem(
+      closed_.product,
+      "answer",
+      resolve(ctx, closed_.product) ?? undefined,
+    )],
+    // A FIXPOINT: no further step was offered, or the law refused the one that
+    // was.  There is no allowance to exhaust, so the note is true by
+    // construction.
     "the multi-hop chain's fixpoint",
   );
-  return cur;
+  return closed_;
 }
 
 /** Fuse independent points of attention into one answer (multi-topic).
@@ -278,7 +354,7 @@ export async function reason(
 export async function fuseAttention(
   ctx: MindContext,
   query: Uint8Array,
-  primary: Uint8Array,
+  state: DerivationState,
   pre: Precomputed,
   /** True when `primary` never touched the consensus climb at all — e.g. a
    *  pure ALU computation, which has no anchor of its own.  commitVotes
@@ -293,8 +369,13 @@ export async function fuseAttention(
    *  which is the layer that knows how a given grounding records its evidence;
    *  fuseAttention just reads a position from it.  Empty or absent preserves
    *  the original behaviour exactly. */
-  primarySpans: ReadonlyArray<readonly [number, number]> = [],
-): Promise<Uint8Array> {
+  primarySpans: ReadonlyArray<Span> = [],
+): Promise<DerivationState> {
+  // THE STATE, NOT BARE BYTES: fusion is one more transition of the derivation
+  // the walk returned, so it reads that state's product and hands back a state.
+  // Its own structural gates stay here — this is the layer that can resolve
+  // those witnesses, and the law never re-derives one.
+  const primary = state.product;
   // When the answer is structurally drawn from the query itself
   // (extraction), it already spans all the query's pieces — fusion
   // would only add noise from unrelated stored contexts.  The gate is
@@ -302,7 +383,7 @@ export async function fuseAttention(
   // byte run): the old sparse-subsequence test was trivially satisfied by
   // short answers over long queries, silently starving multi-topic queries
   // of fusion.
-  if (containsSpan(ctx, query, primary)) return primary;
+  if (containsSpan(ctx, query, primary)) return state;
 
   // The committed points of attention ARE the shared climb's roots (same
   // query, same k, same DF mode) — read them from Precomputed instead of
@@ -345,7 +426,7 @@ export async function fuseAttention(
   const lonePromotes = unclimbed && forest.length === 1 &&
     forest[0].breadth > 0.5 && independentOfPrimary(forest[0]);
   if (forest.length === 0 || (forest.length <= 1 && !lonePromotes)) {
-    return primary;
+    return state;
   }
 
   // WHERE THE QUERY ASKED FOR IT.  The sort below orders the fused pieces by
@@ -428,7 +509,13 @@ export async function fuseAttention(
     // the root resonates.
     const cont = await follow(ctx, root.anchor, qv);
     if (
-      cont !== null && cont.length > 0 && indexOf(query, cont, root.end) >= 0
+      cont !== null && cont.length > 0 &&
+      // The law's positional reading: the caller knows the material it is
+      // looking for lies AT OR AFTER this root, which is the witness; the law
+      // owns the containment test itself.  The `cont.length > 0` guard stays
+      // here because an EMPTY continuation indexes at every offset — the law
+      // has no opinion about whether "nothing" counts as said.
+      restates(query, cont, 0, { from: root.end })
     ) {
       ctx.trace?.step(
         "alreadyAnswered",
@@ -448,7 +535,7 @@ export async function fuseAttention(
       [rItem(primary, "answer")],
       "no further independent point grounded",
     );
-    return primary;
+    return state;
   }
 
   pieces.sort((a, b) => a.start - b.start);
@@ -462,9 +549,29 @@ export async function fuseAttention(
     [rItem(out, "answer", resolve(ctx, out) ?? undefined)],
     `fused ${pieces.length} independent points of attention into one answer`,
   );
-  return out;
+  // THE FACT IS THE FUSED ANSWER, not the call: every early return above hands
+  // back `primary` untouched.  Untraced on purpose (meter.ts contract 1).
+  if (ctx.meter) ctx.meter.fuseRuns++;
+  // A FUSION IS A TRANSITION, and the only one in the engine that can splice the
+  // QUESTION'S OWN material into the product.  So it is OFFERED to the law rather
+  // than built by hand: the law reads the window the fused product holds — the
+  // same reading the carries admission uses, one definition — accounts for the
+  // span it carried, and lets the question's remainder drain on EVIDENCE.  A
+  // fusion that carries nothing consumes nothing, because the reading finds no
+  // window; and `reaches` is declared only when the fusion composed another root,
+  // which is structure this derivation had not stood on.
+  const fusedT: Continuation = {
+    product: out,
+    contains: true,
+    reaches: rest.length > 0,
+    cost: STEP,
+  };
+  const fusedWitness = admissible(state, fusedT, query, ctx.space.maxGroup);
+  if (fusedWitness === null) return { ...state, product: out };
+  const fused = advance(state, fusedT, fusedWitness);
+  if (ctx.meter) {
+    ctx.meter.closureDrainedBytes += unaccountedBytes(state.remainder) -
+      unaccountedBytes(fused.remainder);
+  }
+  return fused;
 }
-
-// (resonance.js is already a static dependency above — `bridge` — so the old
-// dynamic import of pivotInto guarded against a cycle that does not exist.)
-import { containsSpan } from "./match.js";

package/src/mind/recognition.ts

@@ -535,7 +535,10 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
         // emitted, so a caller can retry a trimmed edge on the miss path only.
         if (end - start < W) return false;
         if (flatProbe(start, end) === null) {
-          if (!canonBudget) return false;
+          if (!canonBudget) {
+            if (ctx.meter) ctx.meter.canonProbesDenied++;
+            return false;
+          }
           if (!canonAdmits(start, end)) return false;
         }
         const id = resolveSpan(start, end);
@@ -556,13 +559,6 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
       // endpoints in order and running out partway along the query.  A form
       // longer than that is out of this tier's reach — but so is a form the
       // chain cannot span, and that is exactly the trade the budget prices.
-      // The factor is chainReach(W), the same W² scale the chain already
-      // trusts; no new constant.
-      // The factor is chainReach(W) — the same W² scale the chain itself
-      // trusts — so the cap is derived from the fold's geometry, never tuned.
-      // (It was briefly an environment variable while the cost was being
-      // measured; an env-read here would make inference non-reproducible,
-      // which the determinism contract forbids outright.)
       // The factor is chainReach(W) — the same W² scale the chain itself
       // trusts — so the cap is derived from the fold's geometry, never tuned.
       // (It was briefly an environment variable while the cost was being

package/src/mind/resonance.ts

@@ -329,7 +329,14 @@ export async function pivotInto(
   consumed: ReadonlySet<number>,
   voiced: readonly Uint8Array[] = [],
 ): Promise<number | null> {
-  const k = ctx.cfg.recallQueryK;
+  // The pivot's OWN shortlist capacity — not `recallQueryK`: they are different
+  // quantities (a mechanical sweep's probe budget vs the bridge's candidate-read
+  // allowance), and one number serving both means tightening either silently
+  // starves the other.  The reason is the duplication, NOT a measured strangle:
+  // an earlier version of this comment claimed "at recallQueryK 1 the pivot finds
+  // no pivot", and that was probed and is FALSE on test/23's fixture — the
+  // strangle is fixture-specific, so it is not the evidence for this split.
+  const k = ctx.cfg.pivotProbeK;
   // ONE perception of the answer, shared by the probe budget and the walk —
   // this used to fold the same bytes twice, back to back, on every hop.
   const tree = perceive(ctx, answer);
@@ -365,6 +372,17 @@ export async function pivotInto(
     }
     for (const c of n.kids) queue.push(c); // breadth-first: larger regions first
   }
+  // The sweep's two FACTS, untraced (meter.ts contract 1: a counter never
+  // reaches a decision).  `probes` is the work done; the shortfall is the
+  // capacity the cap withheld — the branches the breadth-first order never got
+  // to.  Whether that withheld anything that mattered is NOT said here: the
+  // order spends the largest regions first, and recognition below still
+  // contributes every exact containment candidate regardless of the budget.
+  if (ctx.meter) {
+    ctx.meter.pivotProbes += probes;
+    const unprobed = branchCount - probeCap;
+    if (unprobed > 0) ctx.meter.pivotBranchesUnprobed += unprobed;
+  }
   // THE FULL recognition, memo-shared with every other reader of these bytes.
   // A "skip the edge trims here" variant was refuted (see recognise's own
   // note): those trims are what find a WHOLE trained form embedded at an

package/src/mind/trace.ts

@@ -18,6 +18,7 @@ export function rItem(
 ): RationaleItem {
   return {
     text: decodeText(bytes),
+    bytes,
     role,
     node: node ?? undefined,
     span,

package/src/mind/traverse.ts

@@ -10,6 +10,13 @@ import { cosine, Vec } from "../vec.js";
 import type { AncestorReach, MindContext, SaturationStop } from "./types.js";
 import { gistOf, read } from "./primitives.js";
 import { canonicalWindows, 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 type { RationaleItem } from "./rationale.js";
 
 // ── Session structural memo ─────────────────────────────────────────────
 //
@@ -824,11 +831,6 @@ export function chooseAmong(
     : { id: candidates[0], score: -Infinity };
 }
 
-// ── Trace shim (used by chooseNext before trace module is loaded) ────────
-
-import { decodeText } from "./rationale.js";
-import type { RationaleItem } from "./rationale.js";
-
 function rItemShort(
   ctx: MindContext,
   id: number,