@hviana/sema 0.8.3 → 0.8.5

package/dist/src/mind/mechanisms/confluence.js

@@ -42,7 +42,7 @@ import { read } from "../primitives.js";
 import { corpusN, reachOf } from "../traverse.js";
 import { dominates } from "../../geometry.js";
 import { STEP } from "../graph-search.js";
-import { unexplainedLabel } from "../rationale.js";
+import { insideAnsweredTurn } from "../derivation.js";
 import { rItem, rNode } from "../trace.js";
 /** The main confluence entry point.  Given a query, detect whether it weaves
  *  two or more INDEPENDENT constraints (ranked anchors supported by disjoint
@@ -75,13 +75,9 @@ export async function confluenceJoin(ctx, query, pre) {
     // Recognition and attention still see the full transcript; only this
     // mechanism's constraint population excludes answered spans.
     const queryWin = new Map();
-    let answered = 0;
+    const answered = { at: 0 };
     for (const [off, id] of pre.queryWindows) {
-        while (answered < ctx.answeredSpans.length &&
-            ctx.answeredSpans[answered][1] <= off)
-            answered++;
-        const span = ctx.answeredSpans[answered];
-        if (span && span[0] <= off && off + W <= span[1])
+        if (insideAnsweredTurn(ctx.answeredSpans, answered, off, off + W))
             continue;
         queryWin.set(off, id);
     }
@@ -258,7 +254,6 @@ export async function confluenceJoin(ctx, query, pre) {
         used: new Set([met.a.anchor, met.b.anchor]),
         accounted,
         moves: 3 * STEP,
-        unexplained: unexplainedLabel(query, accounted),
     };
 }
 // ── Pipeline mechanism ──────────────────────────────────────────────────────
@@ -289,7 +284,6 @@ export const confluenceMechanism = {
                 accounted: met.accounted,
                 moves: met.moves,
                 used: met.used,
-                unexplained: met.unexplained,
             }];
     },
 };

package/dist/src/mind/mechanisms/cover.js

@@ -13,8 +13,8 @@ import { guidedFirst, hubBound } from "../traverse.js";
 import { conceptHop } from "../match.js";
 import { bridge } from "../resonance.js";
 import { liftAnswer, liftedScaffolding, segRestatesQuery } from "../types.js";
-import { decodeText, unexplainedLabel } from "../rationale.js";
-import { indexOf } from "../../bytes.js";
+import { decodeText } from "../rationale.js";
+import { insideAnsweredTurn, restates } from "../derivation.js";
 import { rItem, rNode, traceDerivation } from "../trace.js";
 // ── Concept / connector pre-resolution ──────────────────────────────────────
 export async function resolveConcepts(ctx, sites) {
@@ -45,16 +45,13 @@ export async function resolveConnectors(ctx, sites, query) {
     // discarded — a semantically neutral gate (it removes work whose product
     // liftAnswer throws away), and a cumulative (multi-turn) query is exactly
     // where such already-answered continuations recur.
-    let answered = 0;
+    const answered = { at: 0 };
     const ordered = [...sites]
         .sort((a, b) => a.start - b.start)
         .filter((s) => {
-        while (answered < ctx.answeredSpans.length &&
-            ctx.answeredSpans[answered][1] <= s.start)
-            answered++;
-        const span = ctx.answeredSpans[answered];
-        if (span && span[0] <= s.start && s.end <= span[1])
+        if (insideAnsweredTurn(ctx.answeredSpans, answered, s.start, s.end)) {
             return false;
+        }
         if (query === undefined || ctx.answeredSpans.length === 0)
             return true;
         const continuations = ctx.store.nextFirst(s.payload, hubBound(ctx));
@@ -77,7 +74,11 @@ export async function resolveConnectors(ctx, sites, query) {
             // 3 bytes this reads 4 bytes per candidate instead of the ~231 it
             // averaged before.
             const bytes = read(ctx, answer, query.length + 1);
-            return bytes.length <= query.length && indexOf(query, bytes, 0) >= 0;
+            // THE CONTENT READING of the same exclusion: the site's own
+            // continuation already occurs in the query, so voicing it back adds
+            // nothing.  It is the restatement law with no `proper` flag — the
+            // containment reading that also admits the whole query.
+            return restates(query, bytes, 0);
         });
     });
     const bridgePair = async (l, r) => {
@@ -171,18 +172,11 @@ export const coverMechanism = {
             ? await ctx.meter.time("cover.resolveConnectors", () => resolveConnectors(ctx, sites, query))
             : await resolveConnectors(ctx, sites, query);
         let splits = rec.splits;
-        let starts = rec.starts;
         if (computed.length > 0) {
             splits = new Set(rec.splits);
-            starts = new Set(rec.starts);
             for (const u of computed) {
                 splits.add(u.i);
                 splits.add(u.j);
-                // A computation's own boundaries carry the same fold-level evidence
-                // a chunk boundary does — "computation always wins" (see the header
-                // comment) extends to being trusted ground for cross-leaf recovery.
-                starts.add(u.i);
-                starts.add(u.j);
             }
         }
         const concepts = ctx.meter
@@ -208,7 +202,7 @@ export const coverMechanism = {
             ])),
             ...computedResults.map((u) => rItem(u.bytes, "computed")),
         ], coverDeps.length ? coverDeps : undefined);
-        const solved = ctx.search.cover(query.length, sites, concepts, rec.leaves, splits, starts, undefined, connectors, computedResults, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
+        const solved = ctx.search.cover(query.length, sites, concepts, rec.leaves, splits, undefined, connectors, computedResults, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
         const segs = solved && solved.segs;
         tCover?.done(segs === null
             ? []
@@ -247,9 +241,12 @@ export const coverMechanism = {
         return [{
                 bytes: composed,
                 accounted,
-                moves: 0,
-                weight: solved.cost, // A*LD derivation's g-value IS the weight
-                unexplained: unexplainedLabel(query, accounted),
+                // The derivation's DISCRETE work.  The bytes the chart could not
+                // recognise are NOT priced here: they are exactly the spans `accounted`
+                // leaves uncovered, and the pipeline's one formula charges them at PASS —
+                // the same formula that prices every other mechanism's candidate.  No
+                // mechanism spells a cost of its own.
+                moves: solved.moves,
                 // How much of the composed answer is the asker's own unexplained words
                 // (the spans the liftAnswer trace above labels "scaffolding").  Cover is
                 // the mechanism that can carry them, because a PASS span still lands in

package/dist/src/mind/mechanisms/extraction.d.ts

@@ -19,7 +19,6 @@ import type { PipelineMechanism, Precomputed } from "../pipeline-mechanism.js";
 export declare function extractBySkill(ctx: MindContext, query: Uint8Array, pre: Precomputed): Promise<{
     bytes: Uint8Array;
     accounted: Array<[number, number]>;
-    unexplained: string;
 } | null>;
 /** Decompose an answer into substrings of its surrounding context, in order —
  *  the STRONG span-shape reading (see the section note above).  Returns null

package/dist/src/mind/mechanisms/extraction.js

@@ -8,7 +8,7 @@
 // that contains it.
 import { locate } from "../match.js";
 import { concatBytes, indexOf } from "../../bytes.js";
-import { decodeText, unexplainedLabel } from "../rationale.js";
+import { decodeText } from "../rationale.js";
 import { CONCEPT, STEP } from "../graph-search.js";
 import { rItem, rNode, traceFail } from "../trace.js";
 // ── Extraction ────────────────────────────────────────────────────────────
@@ -81,6 +81,12 @@ export async function extractBySkill(ctx, query, pre) {
     const searched = ranked.slice(0, pre.k);
     let shapeMisses = 0;
     let subQuantum = 0;
+    // A SECOND refusal counter, because the note below used to call an UNANCHORED
+    // read "sub-quantum" — which is false, and it is the kind of instrumentation
+    // defect AGENTS §6 says to close where it lives: a reader could not tell from
+    // the trace which of the two gates refused.  Neither counter reaches a
+    // decision (meter.ts contract 1); they exist so the refusal is legible.
+    let unanchored = 0;
     for (const cand of searched) {
         const exemplar = await pre.spanShapedOf(cand.anchor);
         if (!exemplar) {
@@ -116,15 +122,16 @@ export async function extractBySkill(ctx, query, pre) {
         // Here the field is this mechanism's own output and carries its documented
         // meaning, so the test is sound exactly where the convention does not reach.
         if (built.accounted.length === 0) {
-            subQuantum++;
+            unanchored++;
             continue;
         }
-        if (shapeMisses > 0 || subQuantum > 0) {
+        if (shapeMisses > 0 || subQuantum > 0 || unanchored > 0) {
             ctx.trace?.step("trySkillAnchors", [
-                rItem(query.subarray(0, 0), `skipped ${shapeMisses + subQuantum}`),
+                rItem(query.subarray(0, 0), `skipped ${shapeMisses + subQuantum + unanchored}`),
                 rNode(ctx, cand.anchor, "chosen"),
-            ], [], `skipped ${shapeMisses} non-exemplar and ${subQuantum} sub-quantum ` +
-                `anchor(s) before one yielded a usable extraction`);
+            ], [], `skipped ${shapeMisses} non-exemplar, ${subQuantum} sub-quantum and ` +
+                `${unanchored} unanchored anchor(s) before one yielded a usable ` +
+                `extraction`);
         }
         t?.done([rItem(built.bytes, "extracted")], built.pieces === 1
             ? `apply a learnt extraction skill — read the analogous span of the query` +
@@ -134,7 +141,6 @@ export async function extractBySkill(ctx, query, pre) {
         return {
             bytes: built.bytes,
             accounted: built.accounted,
-            unexplained: unexplainedLabel(query, built.accounted),
         };
     }
     if (shapeMisses === searched.length) {
@@ -321,7 +327,6 @@ export const extractionMechanism = {
                 bytes: ex.bytes,
                 accounted: ex.accounted,
                 moves: CONCEPT + STEP * ex.accounted.length,
-                unexplained: ex.unexplained,
             }];
     },
 };

package/dist/src/mind/mechanisms/prefix-completion.js

@@ -255,7 +255,6 @@ export const prefixMechanism = {
                 // IDENTITY bridge takes.
                 accounted: [[0, query.length]],
                 moves: STEP,
-                unexplained: "",
                 // NOT complete: the query is a proper PREFIX, so the form may carry more
                 // past the remainder this voiced.
             }];

package/dist/src/mind/mechanisms/recall.d.ts

@@ -6,7 +6,6 @@ export interface RecallResult {
     echoed: boolean;
     accounted: Array<[number, number]>;
     moves: number;
-    unexplained: string;
     /** See {@link import("../pipeline-mechanism.js").MechanismResult.complete}
      *  — set by the IDENTITY-bridge tier alone. */
     complete?: boolean;

package/dist/src/mind/mechanisms/recall.js

@@ -6,11 +6,11 @@
 import { cosine } from "../../vec.js";
 import { consensusFloor, dominates, identityBar, reachThreshold, significanceBar, } from "../../geometry.js";
 import { gistOf, read, resolve } from "../primitives.js";
-import { bytesEqual, indexOf } from "../../bytes.js";
+import { indexOf } from "../../bytes.js";
 import { allWindowsAreScaffolding, corpusN, hubBound } from "../traverse.js";
 import { follow, project, reverseContext, voicesDisplacedFiller, } from "../match.js";
 import { CONCEPT, STEP } from "../graph-search.js";
-import { unexplainedLabel } from "../rationale.js";
+import { restates as lawRestates } from "../derivation.js";
 import { rItem, rNode } from "../trace.js";
 import { substitutionBridge } from "../bridge.js";
 /** Recall the answer by resonating the whole query against the content index. */
@@ -29,7 +29,6 @@ export async function recallByResonance(ctx, query, pre) {
             echoed,
             accounted,
             moves,
-            unexplained: unexplainedLabel(query, accounted),
             ...(complete ? { complete } : {}),
         };
     };
@@ -103,7 +102,7 @@ export async function recallByResonance(ctx, query, pre) {
             // guard the argument's OWN later restatement in the same
             // conversation reads as if it were the next thing to say.
             if (g !== null && g.length > 0 &&
-                !(g.length < query.length && indexOf(query, g, 0) >= 0)) {
+                !lawRestates(query, g, 0, { proper: true })) {
                 return ground(g, "argument binding — the query's sole edge-source constituent, continuation followed", [[arg.start, arg.end]], STEP);
             }
         }
@@ -130,9 +129,10 @@ export async function recallByResonance(ctx, query, pre) {
     // same principle that keeps cast from voicing stored questions), and
     // projecting them forward is reverse recall's containment failure in the
     // other direction — "whatever followed these bytes in some document".
-    const qKey = ctx.canon ? ctx.canon(query) : query;
-    const restates = (b) => bytesEqual(b, query) ||
-        (ctx.canon !== null && bytesEqual(ctx.canon(b), qKey));
+    // THE EQUALITY READING of the restatement law: this tier rejects an answer
+    // that IS the question (an echo), and a proper fragment is handled by the
+    // tier's own subspan tests further down — so the law is asked with `whole`.
+    const restates = (b) => lawRestates(query, b, 0, { equate: ctx.canon, whole: true });
     const idBar = identityBar(ctx.store.D, ctx.space.maxGroup, query.length);
     if (top.score >= idBar) {
         for (const h of whole) {
@@ -315,7 +315,7 @@ export async function recallByResonance(ctx, query, pre) {
             // — never an answer (the same principle as `restates` above, extended
             // to fragments).  Genuine anchor groundings — longer than the query,
             // or disjoint from it — pass untouched.
-            else if (g && !(g.length < query.length && indexOf(query, g, 0) >= 0)) {
+            else if (g && !lawRestates(query, g, 0, { proper: true })) {
                 return ground(g, "scaffolding-dominated query — ground the consensus-climb anchor", [[forest[0].start, forest[0].end]], CONCEPT);
             }
         }
@@ -493,7 +493,6 @@ export const recallMechanism = {
                 bytes: r.bytes,
                 accounted: r.accounted,
                 moves: r.moves,
-                unexplained: r.unexplained,
                 provenance: r.echoed ? "recall-echo" : "recall",
                 used: new Set(),
                 ...(r.complete ? { complete: true } : {}),

package/dist/src/mind/mechanisms/reference.js

@@ -35,8 +35,8 @@
 // made AVAILABLE, never imposed.
 import { carriesFillers, distinct, follow, substituteAll } from "../match.js";
 import { dominates } from "../../geometry.js";
-import { bytesEqual, indexOf } from "../../bytes.js";
-import { unexplainedLabel } from "../rationale.js";
+import { bytesEqual } from "../../bytes.js";
+import { restates } from "../derivation.js";
 import { STEP } from "../graph-search.js";
 import { rItem, rNode, traceFail } from "../trace.js";
 /** The minimum number of instances that can establish a frame.  One instance
@@ -196,7 +196,7 @@ export async function bindReference(ctx, query, pre) {
         return fail("the binding produced nothing");
     // Answering with the question is not answering — the same restated-fragment
     // guard every recall tier applies.
-    if (bytes.length < query.length && indexOf(query, bytes, 0) >= 0) {
+    if (restates(query, bytes, 0, { proper: true })) {
         return fail("the binding restates part of the question");
     }
     const carried = !bytesEqual(bytes, first);
@@ -230,7 +230,6 @@ export async function bindReference(ctx, query, pre) {
         // binding claims strictly more than a one-slot binding, so where both are
         // licensed the smaller claim wins.
         moves: STEP * slots.length + STEP,
-        unexplained: unexplainedLabel(query, accounted),
         // NOT scaffolding.  That field counts answer bytes carried through BECAUSE
         // NOTHING EXPLAINED THEM; a referent is carried because the frame's slot
         // explains it, and it is accounted above.  Reporting it would make every

package/dist/src/mind/pipeline-mechanism.d.ts

@@ -153,15 +153,12 @@ export interface MechanismResult {
     moves: number;
     /** WHAT THIS ANSWER SPEAKS FOR — the anchors it voices, and therefore the
      *  content the reasoner must not pivot back through.  Declared by the
-     *  mechanism about its OWN result, exactly like `accounted`/`unexplained`/
+     *  mechanism about its OWN result, exactly like `accounted`/`used`/
      *  `complete`: post-grounding honours the property and NEVER ASKS WHICH
      *  MECHANISM SET IT, so the market stays uniform.  An EMPTY set is a real
      *  declaration — "this answer voices nothing" (recall) — and withholds
      *  nothing; omit the field and the pipeline re-recognises the answer. */
     used?: ReadonlySet<number>;
-    unexplained: string;
-    /** Explicit weight override.  When absent, weight = moves + PASS·unaccounted. */
-    weight?: number;
     /** Bytes of `bytes` that came from spans nothing recognised — the asker's
      *  own words carried through verbatim rather than derived (see
      *  {@link liftedScaffolding}).  Reported, not priced: the ladder prices what

package/dist/src/mind/pipeline.js

@@ -12,8 +12,9 @@ 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 { unaccountedBytes, unexplainedSpans } from "./rationale.js";
+import { closed, remainderOf, unaccountedBytes, unexplainedSpans, windowOf, } from "./derivation.js";
 import { rItem } from "./trace.js";
+import { unexplainedLabel } from "./rationale.js";
 import { hubBound } from "./traverse.js";
 import { Precomputed } from "./pipeline-mechanism.js";
 import { coverMechanism } from "./mechanisms/cover.js";
@@ -242,14 +243,16 @@ export async function think(ctx, query, mechs) {
             ? await meter.time(`${mech.name}.run`, () => mech.run(ctx, query, pre))
             : await mech.run(ctx, query, pre);
         for (const r of results) {
-            const weight = r.weight ?? weigh(r.accounted, r.moves);
+            // ONE FORMULA, EVERY CANDIDATE: the chart's derivation reports how many
+            // discrete moves it made and which bytes it could not recognise; the
+            // currency prices both.  No mechanism passes a price of its own.
+            const weight = weigh(r.accounted, r.moves);
             consider({
                 bytes: r.bytes,
                 provenance: r.provenance ?? mech.provenance,
                 weight,
                 used: r.used,
                 accounted: r.accounted,
-                unexplained: r.unexplained,
                 complete: r.complete,
                 scaffolding: r.scaffolding,
             });
@@ -280,7 +283,17 @@ export async function think(ctx, query, mechs) {
         const margin = decided !== null && runnerUp !== null
             ? grade(runnerUp.weight) - grade(decided.weight)
             : null;
-        ctx.trace?.step("decideGrounding", candidates.map((c) => rItem(c.bytes, `${c.provenance} (weight ${c.weight.toFixed(3)}${c.unexplained ? `, unexplained: "${c.unexplained}"` : ""})`)), decided ? [rItem(decided.bytes, decided.provenance)] : [], "the lightest grounding derivation wins — every mechanism weighed in the one cost ladder", undefined, {
+        ctx.trace?.step("decideGrounding", 
+        // THE LABEL IS RENDERED WHERE IT IS SHOWN.  It was a field on every
+        // mechanism's result, and at every one of them it was exactly
+        // `unexplainedLabel(query, accounted)` — a second representation of a
+        // quantity one pure function already yields, computed on every response
+        // whether or not anyone looked.  Here it is computed only when a rationale
+        // is attached, because `trace?.step` short-circuits its arguments.
+        candidates.map((c) => {
+            const label = unexplainedLabel(query, c.accounted);
+            return rItem(c.bytes, `${c.provenance} (weight ${c.weight.toFixed(3)}${label ? `, unexplained: "${label}"` : ""})`);
+        }), decided ? [rItem(decided.bytes, decided.provenance)] : [], "the lightest grounding derivation wins — every mechanism weighed in the one cost ladder", undefined, {
             version: 1,
             candidates: candidates.map((c) => ({
                 provenance: c.provenance,
@@ -317,7 +330,54 @@ export async function think(ctx, query, mechs) {
     const answer = decided.bytes;
     const provenance = decided.provenance;
     const declaredUsed = decided.used;
-    // ── Post-grounding, gated by provenance ──────────────────────────────
+    // ── THE DERIVATION STATE ─────────────────────────────────────────────
+    //
+    // 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.
+    //
+    // The state is built HERE, where these quantities are already computed, so it
+    // costs nothing new: `accounted` is what the winning transition priced,
+    // `remainder` is the coverage reading over `accounted ∪ the response's
+    // computed spans` (the union is what makes the two different quantities, and
+    // both are kept), `cost` is the ladder position, and the two declarations are
+    // the producer's own (`fixed`, `used`).  What follows reads THIS state rather
+    // than a tuple rebuilt at each call site.
+    // A DERIVATION IS BORN OWING WHAT ITS ANSWER DOES NOT CARRY.  The winning
+    // transition PRICED these spans, and pricing is not carrying: coverage claimed
+    // without evidence stays owed, and a later transition pays it only by carrying
+    // it (the law reads the window; see derivation.ts).  Same reading, one
+    // definition — not a second spelling of it here.
+    const explained = [
+        ...decided.accounted,
+        ...pre.computed.map((u) => [u.i, u.j]),
+    ].filter(([a, b]) => windowOf([a, b], answer, query, ctx.space.maxGroup) !== null);
+    // WHAT THE CONSTRUCTION WITHHOLDS, at or above one quantum: the difference between
+    // the remainder paid in full and the remainder paid by carrying.  Both readings
+    // are the law's, so the floor is applied once and in one place.
+    const paidInFull = remainderOf(query.length, [
+        ...decided.accounted,
+        ...pre.computed.map((u) => [u.i, u.j]),
+    ], ctx.space.maxGroup);
+    const paid = remainderOf(query.length, explained, ctx.space.maxGroup);
+    if (ctx.meter) {
+        ctx.meter.groundingWithheldBytes += unaccountedBytes(paid) -
+            unaccountedBytes(paidInFull);
+    }
+    const state = {
+        product: answer,
+        accounted: decided.accounted,
+        remainder: paid,
+        cost: decided.weight,
+        fixed: decided.complete,
+        used: decided.used,
+    };
+    const uncovered = state.remainder;
+    // ── Post-grounding, gated by the declaration and the remainder ────────
     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
@@ -350,10 +410,13 @@ export async function think(ctx, query, mechs) {
     // suppress every pivot the answer legitimately contains.
     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
+    // by the DECLARATION (`decided.used`, which becomes `voiced`), by what the
+    // recognition already consumed (`preConsumed`) and by the derivation's own
+    // remainder — never by the provenance NAME, which is REPORTED throughout and
+    // compared nowhere (a stale comment here claimed otherwise; the register caught
+    // it, and this is the correction).  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, {
@@ -362,6 +425,14 @@ export async function think(ctx, query, mechs) {
         usedDeclared: decided.used !== undefined,
         preConsumed: preConsumed.size,
         voiced: voiced.length,
+        // THE STATE THE LAW GOVERNS, rendered where it is decided: what the asker
+        // said that no step has accounted for, in spans at or above one quantum,
+        // and whether the producer supplied a fixed point.  Counts only, like
+        // every other operand here — and the spans are the state's, so a reader
+        // can check them against the meter's aggregate of the same remainder.
+        remainderSpans: state.remainder.length,
+        remainderBytes: unaccountedBytes(state.remainder),
+        fixed: state.fixed === true,
     });
     // 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
@@ -373,19 +444,6 @@ export async function think(ctx, query, mechs) {
         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.
@@ -393,14 +451,15 @@ export async function think(ctx, query, mechs) {
         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.
+    // THE WALK CONSUMES AND RETURNS A STATE.  It is handed the derivation's own —
+    // the grounding's product, accounting, remainder and cost — and hands back the
+    // state it advanced to, so what follows reads a state rather than bytes plus a
+    // tuple rebuilt here.  A supplied fixed point is the one case where the walk
+    // does not run at all, and then the state is the grounding's own.
     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;
+        ? await meter.time("reason", () => reason(ctx, query, state, preConsumed, pre, voiced))
+        : await reason(ctx, query, state, preConsumed, pre, voiced);
+    const reasoned = extension ?? state;
     // 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
@@ -417,7 +476,15 @@ 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 remainder = unaccounted(explained);
+    // THE GATE ASKS THE LAW, and that is an OPTIMISATION, not a tidy-up: the state
+    // above ALREADY carries the remainder (`remainderOf`, per-span, with the W
+    // floor applied), so asking it costs nothing, while the total this line used to
+    // compute (`unaccounted(explained)`) was one more sum over the spans on every
+    // response.  The two readings are the same condition, not two: the ACCOUNTING
+    // applies the same W floor the gate does, so a gap below one quantum never
+    // survives into `explained` and the total cannot reach W without some single
+    // gap reaching it.  Measured over twelve constructions at W = 4 (test/136.3,
+    // which pins the equivalence and both sides of it).
     // Whether the winning candidate's entire recognised substance is
     // COMPUTED — every accounted span exactly a pre.computed span, nothing
     // from a genuinely recognised/climbed site.  fuseAttention's lone-root
@@ -427,8 +494,8 @@ export async function think(ctx, query, mechs) {
     // `unclimbed` parameter, gated there by Attention.breadth so a
     // coincidental echo (which this flag alone cannot distinguish) is still
     // rejected.
-    const unclimbed = decided.accounted.length > 0 &&
-        decided.accounted.every(([i, j]) => pre.computed.some((u) => u.i === i && u.j === j));
+    const unclimbed = state.accounted.length > 0 &&
+        state.accounted.every(([i, j]) => pre.computed.some((u) => u.i === i && u.j === j));
     // Where the winning grounding stands in the query — fusion places primary
     // by it (see fuseAttention's `primarySpans`).  `accounted` is the
     // cost-ladder read and is authoritative when non-empty; when it is empty
@@ -436,15 +503,13 @@ export async function think(ctx, query, mechs) {
     // Exactly the cost-ladder-vs-coverage distinction `explained` above draws,
     // read here for POSITION instead of for coverage — and resolved here, where
     // both readings are in hand, rather than inside fuseAttention.
-    const primarySpans = decided.accounted.length > 0
-        ? decided.accounted
+    const primarySpans = state.accounted.length > 0
+        ? state.accounted
         : pre.computed.map((u) => [u.i, u.j]);
-    const fused = remainder < ctx.space.maxGroup
-        ? reasoned
-        : meter
-            ? await meter.time("fuse", () => fuseAttention(ctx, query, reasoned, pre, unclimbed, primarySpans))
-            : await fuseAttention(ctx, query, reasoned, pre, unclimbed, primarySpans);
-    done(fused, 
+    const fused = closed(state) ? reasoned : meter
+        ? await meter.time("fuse", () => fuseAttention(ctx, query, reasoned, pre, unclimbed, primarySpans))
+        : await fuseAttention(ctx, query, reasoned, pre, unclimbed, primarySpans);
+    done(fused.product, 
     // 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:
@@ -452,5 +517,5 @@ export async function think(ctx, query, mechs) {
     // 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 };
+    return { bytes: fused.product, provenance };
 }

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

@@ -83,17 +83,6 @@ 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. */
-export declare function unexplainedSpans(queryLen: number, accounted: ReadonlyArray<[number, number]>): Array<[number, number]>;
 /** A human-readable label for the query bytes a mechanism's `accounted`
  *  spans leave unexplained — purely diagnostic (Task 2's negative evidence):
  *  it never changes a candidate's weight, only what the rationale trace

package/dist/src/mind/rationale.js

@@ -19,43 +19,17 @@
 // out into a ranked list of hits.  So a step's `inputs` and `outputs` are each a
 // VECTOR — an ordered list of {@link RationaleItem}s, one per element — and the
 // fan-out / fan-in is visible in their lengths.
+import { unexplainedSpans } from "./derivation.js";
 /** Decode bytes to text for display, dropping the NUL padding the encoder uses
  *  (the same cleanup {@link Mind.respondText} does for its result). */
 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. */
-export function unexplainedSpans(queryLen, accounted) {
-    const sorted = accounted
-        .map(([s, e]) => [Math.max(0, s), Math.min(queryLen, e)])
-        .filter(([s, e]) => e > s)
-        .sort((a, b) => a[0] - b[0]);
-    const gaps = [];
-    let reach = 0;
-    for (const [s, e] of sorted) {
-        if (s > reach)
-            gaps.push([reach, s]);
-        if (e > reach)
-            reach = e;
-    }
-    if (reach < queryLen)
-        gaps.push([reach, queryLen]);
-    return gaps;
-}
+// THE SPAN ALGEBRA LIVES IN derivation.ts.  `unaccountedBytes` and
+// `unexplainedSpans` are the closure law's vocabulary — gap arithmetic over the
+// asker's own bytes — and they moved to the layer that owns the law, so they
+// have ONE home and are no longer asked of the tracer.  This module keeps the
+// inference TOLD as it happens, and reads the gaps only to render a label.
 /** A human-readable label for the query bytes a mechanism's `accounted`
  *  spans leave unexplained — purely diagnostic (Task 2's negative evidence):
  *  it never changes a candidate's weight, only what the rationale trace