@hviana/sema 0.8.2 → 0.8.5

package/src/mind/mechanisms/recall.ts

@@ -24,7 +24,7 @@ import {
   voicesDisplacedFiller,
 } from "../match.js";
 import { CONCEPT, STEP } from "../graph-search.js";
-import { unexplainedLabel } from "../rationale.js";
+import { restates as lawRestates } from "../derivation.js";
 import type { PipelineMechanism, Precomputed } from "../pipeline-mechanism.js";
 import { rItem, rNode } from "../trace.js";
 import { substitutionBridge } from "../bridge.js";
@@ -35,7 +35,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;
@@ -71,7 +70,6 @@ export async function recallByResonance(
       echoed,
       accounted,
       moves,
-      unexplained: unexplainedLabel(query, accounted),
       ...(complete ? { complete } : {}),
     };
   };
@@ -156,7 +154,7 @@ export async function recallByResonance(
       // 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,
@@ -196,10 +194,11 @@ export async function recallByResonance(
   // 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;
+  // 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: Uint8Array): boolean =>
-    bytesEqual(b, query) ||
-    (ctx.canon !== null && bytesEqual(ctx.canon(b), qKey));
+    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) {
@@ -276,9 +275,36 @@ export async function recallByResonance(
     // consensus", while breadth is the SCALE-INVARIANT reading — "a point whose
     // breadth clears `dominates` (> half the query's regions corroborate it) is
     // real consensus; one that does not is a coincidental single-region echo".
-    // Attention.peak's contract makes the same point from the other side:
-    // comparing a POOLED SUM against a floor that prices ONE region's evidence
-    // is a dimensional error.
+    // THIS USED TO CLAIM A DIMENSIONAL ERROR, AND THAT CLAIM WAS FALSE.
+    // It read: "comparing a POOLED SUM against a floor that prices ONE region's
+    // evidence is a dimensional error."  `consensusFloor` is not priced for one
+    // region: thresholds.md §2 derives it as the POOLED-vote significance floor —
+    // "each region contributes at most ln(N/c) <= ln(N); ln(N)+1/2 demands ..." —
+    // and attention.ts says the same where it builds the vote ("the scale
+    // consensusFloor is derived for").  The comparison is in ONE dimension, and
+    // it is so because the climb WEIGHTS BY IDF: `wf` in voteRegions is
+    // `direct ? df : combined ? idf + df : idf`, and the engine only ever runs the
+    // last one (DFMode's default "inverse", the mode every non-test caller uses —
+    // `direct` and `combined` are exercised by test/24 and test/27 only, and
+    // test/24 pins that their votes DO differ).  In those two the sum would leave
+    // the floor's dimension and the floor would need re-deriving.
+    //
+    // What the OR below is really for is SCALE, not dimension (the paragraph
+    // above says it): a vote that clears ln(N)+1/2 means "strong" on a small store
+    // and "weak" on a large one for the same genuine consensus, so the
+    // scale-invariant breadth reading is added beside it.
+    //
+    // AND THE PREMISE IS IDF.  The deviation in the other two weighting modes is
+    // TWO-SIDED and DERIVED: `direct` DEFLATES a region (ln(1+c) < ln(N/c) for
+    // small c) and `combined` INFLATES it (ln N + ln(1+1/c)), both by at most
+    // `ln 2` — see `geometry.ts`'s `consensusFloor`, where the bound lives.
+    // MEASURED on 8 anchors across 5 queries, running the same climb in all
+    // three modes: ZERO gate inversions — every anchor's `vote >= floor` verdict
+    // is the same in `inverse`, `direct` and `combined`, even where the readings
+    // straddle the floor on opposite sides (#148: inverse 3.39, combined 4.71
+    // above it, direct 1.31 below).  Pinned by test/55's test 20.  The bar is not
+    // re-derived for those modes because nothing reachable needs it; the premise
+    // is IDF, and that is now written where the gate reads it.
     //
     // Measured on the 15.7M-node store (N=325,615, so the old floor was 13.19).
     // The absolute vote cannot separate right from wrong at this scale, and the
@@ -348,7 +374,7 @@ export async function recallByResonance(
     if (
       forest.length > 0 &&
       !allWindowsAreScaffolding(ctx, query) &&
-      (forest[0].vote >= minVote ||
+      (forest[0].idfVote >= minVote || // the IDF sum: the bar's own quantity
         (dominates(forest[0].breadth, 1) && forest[0].peak > Math.LN2))
     ) {
       const g = await project(ctx, forest[0].anchor, queryGist);
@@ -381,7 +407,7 @@ export async function recallByResonance(
       // — 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",
@@ -600,8 +626,8 @@ export const recallMechanism: PipelineMechanism = {
       bytes: r.bytes,
       accounted: r.accounted,
       moves: r.moves,
-      unexplained: r.unexplained,
       provenance: r.echoed ? "recall-echo" : "recall",
+      used: new Set<number>(),
       ...(r.complete ? { complete: true } : {}),
     }];
   },

package/src/mind/mechanisms/reference.ts

@@ -39,7 +39,7 @@ import type { FrameInstance } from "../match.js";
 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 { restates } from "../derivation.js";
 import { STEP } from "../graph-search.js";
 import type {
   MechanismResult,
@@ -231,7 +231,7 @@ export async function bindReference(
   if (bytes.length === 0) 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);
@@ -278,7 +278,6 @@ export async function bindReference(
     // 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/src/mind/mind.ts

@@ -16,7 +16,6 @@ import type { CorpusPair, CorpusResult } from "./corpus.js";
 import { Alphabet } from "../alphabet.js";
 import {
   bytesToTree,
-  contentBoundaries,
   contentFoldIncremental,
   Grid,
   gridToTree,
@@ -24,6 +23,7 @@ import {
   reachThreshold,
   stackGrids,
 } from "../geometry.js";
+import { keyEnds } from "./canonical.js";
 import type { ContentFold } from "../geometry.js";
 import { BoundedMap, type Store } from "../store.js";
 import { SQliteStore } from "../store-sqlite.js";
@@ -244,6 +244,8 @@ export interface MindOptions {
   seed?: number;
   recallQueryK?: number;
   haloQueryK?: number;
+  /** Branch nodes the pivot sweep may probe — see {@link MindConfig}. */
+  pivotProbeK?: number;
   /** Items one rationale step may itemise — see {@link MindConfig}. */
   rationaleSampleK?: number;
   /** Corpus-reading capacities and budgets — see {@link MindConfig}. */
@@ -443,9 +445,9 @@ export class Mind implements MindContext {
    *  with the most distributional evidence (highest `prevOf` count — the
    *  structural manifestation of its halo).  When evidence is equal the
    *  first-inserted edge wins. */
-  /** See {@link GraphSearchHost.contentCuts}. */
-  contentCuts(bytes: Uint8Array): readonly number[] {
-    return contentBoundaries(this.space, bytes);
+  /** See {@link GraphSearchHost.contentKeyEnds}. */
+  contentKeyEnds(prefix: Uint8Array, tail: Uint8Array): readonly number[] {
+    return keyEnds(this, prefix, tail);
   }
 
   chooseNext(node: number): number | undefined {

package/src/mind/pipeline-mechanism.ts

@@ -675,10 +675,14 @@ export interface MechanismResult {
   bytes: Uint8Array;
   accounted: Array<[number, number]>;
   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`/`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/src/mind/pipeline.ts

@@ -15,8 +15,17 @@ import type { ComputedSpan } from "../extension.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,
+  type DerivationState,
+  remainderOf,
+  type Span,
+  unaccountedBytes,
+  unexplainedSpans,
+  windowOf,
+} from "./derivation.js";
 import { rItem } from "./trace.js";
+import { unexplainedLabel } from "./rationale.js";
 import { hubBound } from "./traverse.js";
 import { type PipelineMechanism, Precomputed } from "./pipeline-mechanism.js";
 import { coverMechanism } from "./mechanisms/cover.js";
@@ -244,7 +253,6 @@ export async function think(
     weight: number;
     used?: ReadonlySet<number>;
     accounted: ReadonlyArray<[number, number]>;
-    unexplained: string;
     complete?: boolean;
     /** Bytes of this candidate's ANSWER that came from spans nothing
      *  recognised — query words carried through verbatim (see
@@ -253,8 +261,7 @@ export async function think(
   }
   const grade = (w: number) => Math.floor(w / STEP);
   const unaccounted = (spans: ReadonlyArray<[number, number]>): number =>
-    unexplainedSpans(query.length, spans)
-      .reduce((sum, [s, e]) => sum + (e - s), 0);
+    unaccountedBytes(unexplainedSpans(query.length, spans));
   const weigh = (
     accounted: ReadonlyArray<[number, number]>,
     moves: number,
@@ -394,14 +401,16 @@ export async function think(
       ? 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,
       });
@@ -434,14 +443,21 @@ export async function think(
       : null;
     ctx.trace?.step(
       "decideGrounding",
-      candidates.map((c) =>
-        rItem(
+      // 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)}${
-            c.unexplained ? `, unexplained: "${c.unexplained}"` : ""
+            label ? `, unexplained: "${label}"` : ""
           })`,
-        )
-      ),
+        );
+      }),
       decided ? [rItem(decided.bytes, decided.provenance)] : [],
       "the lightest grounding derivation wins — every mechanism weighed in the one cost ladder",
       undefined,
@@ -504,14 +520,65 @@ export async function think(
   }
   const answer: Uint8Array = decided.bytes;
   const provenance = decided.provenance as Provenance;
-  const castUsed: ReadonlySet<number> = decided.used ?? new Set();
+  const declaredUsed = decided.used;
 
-  // ── Post-grounding, gated by provenance ──────────────────────────────
-  const preConsumed = provenance === "cast" || provenance === "join"
-    ? castUsed
-    : provenance === "recall" || provenance === "recall-echo"
-    ? new Set<number>()
-    : new Set(recognise(ctx, answer).sites.map((s) => s.payload));
+  // ── 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: Array<[number, number]> = [
+    ...decided.accounted,
+    ...pre.computed.map((u): [number, number] => [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): [number, number] => [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: DerivationState = {
+    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
@@ -540,11 +607,41 @@ export async function think(
   // `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
@@ -560,25 +657,25 @@ export async function think(
         "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: Array<[number, number]> = [
-    ...decided.accounted,
-    ...pre.computed.map((u): [number, number] => [u.i, u.j]),
-  ];
-  const uncovered = unexplainedSpans(query.length, explained)
-    .filter(([a, b]) => b - a >= ctx.space.maxGroup);
-  const reasoned = decided.complete ? answer : meter
+  // 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, answer, preConsumed, pre, voiced, uncovered),
+      () => reason(ctx, query, state, preConsumed, pre, voiced),
     )
-    : await reason(ctx, query, answer, preConsumed, pre, voiced, uncovered);
+    : 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
@@ -596,7 +693,15 @@ export async function think(
   // 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
@@ -606,8 +711,8 @@ export async function think(
   // `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]) =>
+  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
@@ -617,13 +722,10 @@ export async function think(
   // 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: ReadonlyArray<[number, number]> =
-    decided.accounted.length > 0
-      ? decided.accounted
-      : pre.computed.map((u): [number, number] => [u.i, u.j]);
-  const fused = remainder < ctx.space.maxGroup
-    ? reasoned
-    : meter
+  const primarySpans: ReadonlyArray<Span> = state.accounted.length > 0
+    ? state.accounted
+    : pre.computed.map((u): [number, number] => [u.i, u.j]);
+  const fused = closed(state) ? reasoned : meter
     ? await meter.time(
       "fuse",
       () => fuseAttention(ctx, query, reasoned, pre, unclimbed, primarySpans),
@@ -638,8 +740,14 @@ export async function think(
     );
 
   done(
-    fused,
-    "grounded, reasoned forward, fused across points of attention",
+    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, provenance };
+  return { bytes: fused.product, provenance };
 }

package/src/mind/primitives.ts

@@ -338,7 +338,15 @@ export function canonResolve(
     // 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)

package/src/mind/rationale.ts

@@ -21,6 +21,7 @@
 // fan-out / fan-in is visible in their lengths.
 
 import type { Vec } from "../vec.js";
+import { unexplainedSpans } from "./derivation.js";
 
 /** One element of a step's input or output vector.
  *
@@ -49,6 +50,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.
@@ -101,28 +113,11 @@ export function decodeText(bytes: Uint8Array): string {
   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: number,
-  accounted: ReadonlyArray<[number, number]>,
-): Array<[number, number]> {
-  const sorted = accounted
-    .map(([s, e]) =>
-      [Math.max(0, s), Math.min(queryLen, e)] as [number, number]
-    )
-    .filter(([s, e]) => e > s)
-    .sort((a, b) => a[0] - b[0]);
-  const gaps: Array<[number, number]> = [];
-  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):
@@ -264,7 +259,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: string,