@hviana/sema 0.8.1 → 0.8.3

package/src/mind/pipeline.ts

@@ -15,7 +15,7 @@ import type { ComputedSpan } from "../extension.js";
 import { gistOf, read, resolve } from "./primitives.js";
 import { recognise } from "./recognition.js";
 import { fuseAttention, reason } from "./reasoning.js";
-import { unexplainedSpans } from "./rationale.js";
+import { unaccountedBytes, unexplainedSpans } from "./rationale.js";
 import { rItem } from "./trace.js";
 import { hubBound } from "./traverse.js";
 import { type PipelineMechanism, Precomputed } from "./pipeline-mechanism.js";
@@ -253,8 +253,7 @@ export async function think(
   }
   const grade = (w: number) => Math.floor(w / STEP);
   const unaccounted = (spans: ReadonlyArray<[number, number]>): number =>
-    unexplainedSpans(query.length, spans)
-      .reduce((sum, [s, e]) => sum + (e - s), 0);
+    unaccountedBytes(unexplainedSpans(query.length, spans));
   const weigh = (
     accounted: ReadonlyArray<[number, number]>,
     moves: number,
@@ -504,14 +503,11 @@ export async function think(
   }
   const answer: Uint8Array = decided.bytes;
   const provenance = decided.provenance as Provenance;
-  const castUsed: ReadonlySet<number> = decided.used ?? new Set();
+  const declaredUsed = decided.used;
 
   // ── Post-grounding, gated by provenance ──────────────────────────────
-  const preConsumed = provenance === "cast" || provenance === "join"
-    ? castUsed
-    : provenance === "recall" || provenance === "recall-echo"
-    ? new Set<number>()
-    : new Set(recognise(ctx, answer).sites.map((s) => s.payload));
+  const preConsumed = declaredUsed ??
+    new Set(recognise(ctx, answer).sites.map((s) => s.payload));
   // A grounding that DECLARED itself complete is not extended: the answer is
   // already a trained form's own continuation, reached through an identity
   // claim about the query, so a multi-hop pivot could only chain past the
@@ -540,17 +536,76 @@ export async function think(
   // `preConsumed` is derived by re-recognising the answer — "everything in
   // it", not "what it voiced" — and a containment rule over that would
   // suppress every pivot the answer legitimately contains.
-  const voiced = (provenance === "cast" || provenance === "join")
-    ? [...castUsed].flatMap((id) =>
-      ctx.store.nextFirst(id, hubBound(ctx)).map((n) => read(ctx, n))
-    )
-    : [];
-  const reasoned = decided.complete ? answer : meter
+  const voiced = declaredUsed === undefined ? [] : [...declaredUsed].flatMap(
+    (id) => ctx.store.nextFirst(id, hubBound(ctx)).map((n) => read(ctx, n)),
+  );
+  // WHAT THIS BRANCH READ, published where it was read.  Post-grounding decides
+  // by `decided.used` and by the provenance NAME; the operands were invisible in
+  // the trace, so a change to the branching could not be shown equivalent or
+  // otherwise from outside — three separate investigations failed on exactly
+  // that gap.  A gap in instrumentation is a defect IN the instrumentation
+  // (AGENTS.md §6): closed here, once, as counts only — never content.
+  ctx.trace?.step(
+    "postGrounding",
+    [rItem(answer, provenance)],
+    [],
+    `used=${decided.used !== undefined ? "declared" : "absent"} · ` +
+      `preConsumed=${preConsumed.size} · voiced=${voiced.length}`,
+    undefined,
+    {
+      version: 1,
+      provenance,
+      usedDeclared: decided.used !== undefined,
+      preConsumed: preConsumed.size,
+      voiced: voiced.length,
+    },
+  );
+  // REPORTABLE, NOT SILENT.  A declared-complete grounding ends the derivation
+  // here, and that decision is part of the derivation's shape: the reader of a
+  // rationale must be able to see that the chain stopped because the mechanism
+  // claimed the query WAS the context, not because nothing followed.  The step
+  // carries the claim, not a re-description of the answer — the extension is
+  // skipped, so there is no output item to show.
+  if (decided.complete) {
+    ctx.trace?.step(
+      "completeGrounding",
+      [rItem(answer, provenance)],
+      [],
+      "grounding declared complete — the query IS the context, so " +
+        "post-grounding extension is skipped",
+    );
+  }
+  // THE REASONER JUDGES ITS OWN EXTENSIONS BY THE PIPELINE'S REMAINDER, not by
+  // the ladder's `accounted` — and by the SAME reading the fuse gate below uses,
+  // with the same W floor.  `accounted` is a COST quantity (measured: a query
+  // fully explained by one computed span plus bridged connectors reports
+  // `accounted: []` while nothing is unexplained), and a remainder under one
+  // river-fold quantum is bridging punctuation, never a second topic — so it
+  // licenses no extension and blocks none.
+  const explained: Array<[number, number]> = [
+    ...decided.accounted,
+    ...pre.computed.map((u): [number, number] => [u.i, u.j]),
+  ];
+  const uncovered = unexplainedSpans(query.length, explained)
+    .filter(([a, b]) => b - a >= ctx.space.maxGroup);
+  // PUBLISHED, NOT RECOMPUTED: the same `uncovered` the gates below read.  A
+  // write-only accounting (meter contract 1), so the number that licenses an
+  // extension or a fusion stops being invisible.
+  if (meter) {
+    meter.postGroundingRemainderSpans += uncovered.length;
+    meter.postGroundingRemainderBytes += unaccountedBytes(uncovered);
+  }
+  // The extension is kept as a WHOLE (bytes + what it carried + how many steps),
+  // not just its bytes: pricing it — `steps · STEP` against `PASS · unaccounted`
+  // — is the caller's job, one comparison away.  `reasoned` stays the bytes so
+  // everything downstream is untouched.
+  const extension = decided.complete ? undefined : meter
     ? await meter.time(
       "reason",
-      () => reason(ctx, query, answer, preConsumed, pre, voiced),
+      () => reason(ctx, query, answer, preConsumed, pre, voiced, uncovered),
     )
-    : await reason(ctx, query, answer, preConsumed, pre, voiced);
+    : await reason(ctx, query, answer, preConsumed, pre, voiced, uncovered);
+  const reasoned = extension?.bytes ?? answer;
 
   // Fuse only when the query has a genuine REMAINDER no mechanism's
   // structural evidence touched at all.  `decided.accounted` alone
@@ -568,10 +623,6 @@ export async function think(
   // observed: a single space between two fully-computed arithmetic spans
   // ("2+2 3+3") registered as "unaccounted" and pulled in an unrelated
   // corpus fact, corrupting "4 6" into "4 63".
-  const explained: Array<[number, number]> = [
-    ...decided.accounted,
-    ...pre.computed.map((u): [number, number] => [u.i, u.j]),
-  ];
   const remainder = unaccounted(explained);
   // Whether the winning candidate's entire recognised substance is
   // COMPUTED — every accounted span exactly a pre.computed span, nothing
@@ -615,7 +666,13 @@ export async function think(
 
   done(
     fused,
-    "grounded, reasoned forward, fused across points of attention",
+    // NO CLAIM ABOUT FUSION HERE.  `fuseAttention` is entered whenever a
+    // remainder ≥ W exists and returns early when there is nothing to bridge, so
+    // this note used to assert a fusion that frequently did not happen (measured:
+    // "What is the capital of France famous for" fuses 0 times).  The fusion is
+    // reported by `fuseAttention`'s own `done` when it happens — the layer that
+    // did the work is the layer that says so.
+    "grounded, reasoned forward",
   );
   return { bytes: fused, provenance };
 }

package/src/mind/primitives.ts

@@ -338,7 +338,15 @@ export function canonResolve(
     // on exactly the node the canonical-case query would have found.
     const folded = foldTree(ctx, perceive(ctx, bytesOf), 0).node;
     const use = folded ?? id;
-    const leads = store.hasNext(use) || store.haloMass(use) > 0;
+    // THE ADMISSION PREDICATE, by its own pair of probes: `traverse.ts`'s
+    // `leadsSomewhere` is edge-or-halo, and `hasHalo` is the one that carries
+    // the mass bar (`mass >= minHaloMass`).  Asking `haloMass(use) > 0` instead
+    // is the same answer only while `minHaloMass <= 1` (its default): raise the
+    // bar and this site would rank a node as leading on evidence the law
+    // refuses.  Calling `leadsSomewhere` here is not possible — `traverse.ts`
+    // imports THIS file, so it would be a cycle — which is why the pair is
+    // spelled out rather than named.
+    const leads = store.hasNext(use) || store.hasHalo(use);
     if (
       best === null || (leads && !bestLeads) ||
       (leads === bestLeads && use < best)

package/src/mind/rationale.ts

@@ -49,6 +49,17 @@ export interface RationaleItem {
    *  caller asked to carry it (off by default — a D-float array per item would
    *  bury the reasoning it is meant to explain). */
   v?: Vec;
+  /** The element's OWN bytes, attached BY REFERENCE when the step was built from
+   *  bytes (a `rationale.ts` item made from a node carries none: read it back
+   *  through `node`).  `text` is a RENDERING and cannot stand in for them — it
+   *  decodes UTF-8 and DROPS NUL bytes, so a key containing one is unrecoverable
+   *  from it, which is exactly how a join refusal (`deriveThroughMiss`) became
+   *  impossible to test exactly without re-encoding.  Treat as READ-ONLY: the
+   *  array belongs to the caller (and may be a view into the query).
+   *
+   *  Costs nothing when nothing inspects: items exist only while a rationale
+   *  sink is attached, and this holds a reference rather than a copy. */
+  bytes?: Uint8Array;
 }
 
 /** A single completed act of inference — one mechanism, run once.
@@ -101,6 +112,20 @@ export function decodeText(bytes: Uint8Array): string {
   return new TextDecoder().decode(bytes.filter((b) => b !== 0x00));
 }
 
+/** The BYTE COUNT of the complement — what the currency calls `unaccounted`
+ *  in `weight = moves + PASS·unaccounted`.  It lives here, beside the function
+ *  that produces the gaps, because the price's second term has ONE definition:
+ *  this was four copies of the same `reduce` (two in reasoning.ts, two in
+ *  pipeline.ts) before the architecture audit of `../auditoria-arquitectura-sema.md`
+ *  collapsed them.  Same value at every site — the control diff is identical. */
+export function unaccountedBytes(
+  spans: ReadonlyArray<readonly [number, number]>,
+): number {
+  let total = 0;
+  for (const [a, b] of spans) total += b - a;
+  return total;
+}
+
 /** The `[start, end)` gaps of `[0, queryLen)` NOT covered by `accounted` —
  *  the same union-of-spans reading think's grounding decider prices at PASS
  *  per byte, exposed here so a mechanism can turn it into a human label. */
@@ -264,7 +289,16 @@ export class Rationale {
     };
   }
 
-  /** Record a mechanism that has no sub-steps — its inputs and outputs are both
+  /** WHY THIS NAME IS A FREE STRING, when the derivation's moves are a closed
+   *  union: a mechanism name is WRITTEN and DISPLAYED, and it COMPOSES with
+   *  the nesting — `mechanism` is the whole path (`["respond", "think",
+   *  "recognise"]`), which no fixed union can express.  Nothing branches on it:
+   *  `nothing here drives the inference; it only WITNESSES it`.  A vocabulary
+   *  that is only witnessed needs no union; one that is read does
+   *  (`DerivationMove`, in graph-search.ts).  The asymmetry is the design, not
+   *  a drift.
+   *
+   *  Record a mechanism that has no sub-steps — its inputs and outputs are both
    *  known at the call site.  Returns its index, for a later step to depend on. */
   step(
     name: string,

package/src/mind/reasoning.ts

@@ -8,10 +8,10 @@ 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 type { Precomputed } from "./pipeline-mechanism.js";
-import type { Rationale } from "./rationale.js";
+import { type Rationale, unaccountedBytes } 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,
@@ -29,13 +29,32 @@ export function restatesQuery(query: Uint8Array, bytes: Uint8Array): boolean {
 
 /** 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
  *  response's shared pre-computation — the post-grounding stages read the
  *  same container the mechanisms did. */
+/** What the multi-hop extension produced, and what it cost: the bytes (the
+ *  answer), the spans of the grounding's UNCOVERED material that each step was
+ *  justified by, and how many steps were taken.  The last two exist so the
+ *  caller can price the extension in the ladder's own currency — `steps · STEP`
+ *  against `PASS · unaccounted` — instead of taking it unconditionally.  Both
+ *  are FACTS, not verdicts: nothing here says whether the extension was worth
+ *  it; that is the comparison's job, one layer up. */
+export interface ReasonedAnswer {
+  bytes: Uint8Array;
+  carried: Array<[number, number]>;
+  steps: number;
+}
+
 export async function reason(
   ctx: MindContext,
   query: Uint8Array,
@@ -43,14 +62,20 @@ export async function reason(
   preConsumed: ReadonlySet<number>,
   pre: Precomputed,
   voiced: readonly Uint8Array[] = [],
-): Promise<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<ReasonedAnswer> {
   // 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 { bytes: answer, carried: [], steps: 0 };
+  }
 
   // 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
@@ -109,7 +134,7 @@ export async function reason(
     ? null
     : ctx.store.prevFirst(groundedId, bound);
   if (qId !== null && groundedPrev !== null && groundedPrev.includes(qId)) {
-    return answer;
+    return { bytes: answer, carried: [], steps: 0 };
   }
 
   const consumed = new Set<number>();
@@ -155,7 +180,27 @@ export async function reason(
   const qv = pre.guide; // the response-wide guide IS the query's gist
   let t: ReturnType<Rationale["enter"]> | undefined;
   const startedFrom = answer;
-  for (let hop = 0; hop < ctx.cfg.recallQueryK; hop++) {
+  // INSTRUMENTATION ONLY — the two facts the extension's own decision already
+  // used and threw away: the spans of uncovered material each step was
+  // JUSTIFIED by (the gate below computes which span carries it and kept only a
+  // boolean), and how many steps were taken.  Nothing here decides anything:
+  // both are read after the loop, to bump counters and to let the caller compare
+  // the extension's cost against what it explains, in the ladder's own currency.
+  const carried: Array<[number, number]> = [];
+  let steps = 0;
+  // 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: each taken
+  // step must carry a W-window of the uncovered material (finite), 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 it: test/89 — the corpus-cost guard, the heaviest
+  // case in the suite — is green and no slower without the allowance (27 s
+  // against 30 s); and raising it from 12 to 200 changed neither the answer nor
+  // `pivotSteps` on the chain fixtures.
+  for (let hop = 0;; 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.
     const curId = hop === 0 ? groundedId : resolve(ctx, cur);
@@ -188,6 +233,7 @@ export async function reason(
           "the answer is itself a learnt fact — follow its continuation to the fixpoint",
         );
         cur = fwd;
+        steps++;
         continue;
       }
     }
@@ -200,6 +246,80 @@ export async function reason(
     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;
+      let justified: [number, number] | undefined;
+      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;
+            justified = [a, b];
+          }
+        }
+        if (progress) break;
+      }
+      if (progress && justified !== undefined) carried.push(justified);
+      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.
+        //
+        // THE PROMISE IS NOW KEPT, AND THE BRAKE TURNS OUT TO BE THE LADDER'S
+        // OWN CONSEQUENCE.  The extension reports what it carried (`carried`,
+        // the span each step was justified by) and what it cost (`steps`), both
+        // counted in the meter (`reasonCarriedBytes`, `reasonSteps`), so the
+        // ladder CAN judge it: it accepts while
+        //
+        //     steps · STEP  <  PASS · carried
+        //
+        // and this brake accepts whenever the step carries a `W`-window, i.e.
+        // whenever `carried ≥ W ≥ 1`.  With `PASS/STEP = 1000` the two therefore
+        // agree on every extension with `steps ≤ 1000 · carried` — and every
+        // extension this repository produces takes 0 or 1 steps (measured on
+        // chains of 3, 8, 20 and 40 links).  Above that bound the ladder would
+        // refuse what this brake accepts, which is the corner named in the
+        // closure report's limits: a chain of thousands of links explaining a
+        // handful of bytes.  No guard is added for it — a limit without a
+        // derivation is exactly what the brake must not become.
+        const left = unaccountedBytes(uncovered);
+        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`,
+        );
+        break;
+      }
+    }
+    if (ctx.meter) ctx.meter.pivotSteps++;
     t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
     ctx.trace?.step(
       "pivotStep",
@@ -208,12 +328,25 @@ export async function reason(
       "pivot on the shared span this answer contains, then step forward across that fact",
     );
     cur = fc;
+    steps++;
+  }
+  // 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: the work
+  // it did (`steps · STEP`) and the uncovered material it carried.
+  if (ctx.meter) {
+    ctx.meter.reasonSteps += steps;
+    ctx.meter.reasonCarriedBytes += unaccountedBytes(carried);
   }
   t?.done(
     [rItem(cur, "answer", resolve(ctx, cur) ?? undefined)],
+    // A FIXPOINT: no further step was possible.  This note used to also cover an
+    // exhausted hop allowance — a different fact, and the reason F1 added a
+    // counter for it.  The allowance is gone, so the only way out of the loop is
+    // a refusal, and the note is true again by construction.
     "the multi-hop chain's fixpoint",
   );
-  return cur;
+  return { bytes: cur, carried, steps };
 }
 
 /** Fuse independent points of attention into one answer (multi-topic).
@@ -407,9 +540,8 @@ export async function fuseAttention(
     [rItem(out, "answer", resolve(ctx, out) ?? undefined)],
     `fused ${pieces.length} independent points of attention into one answer`,
   );
+  // 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++;
   return out;
 }
-
-// (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 ─────────────────────────────────────────────
 //
@@ -765,7 +772,15 @@ export function chooseNext(
   // for the prevCount calls in the loop above, never for extra rItemShort
   // byte-reads.
   if (ctx.trace) {
-    const others = capped.filter((c) => c !== best);
+    // A BOUNDED SAMPLE, AND THE COUNT.  The step used to carry EVERY candidate
+    // it weighed — measured on the trained store, 1559 out-items in one step
+    // (hubBound's own size) and 1082 in another (the hub's degree).  The
+    // rationale's job is to explain the CHOICE, and the count is what says how
+    // wide the field was; the declared candidate budget (`recallQueryK`) is what
+    // bounds the sample, so no number is invented here.
+    const others = capped
+      .filter((c) => c !== best)
+      .slice(0, ctx.cfg.rationaleSampleK);
     ctx.trace.step(
       "disambiguate",
       [rItemShort(ctx, best, "halo-evidence", bestSupport)],
@@ -816,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,

package/src/mind/types.ts

@@ -65,12 +65,44 @@ export interface GraphSearchHost {
     starts: ReadonlySet<number>;
   };
   chooseNext?(node: number): number | undefined;
+  /** The lengths `p` for which `prefix ‖ tail[0..p]` IS A STORED NODE, ascending
+   *  — the join's candidate set, in the tail's own coordinates.  Optional: a host
+   *  that cannot answer makes the join fall back to every prefix, which is exact
+   *  and complete but pays a `resolve` per offset.
+   *
+   *  WHY NOT THE FOLD'S CUTS.  A key names a relation exactly when the
+   *  concatenation is a node, and a node's end is the end of ITS OWN stream —
+   *  where the fold never emits a cut (geometry's `emit` guards `at >= n`).  So a
+   *  key can end strictly inside the tail with no boundary anywhere near it:
+   *  measured, "stockholm mayor" exists, leads on to the mayor fact, and its
+   *  boundary 6 is in neither the tail's cuts ([4,7]) nor the concatenation's.
+   *  The fold's boundaries are a SUBSET of the real ends, not a proxy for them,
+   *  and using them skipped the shortest names first — which is a semantic law,
+   *  not an optimisation (test/106, test/108 pin it). */
+  contentKeyEnds?(prefix: Uint8Array, tail: Uint8Array): readonly number[];
   /** The admission predicate — `traverse.ts`'s `leadsSomewhere`, its ONE
    *  definition: does this node bear an edge or a halo?  Optional, so a bare
    *  host (a raw Store and nothing else) still works; when present, the search
    *  uses it rather than re-probing the store, which keeps the predicate
    *  single-defined AND memoised on the response-scoped struct cache. */
   leadsSomewhere?(id: number): boolean;
+  /** Report a SEARCH REFUSAL into the rationale — the channel AGENTS §6
+   *  requires: a callback threaded through a call chain must FEED the
+   *  rationale, the way `GraphSearch`'s `onDerivation` feeds `traceDerivation`,
+   *  never a channel of its own.  Optional, so a bare host stays silent rather
+   *  than crashing. */
+  reportSearch?(
+    name: string,
+    parts: ReadonlyArray<Uint8Array>,
+    note: string,
+  ): void;
+  /** The CANONICAL resolver ({@link canonResolve}), optional like
+   *  {@link leadsSomewhere}.  The store's keys were written through the
+   *  canonical fold, so a fact's `Gustaf Molander` and the deposited
+   *  `gustaf molander` are the SAME node (measured inside a response: the
+   *  canonical resolver maps the surface form to the deposited node while a raw
+   *  resolve returns null).  A bare host falls back to the plain probe. */
+  canonResolve?(bytes: Uint8Array): number | null;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -119,11 +151,28 @@ export interface Attention {
    *  strength and its place.
    *  `vote` is a sum over every region that agreed, so it grows with how many
    *  places corroborated; `peak` is what the strongest one of them said on its
-   *  own.  A consumer holding this point to consensusFloor(N) — a bar that
-   *  prices ONE region's maximally-discriminative evidence — must read `peak`,
-   *  not `vote`: six scaffolding regions summing past the floor is not the
-   *  same claim as one region clearing it. */
+   *  own.  THIS USED TO PRESCRIBE THE WRONG OPERAND.  It read: "a consumer
+   *  holding this point to consensusFloor(N) — a bar that prices ONE region's
+   *  maximally-discriminative evidence — must read `peak`, not `vote`."  The
+   *  engine reads the POOLED vote, and thresholds.md §2 derives the floor for
+   *  exactly that ("Pooled-vote significance floor": one maximally-specific
+   *  region contributes at most ln N, and ln(N)+1/2 demands corroboration
+   *  BEYOND one region).  MEASURED across 27 anchors on 6 queries: all 11
+   *  admissions cleared the floor by the sum and NONE by `peak` alone — a gate
+   *  reading `peak` would refuse every root the engine elects.  `peak` remains
+   *  what it is: the strongest SINGLE region's contribution. */
   peak: number;
+  /** The IDF-WEIGHTED sum behind this point — the quantity `consensusFloor` is
+   *  derived for, and therefore the one the floor gates must read.  It is
+   *  MODE-INDEPENDENT by construction (its per-region weight is
+   *  `mutual · idf / roots`, never the mode-dependent `wf`), so gating on it
+   *  makes an anchor's admission the same in `inverse`, `direct` and `combined`.
+   *  In `inverse` — the only mode the engine runs — it equals `vote` exactly
+   *  (measured, test/55 test 17), so nothing about today's verdicts changes.
+   *  MEASURED before this field existed: gating on `vote` DID flip a verdict,
+   *  anchor 87 of test/55's query (inverse 2.682 admitted, direct 1.468
+   *  refused, floor 2.292). */
+  idfVote: number;
   /** SCALE-INVARIANT confidence: the fraction of the query's OWN regions
    *  whose evidence this point accounts for (Σ RegionVote.absorbed among
    *  its contributors, over the query's total region count) — read PER-