@hviana/sema 0.8.3 → 0.8.5

package/src/mind/reasoning.ts

@@ -10,22 +10,18 @@ import { resolve } from "./primitives.js";
 import { corpusN, hubBound } from "./traverse.js";
 import { containsSpan, follow, haloSiblings, project } from "./match.js";
 import { joinWithBridge, pivotInto } from "./resonance.js";
+import { admissible, advance, type Continuation } from "./derivation.js";
 import type { Precomputed } from "./pipeline-mechanism.js";
-import { type Rationale, 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: Uint8Array, bytes: Uint8Array): boolean {
-  return bytes.length < query.length && indexOf(query, bytes, 0) >= 0;
-}
+import { type Rationale } from "./rationale.js";
+import {
+  closure,
+  type DerivationState,
+  type Offer,
+  restates,
+  type Span,
+  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,
@@ -42,31 +38,19 @@ export function restatesQuery(query: Uint8Array, bytes: Uint8Array): boolean {
  *  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 async function reason(
   ctx: MindContext,
   query: Uint8Array,
-  answer: Uint8Array,
+  d0: DerivationState,
   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> {
+): Promise<DerivationState> {
+  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
@@ -74,7 +58,7 @@ export async function reason(
   // 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
@@ -94,7 +78,7 @@ export async function reason(
   // 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:
   //
@@ -134,7 +118,7 @@ export async function reason(
     ? 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<number>();
@@ -176,41 +160,66 @@ export async function reason(
     await preconsume();
   }
 
-  let cur = answer;
-  const qv = pre.guide; // the response-wide guide IS the query's gist
-  let t: ReturnType<Rationale["enter"]> | undefined;
-  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: Array<[number, number]> = [];
-  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: ReturnType<Rationale["enter"]> | undefined;
+  // 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:
+    | { kind: "absorb"; cur: Uint8Array; curId: number | null; fwd: Uint8Array }
+    | { kind: "pivot"; cur: Uint8Array; pivot: number; fc: Uint8Array }
+    | null = null;
+
+  const offer: 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))
@@ -220,133 +229,122 @@ export async function reason(
       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;
-
+    if (pivot === null) 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: [number, number] | undefined;
-      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 (
+      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 (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);
+      const p = pending;
+      pending = null;
+      if (p === null) return;
+      t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
+      if (p.kind === "absorb") {
         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`,
+          "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",
         );
-        break;
       }
-    }
-    if (ctx.meter) ctx.meter.pivotSteps++;
-    t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
-    ctx.trace?.step(
-      "pivotStep",
-      [rItem(cur, "answer"), rNode(ctx, pivot, "pivot")],
-      [rItem(fc, "answer", resolve(ctx, fc) ?? undefined)],
-      "pivot on the shared span this answer contains, then step forward across that fact",
-    );
-    cur = fc;
-    steps++;
-  }
+    },
+    (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.
+    [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).
@@ -356,7 +354,7 @@ export async function reason(
 export async function fuseAttention(
   ctx: MindContext,
   query: Uint8Array,
-  primary: 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
@@ -371,8 +369,13 @@ export async function fuseAttention(
    *  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> {
+  // 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
@@ -380,7 +383,7 @@ export async function fuseAttention(
   // byte run): the old sparse-subsequence test was trivially satisfied by
   // short answers over long queries, silently starving multi-topic queries
   // of fusion.
-  if (containsSpan(ctx, query, primary)) return primary;
+  if (containsSpan(ctx, query, 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
@@ -423,7 +426,7 @@ export async function fuseAttention(
   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
@@ -506,7 +509,13 @@ export async function fuseAttention(
     // the root resonates.
     const cont = await follow(ctx, root.anchor, qv);
     if (
-      cont !== null && cont.length > 0 && indexOf(query, cont, root.end) >= 0
+      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",
@@ -526,7 +535,7 @@ export async function fuseAttention(
       [rItem(primary, "answer")],
       "no further independent point grounded",
     );
-    return primary;
+    return state;
   }
 
   pieces.sort((a, b) => a.start - b.start);
@@ -543,5 +552,26 @@ export async function fuseAttention(
   // THE FACT IS THE FUSED ANSWER, not the call: every early return above hands
   // back `primary` untouched.  Untraced on purpose (meter.ts contract 1).
   if (ctx.meter) ctx.meter.fuseRuns++;
-  return out;
+  // 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: Continuation = {
+    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/src/mind/types.ts

@@ -34,6 +34,7 @@ export interface DepositCacheEntry {
   content: ContentFold;
 }
 import { bytesEqual, concatBytes, indexOf } from "../bytes.js";
+import { restates } from "./derivation.js";
 import { dominates } from "../geometry.js";
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -486,11 +487,13 @@ export function segRestatesQuery(
   W: number,
 ): boolean {
   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