@hviana/sema 0.8.3 → 0.8.5

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

@@ -1,16 +1,6 @@
 import type { MindContext } from "./types.js";
 import type { Precomputed } from "./pipeline-mechanism.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 declare function restatesQuery(query: Uint8Array, bytes: Uint8Array): boolean;
+import { type DerivationState, type Span } from "./derivation.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.  **The chain ends
@@ -26,28 +16,12 @@ export declare function restatesQuery(query: Uint8Array, bytes: Uint8Array): boo
  *  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 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>;
+export declare function reason(ctx: MindContext, query: Uint8Array, d0: DerivationState, preConsumed: ReadonlySet<number>, pre: Precomputed, voiced?: readonly Uint8Array[]): Promise<DerivationState>;
 /** 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 declare function fuseAttention(ctx: MindContext, query: Uint8Array, primary: Uint8Array, pre: Precomputed, 
+export declare function fuseAttention(ctx: MindContext, query: Uint8Array, state: DerivationState, pre: Precomputed, 
 /** True when `primary` never touched the consensus climb at all — e.g. a
  *  pure ALU computation, which has no anchor of its own.  commitVotes
  *  ALWAYS admits the dominant root regardless of its vote (attention.ts:
@@ -61,4 +35,4 @@ unclimbed?: boolean,
  *  which is the layer that knows how a given grounding records its evidence;
  *  fuseAttention just reads a position from it.  Empty or absent preserves
  *  the original behaviour exactly. */
-primarySpans?: ReadonlyArray<readonly [number, number]>): Promise<Uint8Array>;
+primarySpans?: ReadonlyArray<Span>): Promise<DerivationState>;

package/dist/src/mind/reasoning.js

@@ -8,25 +8,30 @@ import { resolve } from "./primitives.js";
 import { hubBound } from "./traverse.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
- *  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;
-}
-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 = []) {
+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.  **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, 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
@@ -34,7 +39,7 @@ uncovered = []) {
     // broad structural gate; pinned by test/31-audit.
     const qId = pre.queryResolved;
     if (qId !== null && ctx.store.prevCount(qId) > 0) {
-        return { bytes: answer, carried: [], steps: 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
@@ -52,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:
     //
@@ -92,7 +97,7 @@ uncovered = []) {
         ? null
         : ctx.store.prevFirst(groundedId, bound);
     if (qId !== null && groundedPrev !== null && groundedPrev.includes(qId)) {
-        return { bytes: answer, carried: [], steps: 0 };
+        return d0;
     }
     const consumed = new Set();
     /** `prev` lets a caller hand in an already-read reverse-edge list — hop 0
@@ -136,164 +141,158 @@ uncovered = []) {
     else {
         await preconsume();
     }
-    let cur = answer;
-    const qv = pre.guide; // the response-wide guide IS the query's gist
-    let t;
-    const startedFrom = answer;
-    // 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;
+    // ── 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: 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).
+    // 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 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
+    // 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.
-    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 qv = pre.guide; // the response-wide guide IS the query's gist
+    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;
+    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;
-                steps++;
-                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;
-            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 (fc === null || bytesEqual(fc, cur) ||
+            restates(query, fc, 0, { proper: true })) {
+            return null;
+        }
+        pending = { kind: "pivot", cur, pivot, fc };
+        // Offered with the identity species ONLY when the grounding declared what it
+        // speaks for; otherwise the law requires this step to carry question
+        // material the grounding left unaccounted, which is the drift the extension
+        // tests pin — refused by the law's own measure, not by a private window
+        // test.
+        return {
+            product: fc,
+            contains: true,
+            reaches: producerOwnsShape,
+            cost: STEP,
+        };
+    };
+    const closed_ = await closure(d0, query, W, offer, (before, after) => {
+        if (ctx.meter) {
+            ctx.meter.closureDrainedBytes += unaccountedBytes(before.remainder) -
+                unaccountedBytes(after.remainder);
         }
-        if (ctx.meter)
-            ctx.meter.pivotSteps++;
+        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;
-        steps++;
-    }
+        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: the work
-    // it did (`steps · STEP`) and the uncovered material it carried.
+    // 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;
-        ctx.meter.reasonCarriedBytes += unaccountedBytes(carried);
+        // 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)], 
-    // 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.
+    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 { bytes: cur, carried, steps };
+    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:
@@ -308,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
@@ -316,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.
@@ -357,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
@@ -433,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;
         }
@@ -446,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;
@@ -460,5 +470,27 @@ primarySpans = []) {
     // back `primary` untouched.  Untraced on purpose (meter.ts contract 1).
     if (ctx.meter)
         ctx.meter.fuseRuns++;
-    return out;
+    // 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;
 }

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

package/docs/INDEX.md

@@ -8,10 +8,10 @@ proof in `test/` (pins that fail when the law is broken).
 
 | Task                        | Read                                                                               | Why                                                                                   |
 | --------------------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
-| Add a mechanism             | `docs/architecture/mechanism-market.md` + `docs/mechanisms/*.md`                   | Market contract: decoupled, declared competence, visible budget, evidence travels     |
-| Add a threshold             | `docs/architecture/thresholds.md`                                                  | All cutoffs are formulas over D/W/N in `geometry.ts`; `config.ts` holds only budgets  |
-| Debug an answer             | `docs/architecture/cost-model.md` + `src/meter.ts`                                 | One cost ladder (`MICRO`/`STEP`/`CONCEPT`/`PASS`) decides every grounding choice      |
-| Understand the fold         | `docs/architecture/fold-contract.md`                                               | Deposit and inference must compute the same tree; boundaries are not turn metadata    |
+| Add a mechanism             | `docs/architecture/mechanism-market.md` + `docs/mechanisms/*.md`                   | Market contract: the four constraints                                                 |
+| Add a threshold             | `docs/architecture/thresholds.md`                                                  | All cutoffs are formulas over D/W/N; `config.ts` holds budgets only                   |
+| Debug an answer             | `docs/architecture/cost-model.md` + `src/meter.ts`                                 | One ladder decides every grounding choice                                             |
+| Understand the fold         | `docs/architecture/fold-contract.md`                                               | Deposit and inference compute the same tree                                           |
 | Add a store backend         | `docs/architecture/store.md` + `docs/architecture/bounded-reads.md`                | `AbstractStore` owns domain logic; backends are thin wrappers with capped reads       |
 | Add an ALU operation        | `src/alu/README.md`                                                                | One `registry.derive` per op composing existing ops; no new `derive` needed           |
 | Add a matcher or projection | `docs/architecture/match-project.md`                                               | Mechanisms are `(matcher, direction, gate)` configs over the shared `match.ts` family |
@@ -19,23 +19,24 @@ proof in `test/` (pins that fail when the law is broken).
 | Change vector search        | `docs/architecture/exact-vs-approximate.md` + `docs/architecture/bounded-reads.md` | Scores propose, bytes dispose; ANN is bounded by `hubBound`                           |
 | Profile or bound work       | `docs/architecture/meter.md` + `docs/architecture/bounded-reads.md`                | `meter.ts` is write-only; counters are product, phases are hints                      |
 
-## Architecture laws (13)
+## Architecture laws (14)
 
-| Law | File                                        | Summary                                                                                                     | Pins                 |
-| --- | ------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | -------------------- |
-| 1   | `docs/architecture/determinism.md`          | No `Math.random`/`Date.now` in behaviour; seed-derived randomness; corpus-determined tie-breaks             | `test/20`            |
-| 2   | `docs/architecture/thresholds.md`           | Every decision cutoff derived in `geometry.ts` over D/W/N; no tunable knobs                                 | `test/40`, `test/64` |
-| 3   | `docs/architecture/exact-vs-approximate.md` | Vector scores rank only; identity via content-addressed lookup; five graded ladders                         | `test/51`            |
-| 4   | `docs/architecture/cost-model.md`           | Single ladder `MICRO`/`STEP`/`CONCEPT`/`PASS`; weight `moves + PASS·unaccounted`; `STEP`-grade compare      | `test/04`, `test/55` |
-| 5   | `docs/architecture/match-project.md`        | Shared `match.ts` family (`locate`/`alignGraded`/`frameSlots`/`project`); voicing gates belong to consumers | `test/24`, `test/76` |
-| 6   | `docs/architecture/mechanism-market.md`     | `PipelineMechanism` (`floor`/`run`/`parse`); admissible-floor pruning and investment discipline             | `test/01`, `test/04` |
-| 7   | `docs/architecture/commonality.md`          | Two populations: corpus-global (`reachOf`+`dominates`) vs weave-local (`depth[]`)                           | `test/17`, `test/34` |
-| 8   | `docs/architecture/bounded-reads.md`        | No per-query read grows with N; `hubBound=√N` enforced at store via LIMIT/probe/prefix caps                 | `test/77`, `test/90` |
-| 9   | `docs/architecture/store.md`                | `AbstractStore` owns dedup/indexing/batch; `store-sqlite.ts` is thin wrappers; canon index optional         | `test/08`            |
-| 10  | `docs/architecture/fold-contract.md`        | `perceiveDeposit` and `perceive` agree; `contentLevels` is single boundary rule; no W/offset dependence     | `test/59`, `test/63` |
-| 11  | `docs/architecture/memoization.md`          | `Precomputed` is per-response lazy cache (promise-cached async); `beginResponse`/`endResponse` lifecycle    | `test/42`            |
-| 12  | `docs/architecture/saturation.md`           | Every walk names a deciding saturation beside its cap; cap is safety net, not decision                      | `test/27`, `test/16` |
-| 13  | `docs/architecture/meter.md`                | `meter.ts` is write-only work accounting; counts are deterministic, phases nest                             | `test/55`            |
+| Law | File                                        | Summary                                                                                                         | Pins                 |
+| --- | ------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | -------------------- |
+| 1   | `docs/architecture/determinism.md`          | No `Math.random`/`Date.now` in behaviour; seed-derived randomness; corpus-determined tie-breaks                 | `test/20`            |
+| 2   | `docs/architecture/thresholds.md`           | Every decision cutoff derived in `geometry.ts` over D/W/N; no tunable knobs                                     | `test/40`, `test/64` |
+| 3   | `docs/architecture/exact-vs-approximate.md` | Vector scores rank only; identity via content-addressed lookup; five graded ladders                             | `test/51`            |
+| 4   | `docs/architecture/cost-model.md`           | Single ladder `MICRO`/`STEP`/`CONCEPT`/`PASS`; weight `moves + PASS·unaccounted`; `STEP`-grade compare          | `test/04`, `test/55` |
+| 5   | `docs/architecture/match-project.md`        | Shared `match.ts` family (`locate`/`alignGraded`/`frameSlots`/`project`); voicing gates belong to consumers     | `test/24`, `test/76` |
+| 6   | `docs/architecture/mechanism-market.md`     | `PipelineMechanism` (`floor`/`run`/`parse`); admissible-floor pruning and investment discipline                 | `test/01`, `test/04` |
+| 7   | `docs/architecture/commonality.md`          | Three: global (`reachOf`+`dominates`), weave-local (`depth[]`), window rarity                                   | `test/17`, `test/34` |
+| 8   | `docs/architecture/bounded-reads.md`        | No per-query read grows with N; `hubBound=√N` enforced at store via LIMIT/probe/prefix caps                     | `test/77`, `test/90` |
+| 9   | `docs/architecture/store.md`                | `AbstractStore` owns dedup/indexing/batch; `store-sqlite.ts` is thin wrappers; canon index optional             | `test/08`            |
+| 10  | `docs/architecture/fold-contract.md`        | `perceiveDeposit` and `perceive` agree; `contentLevels` is single boundary rule; no W/offset dependence         | `test/59`, `test/63` |
+| 11  | `docs/architecture/memoization.md`          | `Precomputed` is per-response lazy cache (promise-cached async); `beginResponse`/`endResponse` lifecycle        | `test/42`            |
+| 12  | `docs/architecture/saturation.md`           | Every walk names a deciding saturation beside its cap; cap is safety net, not decision                          | `test/27`, `test/16` |
+| 13  | `docs/architecture/meter.md`                | `meter.ts` is write-only work accounting; counts are exact, phases nest                                         | `test/55`            |
+| 14  | `docs/architecture/closure.md`              | A derivation is closed when its structure accounts for the question's remainder; every transition asks that law | `test/133`–`140`     |
 
 ## Mechanisms (8)
 
@@ -63,9 +64,7 @@ proof in `test/` (pins that fail when the law is broken).
 - `docs/INVARIANTS.md` — the five invariants (determinism, derived thresholds,
   exact-decides, one cost currency, bounded reads) with file-level routing.
 - `docs/failures/tempting-but-wrong.md` — refuted simplifications that passed
-  review but failed pins (e.g. reordering ladders, flattening attention
-  asymmetries, one-cone-exhausted stop).
+  review but failed pins.
 - `docs/harness/gates.md` — how `AGENTS.md` recipes,
   `bench/profile-inference.mjs`, and `test/*.test.mjs` enforce the laws.
-- `docs/architecture/` — full per-law derivation (each file states why the law
-  is this way; no separate HOW).
+- `docs/architecture/` — per-law derivation: each file says why, not how.