@hviana/sema 0.8.2 → 0.8.5

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 { 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";
@@ -124,8 +125,7 @@ export async function think(ctx, query, mechs) {
     // (meter.md); the trace already represents structure.
     const pre = new Precomputed(ctx, query, rec, computed, ctx._edgeGuide);
     const grade = (w) => Math.floor(w / STEP);
-    const unaccounted = (spans) => unexplainedSpans(query.length, spans)
-        .reduce((sum, [s, e]) => sum + (e - s), 0);
+    const unaccounted = (spans) => unaccountedBytes(unexplainedSpans(query.length, spans));
     const weigh = (accounted, moves) => moves + PASS * unaccounted(accounted);
     const candidates = [];
     let best = null;
@@ -243,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,
             });
@@ -281,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,13 +329,57 @@ export async function think(ctx, query, mechs) {
     }
     const answer = decided.bytes;
     const provenance = decided.provenance;
-    const castUsed = decided.used ?? new Set();
-    // ── Post-grounding, gated by provenance ──────────────────────────────
-    const preConsumed = provenance === "cast" || provenance === "join"
-        ? castUsed
-        : provenance === "recall" || provenance === "recall-echo"
-            ? new Set()
-            : new Set(recognise(ctx, answer).sites.map((s) => s.payload));
+    const declaredUsed = decided.used;
+    // ── 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
     // already a trained form's own continuation, reached through an identity
     // claim about the query, so a multi-hop pivot could only chain past the
@@ -352,9 +408,32 @@ export async function think(ctx, query, mechs) {
     // `preConsumed` is derived by re-recognising the answer — "everything in
     // it", not "what it voiced" — and a containment rule over that would
     // suppress every pivot the answer legitimately contains.
-    const voiced = (provenance === "cast" || provenance === "join")
-        ? [...castUsed].flatMap((id) => ctx.store.nextFirst(id, hubBound(ctx)).map((n) => read(ctx, n)))
-        : [];
+    const 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 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, {
+        version: 1,
+        provenance,
+        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
     // rationale must be able to see that the chain stopped because the mechanism
@@ -365,22 +444,22 @@ 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);
-    const reasoned = decided.complete ? answer : meter
-        ? await meter.time("reason", () => reason(ctx, query, answer, preConsumed, pre, voiced, uncovered))
-        : await reason(ctx, query, answer, preConsumed, pre, voiced, uncovered);
+    // PUBLISHED, NOT RECOMPUTED: the same `uncovered` the gates below read.  A
+    // write-only accounting (meter contract 1), so the number that licenses an
+    // extension or a fusion stops being invisible.
+    if (meter) {
+        meter.postGroundingRemainderSpans += uncovered.length;
+        meter.postGroundingRemainderBytes += unaccountedBytes(uncovered);
+    }
+    // THE 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, 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
@@ -397,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
@@ -407,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
@@ -416,14 +503,19 @@ 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, "grounded, reasoned forward, fused across points of attention");
-    return { bytes: fused, provenance };
+    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:
+    // "What is the capital of France famous for" fuses 0 times).  The fusion is
+    // reported by `fuseAttention`'s own `done` when it happens — the layer that
+    // did the work is the layer that says so.
+    "grounded, reasoned forward");
+    return { bytes: fused.product, provenance };
 }

package/dist/src/mind/primitives.js

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

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

@@ -26,6 +26,17 @@ export interface RationaleItem {
      *  caller asked to carry it (off by default — a D-float array per item would
      *  bury the reasoning it is meant to explain). */
     v?: Vec;
+    /** The element's OWN bytes, attached BY REFERENCE when the step was built from
+     *  bytes (a `rationale.ts` item made from a node carries none: read it back
+     *  through `node`).  `text` is a RENDERING and cannot stand in for them — it
+     *  decodes UTF-8 and DROPS NUL bytes, so a key containing one is unrecoverable
+     *  from it, which is exactly how a join refusal (`deriveThroughMiss`) became
+     *  impossible to test exactly without re-encoding.  Treat as READ-ONLY: the
+     *  array belongs to the caller (and may be a view into the query).
+     *
+     *  Costs nothing when nothing inspects: items exist only while a rationale
+     *  sink is attached, and this holds a reference rather than a copy. */
+    bytes?: Uint8Array;
 }
 /** A single completed act of inference — one mechanism, run once.
  *
@@ -72,10 +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 `[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
@@ -133,7 +140,16 @@ export declare class Rationale {
      *  now; the matching {@link Scope.done} supplies the outputs when it finishes.
      *  `deps` overrides the default data-flow edge (previous sibling / parent). */
     enter(name: string, inputs: RationaleItem[], deps?: number[]): Scope;
-    /** Record a mechanism that has no sub-steps — its inputs and outputs are both
+    /** WHY THIS NAME IS A FREE STRING, when the derivation's moves are a closed
+     *  union: a mechanism name is WRITTEN and DISPLAYED, and it COMPOSES with
+     *  the nesting — `mechanism` is the whole path (`["respond", "think",
+     *  "recognise"]`), which no fixed union can express.  Nothing branches on it:
+     *  `nothing here drives the inference; it only WITNESSES it`.  A vocabulary
+     *  that is only witnessed needs no union; one that is read does
+     *  (`DerivationMove`, in graph-search.ts).  The asymmetry is the design, not
+     *  a drift.
+     *
+     *  Record a mechanism that has no sub-steps — its inputs and outputs are both
      *  known at the call site.  Returns its index, for a later step to depend on. */
     step(name: string, inputs: RationaleItem[], outputs: RationaleItem[], note?: string, deps?: number[], data?: unknown): number;
 }

package/dist/src/mind/rationale.js

@@ -19,31 +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 `[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
@@ -151,7 +137,16 @@ export class Rationale {
             },
         };
     }
-    /** Record a mechanism that has no sub-steps — its inputs and outputs are both
+    /** WHY THIS NAME IS A FREE STRING, when the derivation's moves are a closed
+     *  union: a mechanism name is WRITTEN and DISPLAYED, and it COMPOSES with
+     *  the nesting — `mechanism` is the whole path (`["respond", "think",
+     *  "recognise"]`), which no fixed union can express.  Nothing branches on it:
+     *  `nothing here drives the inference; it only WITNESSES it`.  A vocabulary
+     *  that is only witnessed needs no union; one that is read does
+     *  (`DerivationMove`, in graph-search.ts).  The asymmetry is the design, not
+     *  a drift.
+     *
+     *  Record a mechanism that has no sub-steps — its inputs and outputs are both
      *  known at the call site.  Returns its index, for a later step to depend on. */
     step(name, inputs, outputs, note, deps, data) {
         const mechanism = this.path(name);

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

@@ -1,35 +1,27 @@
 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.  Repeats up
- *  to `cfg.recallQueryK` hops.  `preConsumed` carries node ids already
+ *  then follows the pivot's continuation to the next fact.  **The chain ends
+ *  when it STOPS, never when a count runs out**: every exit is a refusal (no
+ *  pivot, no forward step, no question material carried) and the walk is bounded
+ *  by the material and the graph — `consumed` refuses to revisit a node.  There
+ *  is no hop allowance, so this doc deliberately names no `cfg` capacity: the
+ *  cover prices every hop at `STEP` and lets the search decide the depth, and a
+ *  second count here would be a second decision about the same thing.
+ *  `preConsumed` carries node ids already
  *  spoken for by the grounding stage (cover/extract/CAST).  `voiced` carries
  *  the BYTES of the anchors a mechanism declared it voiced (its `used` set),
  *  when it declared one — see the pivot's own containment rule.  `pre` is the
  *  response's shared pre-computation — the post-grounding stages read the
  *  same container the mechanisms did. */
-export declare function reason(ctx: MindContext, query: Uint8Array, answer: Uint8Array, preConsumed: ReadonlySet<number>, pre: Precomputed, voiced?: readonly Uint8Array[], 
-/** 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<Uint8Array>;
+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:
@@ -43,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>;