@hviana/sema 0.8.2 → 0.8.5

package/dist/src/mind/reasoning.js

@@ -6,43 +6,41 @@ 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";
-/** 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, bytes) {
-    return bytes.length < query.length && indexOf(query, bytes, 0) >= 0;
-}
+import { admissible, advance } from "./derivation.js";
+import { closure, restates, 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
  *  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 = [], 
-/** 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 = []) {
+export async function reason(ctx, query, d0, preConsumed, pre, voiced = []) {
+    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
     // reverse fan-in (and a hub context's forward fan-out) is corpus-sized, and
@@ -59,7 +57,7 @@ uncovered = []) {
     // 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:
     //
@@ -99,7 +97,7 @@ uncovered = []) {
         ? null
         : ctx.store.prevFirst(groundedId, bound);
     if (qId !== null && groundedPrev !== null && groundedPrev.includes(qId)) {
-        return answer;
+        return d0;
     }
     const consumed = new Set();
     /** `prev` lets a caller hand in an already-read reverse-edge list — hop 0
@@ -143,106 +141,158 @@ uncovered = []) {
     else {
         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;
+    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;
+    // 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 = null;
+    const 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))) {
             const fwd = await follow(ctx, curId, qv);
             const fwdId = fwd !== null ? resolve(ctx, fwd) : null;
             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;
+            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 (!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);
-                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 (fc === null || bytesEqual(fc, cur) ||
+            restates(query, fc, 0, { proper: true })) {
+            return null;
         }
-        if (ctx.meter)
-            ctx.meter.pivotSteps++;
+        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);
+        }
+        const p = pending;
+        pending = null;
+        if (p === null)
+            return;
         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;
+        if (p.kind === "absorb") {
+            ctx.trace?.step("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");
+        }
+    }, (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));
     }
-    t?.done([rItem(cur, "answer", resolve(ctx, cur) ?? undefined)], "the multi-hop chain's fixpoint");
-    return cur;
+    t?.done([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 closed_;
 }
 /** 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
  *  by any learnt connector the graph holds between them. */
-export async function fuseAttention(ctx, query, primary, pre, 
+export async function fuseAttention(ctx, query, state, pre, 
 /** True when `primary` never touched the consensus climb at all — e.g. a
  *  pure ALU computation, which has no anchor of its own.  commitVotes
  *  ALWAYS admits the dominant root regardless of its vote (attention.ts:
@@ -257,6 +307,11 @@ unclimbed = false,
  *  fuseAttention just reads a position from it.  Empty or absent preserves
  *  the original behaviour exactly. */
 primarySpans = []) {
+    // 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
@@ -265,7 +320,7 @@ primarySpans = []) {
     // short answers over long queries, silently starving multi-topic queries
     // of fusion.
     if (containsSpan(ctx, query, primary))
-        return 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
     // re-climbing, so even a traced response pays for the climb once.
@@ -306,7 +361,7 @@ primarySpans = []) {
     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
     // query position, which is the whole point of the `start` field: a
@@ -382,7 +437,13 @@ primarySpans = []) {
         // it fires on exact content-addressed recurrence, not on how strongly
         // the root resonates.
         const cont = await follow(ctx, root.anchor, qv);
-        if (cont !== null && cont.length > 0 && indexOf(query, cont, root.end) >= 0) {
+        if (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", [rNode(ctx, root.anchor, "point", root.vote)], [rItem(cont, "continuation")], "this point's own learnt continuation already appears later in the query — already answered, not fused");
             continue;
         }
@@ -395,7 +456,7 @@ primarySpans = []) {
     }
     if (pieces.length === 1) {
         t?.done([rItem(primary, "answer")], "no further independent point grounded");
-        return primary;
+        return state;
     }
     pieces.sort((a, b) => a.start - b.start);
     let out = pieces[0].bytes;
@@ -405,8 +466,31 @@ 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`);
-    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 = {
+        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/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
@@ -704,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)),

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

@@ -35,15 +35,21 @@ export interface GraphSearchHost {
         starts: ReadonlySet<number>;
     };
     chooseNext?(node: number): number | undefined;
-    /** The boundary positions of `bytes` under the engine's ONE boundary rule
-     *  (geometry.ts's `contentBoundaries`), or undefined when the host has no
-     *  space to ask.  The join's key is an entity plus a prefix of the tail, and
-     *  the prefix that names a stored relation ENDS on one of these boundaries —
-     *  measured, 5 of 5 accepted keys over four join-firing queries, where the
-     *  byte-by-byte scan spent 153 probes for 14 boundaries.  Boundaries are
-     *  content-defined and STABLE under prefix extension, which is why a corpus
-     *  key's end is a boundary of the query's own fold of the same bytes. */
-    contentCuts?(bytes: Uint8Array): readonly number[];
+    /** 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
@@ -104,11 +110,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-

package/dist/src/mind/types.js

@@ -2,7 +2,8 @@
 //
 // GraphSearchHost is defined first (minimal imports) so GraphSearch can import
 // it without pulling in the full MindContext.
-import { bytesEqual, concatBytes, indexOf } from "../bytes.js";
+import { bytesEqual, concatBytes } from "../bytes.js";
+import { restates } from "./derivation.js";
 import { dominates } from "../geometry.js";
 // ═══════════════════════════════════════════════════════════════════════════
 // FREE FUNCTIONS (pure, no state)
@@ -32,12 +33,14 @@ export function spliceAll(segs) {
 export function segRestatesQuery(s, query, queryLen, W) {
     if (!s.rec)
         return false;
+    // THE LITERAL EXEMPTION IS THE CALLER'S.  A span that IS the site's own bytes
+    // at its own position is naming what is already there, not substituting for
+    // it — and only this caller knows that, so it says so by not asking.
     const literal = s.j - s.i === s.bytes.length &&
         bytesEqual(s.bytes, query.subarray(s.i, s.j));
     if (literal)
         return false;
-    return s.bytes.length >= W && s.bytes.length < queryLen &&
-        indexOf(query, s.bytes, 0) >= 0;
+    return restates(query, s.bytes, W, { proper: true });
 }
 /** Lift the answer out of the cover for think: the recognised region, free of
  *  the asker's surrounding (unrecognised) framing — and free of any chosen