@hviana/sema 0.8.1 → 0.8.3

package/dist/src/mind/pipeline.js

@@ -12,7 +12,7 @@ import { PASS, STEP } from "./graph-search.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 { Precomputed } from "./pipeline-mechanism.js";
@@ -124,8 +124,7 @@ export async function think(ctx, query, mechs) {
     // (meter.md); the trace already represents structure.
     const pre = new Precomputed(ctx, query, rec, computed, ctx._edgeGuide);
     const grade = (w) => Math.floor(w / STEP);
-    const unaccounted = (spans) => unexplainedSpans(query.length, spans)
-        .reduce((sum, [s, e]) => sum + (e - s), 0);
+    const unaccounted = (spans) => unaccountedBytes(unexplainedSpans(query.length, spans));
     const weigh = (accounted, moves) => moves + PASS * unaccounted(accounted);
     const candidates = [];
     let best = null;
@@ -317,13 +316,10 @@ export async function think(ctx, query, mechs) {
     }
     const answer = decided.bytes;
     const provenance = decided.provenance;
-    const castUsed = 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()
-            : 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
@@ -352,12 +348,59 @@ export async function think(ctx, query, mechs) {
     // `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
-        ? await meter.time("reason", () => reason(ctx, query, answer, preConsumed, pre, voiced))
-        : await reason(ctx, query, answer, preConsumed, pre, voiced);
+    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 = [
+        ...decided.accounted,
+        ...pre.computed.map((u) => [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, uncovered))
+        : 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
     // undercounts this: it is a COST-LADDER quantity (cover.ts prices its
@@ -374,10 +417,6 @@ export async function think(ctx, query, mechs) {
     // 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 = [
-        ...decided.accounted,
-        ...pre.computed.map((u) => [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
@@ -405,6 +444,13 @@ export async function think(ctx, query, mechs) {
         : meter
             ? await meter.time("fuse", () => fuseAttention(ctx, query, reasoned, pre, unclimbed, primarySpans))
             : await fuseAttention(ctx, query, reasoned, pre, unclimbed, primarySpans);
-    done(fused, "grounded, reasoned forward, fused across points of attention");
+    done(fused, 
+    // 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/dist/src/mind/primitives.js

@@ -297,7 +297,15 @@ export function canonResolve(ctx, bytes) {
         // 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)) {
             best = use;

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

@@ -26,6 +26,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.
  *
@@ -72,6 +83,13 @@ export type InspectRationale = (step: RationaleStep) => void;
 /** Decode bytes to text for display, dropping the NUL padding the encoder uses
  *  (the same cleanup {@link Mind.respondText} does for its result). */
 export declare function decodeText(bytes: Uint8Array): string;
+/** 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 declare function unaccountedBytes(spans: ReadonlyArray<readonly [number, number]>): number;
 /** 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. */
@@ -133,7 +151,16 @@ export declare class Rationale {
      *  now; the matching {@link Scope.done} supplies the outputs when it finishes.
      *  `deps` overrides the default data-flow edge (previous sibling / parent). */
     enter(name: string, inputs: RationaleItem[], deps?: number[]): Scope;
-    /** 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, inputs: RationaleItem[], outputs: RationaleItem[], note?: string, deps?: number[], data?: unknown): number;
 }

package/dist/src/mind/rationale.js

@@ -24,6 +24,18 @@
 export function decodeText(bytes) {
     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) {
+    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. */
@@ -151,7 +163,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, inputs, outputs, note, deps, data) {
         const mechanism = this.path(name);

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

@@ -13,14 +13,36 @@ import type { Precomputed } from "./pipeline-mechanism.js";
 export declare 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. */
-export declare function reason(ctx: MindContext, query: Uint8Array, answer: Uint8Array, preConsumed: ReadonlySet<number>, pre: Precomputed, voiced?: readonly Uint8Array[]): Promise<Uint8Array>;
+/** 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 declare function reason(ctx: MindContext, query: Uint8Array, answer: Uint8Array, 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<ReasonedAnswer>;
 /** Fuse independent points of attention into one answer (multi-topic).
  *  When the consensus climb finds more than one dominant point, each
  *  independent point grounds its own answer; they are bridged together

package/dist/src/mind/reasoning.js

@@ -6,8 +6,9 @@ import { rItem, rNode } from "./trace.js";
 import { bytesEqual, indexOf } from "../bytes.js";
 import { resolve } from "./primitives.js";
 import { 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 { 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,
  *  never answers it.  The exact guard recallByResonance already applies to
@@ -21,24 +22,20 @@ import { joinWithBridge, pivotInto } from "./resonance.js";
 export function restatesQuery(query, bytes) {
     return bytes.length < query.length && indexOf(query, bytes, 0) >= 0;
 }
-/** 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
- *  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. */
-export async function reason(ctx, query, answer, preConsumed, pre, voiced = []) {
+export async function reason(ctx, query, answer, preConsumed, pre, voiced = [], 
+/** 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 = []) {
     // 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
     // reverse fan-in (and a hub context's forward fan-out) is corpus-sized, and
@@ -95,7 +92,7 @@ export async function reason(ctx, query, answer, preConsumed, pre, voiced = [])
         ? 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();
     /** `prev` lets a caller hand in an already-read reverse-edge list — hop 0
@@ -143,7 +140,27 @@ export async function reason(ctx, query, answer, preConsumed, pre, voiced = [])
     const qv = pre.guide; // the response-wide guide IS the query's gist
     let t;
     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 = [];
+    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);
@@ -166,6 +183,7 @@ export async function reason(ctx, query, answer, preConsumed, pre, voiced = [])
                 ]);
                 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;
+                steps++;
                 continue;
             }
         }
@@ -178,12 +196,98 @@ export async function reason(ctx, query, answer, preConsumed, pre, voiced = [])
         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;
+            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", [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");
         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)], "the multi-hop chain's fixpoint");
-    return cur;
+    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 { bytes: cur, carried, steps };
 }
 /** Fuse independent points of attention into one answer (multi-topic).
  *  When the consensus climb finds more than one dominant point, each
@@ -352,8 +456,9 @@ primarySpans = []) {
         out = await joinWithBridge(ctx, out, pieces[i].bytes);
     }
     t?.done([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/dist/src/mind/recognition.js

@@ -519,8 +519,11 @@ function recogniseImpl(ctx, bytes) {
                 if (end - start < W)
                     return false;
                 if (flatProbe(start, end) === null) {
-                    if (!canonBudget)
+                    if (!canonBudget) {
+                        if (ctx.meter)
+                            ctx.meter.canonProbesDenied++;
                         return false;
+                    }
                     if (!canonAdmits(start, end))
                         return false;
                 }
@@ -543,13 +546,6 @@ function recogniseImpl(ctx, bytes) {
             // 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/dist/src/mind/resonance.js

@@ -249,7 +249,14 @@ export async function joinWithBridge(ctx, left, right) {
  *  overlap, so C3's genuine further hop — "Mona Lisa", a term inside the seat
  *  sentence but part of NEITHER analog — still fires. */
 export async function pivotInto(ctx, answer, consumed, voiced = []) {
-    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);
@@ -288,6 +295,18 @@ export async function pivotInto(ctx, answer, consumed, voiced = []) {
         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/dist/src/mind/trace.js

@@ -8,6 +8,7 @@ import { decodeText } from "./rationale.js";
 export function rItem(bytes, role, node, span) {
     return {
         text: decodeText(bytes),
+        bytes,
         role,
         node: node ?? undefined,
         span,

package/dist/src/mind/traverse.js

@@ -8,6 +8,12 @@
 import { cosine } from "../vec.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";
 //
 // Budgeted on the same terms as the reach memo below (caches.md): these three
 // maps are cleared on every write, but a long read-only session over a large
@@ -664,7 +670,15 @@ export function chooseNext(ctx, id, guide) {
     // 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)], others.map((c) => rItemShort(ctx, c, "candidate", ctx.store.prevCount(c))), `${capped.length} continuations — distributional evidence selects ` +
             `the most corroborated (distinct contexts ${bestSupport}, ` +
             `poured mass ${bestMass})`);
@@ -696,8 +710,6 @@ export function chooseAmong(ctx, candidates, guide) {
         ? { id: found.item, score: found.score }
         : { id: candidates[0], score: -Infinity };
 }
-// ── Trace shim (used by chooseNext before trace module is loaded) ────────
-import { decodeText } from "./rationale.js";
 function rItemShort(ctx, id, role, score) {
     return {
         text: decodeText(read(ctx, id)),