@hviana/sema 0.8.2 → 0.8.3

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

@@ -23,6 +23,22 @@ export declare function leafIdRun(ctx: MindContext, bytes: Uint8Array, from: num
  *  what a partial prefix means (deposit only interns the whole-stream flat
  *  branch when the prefix covers everything). */
 export declare function leafIdPrefix(ctx: MindContext, bytes: Uint8Array): number[];
+/** Which prefixes of `prefix ‖ tail` are STORED NODES — as lengths in the
+ *  tail's own coordinates, ascending, excluding the empty one.  This is the
+ *  candidate set a rule needs to join an already-stored prefix to a suffix it
+ *  has not stored: a key names a relation exactly when `prefix ‖ tail[0..p]` IS
+ *  a node, and a key can end strictly inside the tail without sitting on any
+ *  fold boundary (a stored member's end is the end of ITS OWN stream, and the
+ *  fold never emits a cut at a stream's end).  Measured: "stockholm mayor"
+ *  exists, leads on, and its boundary 6 is in neither the tail's cuts nor the
+ *  concatenation's.
+ *
+ *  ONE cheap content-addressed probe per offset — `leafIdPrefix` walks the bytes
+ *  once (a point probe each), `findBranch` hashes the growing kid run — and NO
+ *  `resolve`, which is what keeps this off the O(suffix) vector folds the
+ *  recognition path pays.  It stops at the first byte that was never interned,
+ *  which costs nothing real: a stored key's bytes are interned by construction. */
+export declare function keyEnds(ctx: MindContext, prefix: Uint8Array, tail: Uint8Array): number[];
 /** The canonical W-window node ids of a byte stream, offset → id — the
  *  CONTENT-ADDRESSED IDENTITY of every W-sized slice, under which any content
  *  two deposits share IS the same node (hash-consing paid the comparison at

package/dist/src/mind/canonical.js

@@ -70,6 +70,47 @@ export function leafIdPrefix(ctx, bytes) {
     }
     return ids;
 }
+/** Which prefixes of `prefix ‖ tail` are STORED NODES — as lengths in the
+ *  tail's own coordinates, ascending, excluding the empty one.  This is the
+ *  candidate set a rule needs to join an already-stored prefix to a suffix it
+ *  has not stored: a key names a relation exactly when `prefix ‖ tail[0..p]` IS
+ *  a node, and a key can end strictly inside the tail without sitting on any
+ *  fold boundary (a stored member's end is the end of ITS OWN stream, and the
+ *  fold never emits a cut at a stream's end).  Measured: "stockholm mayor"
+ *  exists, leads on, and its boundary 6 is in neither the tail's cuts nor the
+ *  concatenation's.
+ *
+ *  ONE cheap content-addressed probe per offset — `leafIdPrefix` walks the bytes
+ *  once (a point probe each), `findBranch` hashes the growing kid run — and NO
+ *  `resolve`, which is what keeps this off the O(suffix) vector folds the
+ *  recognition path pays.  It stops at the first byte that was never interned,
+ *  which costs nothing real: a stored key's bytes are interned by construction. */
+export function keyEnds(ctx, prefix, tail) {
+    if (prefix.length === 0 || tail.length === 0)
+        return [];
+    const joined = new Uint8Array(prefix.length + tail.length);
+    joined.set(prefix, 0);
+    joined.set(tail, prefix.length);
+    const ids = leafIdPrefix(ctx, joined);
+    if (ids.length < prefix.length)
+        return [];
+    const ends = [];
+    // The kid run GROWS by one id per offset; `findBranch` wants an array, so the
+    // run is built once and pushed into, never re-sliced.  Re-slicing
+    // `ids.slice(0, prefix.length + p)` per offset made this O(|tail| ·
+    // (|prefix| + |tail|)) — quadratic in the tail, where the learning path this
+    // follows slices a run that SHRINKS.  Same ends, linear copying.
+    const run = ids.slice(0, prefix.length);
+    // The loop ENDS at the first byte that was never interned (`ids.length`):
+    // every later prefix contains it, so none of them can be a node either — this
+    // is where the scan stops, not a silent truncation of the answer.
+    for (let p = 1; prefix.length + p <= ids.length; p++) {
+        run.push(ids[prefix.length + p - 1]);
+        if (ctx.store.findBranch(run) !== null)
+            ends.push(p);
+    }
+    return ends;
+}
 /** The canonical W-window node ids of a byte stream, offset → id — the
  *  CONTENT-ADDRESSED IDENTITY of every W-sized slice, under which any content
  *  two deposits share IS the same node (hash-consing paid the comparison at

package/dist/src/mind/graph-search.js

@@ -868,6 +868,8 @@ export class GraphSearch {
             // concepts/connectors either (those need the caller's async
             // pre-resolution) — the recursion follows edges and fusion, which is what
             // a deeper rewrite chain is made of.
+            if (this.host.meter)
+                this.host.meter.recompletes++;
             const rec = this.host.recogniseSpan(bytes);
             const kids = new Set(nrec.kids);
             // THE NODE'S OWN KIDS ARE SITES BY STRUCTURE — recognition cannot be the
@@ -1100,20 +1102,37 @@ export class GraphSearch {
             // duplicate read and a branch that could never be taken.
             let next = null;
             let keyBytes = c.bytes;
-            // THE PREFIX ENDS ARE THE TAIL'S OWN FOLD BOUNDARIES, not every byte
-            // length.  The key is `entity + prefix`, and the prefix that names a
-            // stored relation ends where the fold cuts: measured over four join-firing
-            // queries, 5 of 5 accepted keys ended on a boundary (or the tail's end)
-            // while the byte-by-byte scan spent 153 probes where 14 boundaries would
-            // do.  Same criterion — resolves AND leads — same shortest-first order, so
-            // the answer is the same one the enumeration found; only the candidates
-            // come from the structure instead of from the byte count.  A host with no
-            // boundary rule falls back to the enumeration.
-            const cuts = this.host.contentCuts?.(tail);
-            const ends = cuts && cuts.length > 0
-                ? [...cuts.filter((c) => c > 0 && c < tail.length), tail.length]
-                : Array.from({ length: tail.length }, (_, i) => i + 1);
-            for (const len of ends) {
+            // THE CANDIDATE ENDS ARE THE PREFIXES THAT ARE STORED NODES, ASCENDING.
+            // The key is `entity + prefix`, and it names a relation exactly when that
+            // concatenation IS a node — so the ends come from a content-addressed
+            // probe per offset (the host's `contentKeyEnds`, the learning path's own
+            // mechanism: one leaf walk plus one `findBranch` per offset, no `resolve`),
+            // never from the fold's boundaries.  A boundary is not a proxy: a stored
+            // member's end is the end of ITS OWN stream, and the fold never cuts at a
+            // stream's end — measured, "stockholm mayor" exists, leads on to the mayor
+            // fact, and its boundary 6 sits in neither the tail's cuts ([4,7]) nor the
+            // concatenation's.  Filtering the scan by "is this a node?" cannot change
+            // the winner: a position that is not a node cannot resolve, so skipping it
+            // is invisible; and the order stays SHORTEST FIRST, which is a semantic
+            // law, not an optimisation (test/106, test/108 pin it).
+            //
+            // A host that cannot answer falls back to every prefix: exact and
+            // complete, at a `resolve` per offset.  A host that CAN answer is
+            // authoritative even when it answers "none" — if no prefix is a node then
+            // no key exists to resolve, so enumerating would only pay nulls.  (A key
+            // reachable through the CANONICAL equivalence alone and ending off every
+            // node end is therefore not tried here; that dimension is unreachable on
+            // this path by construction and is not part of the exact-key law.)
+            const ends = this.host.contentKeyEnds?.(c.bytes, tail);
+            const candidateEnds = function* () {
+                if (ends !== undefined) {
+                    yield* ends;
+                    return;
+                }
+                for (let p = 1; p <= tail.length; p++)
+                    yield p;
+            };
+            for (const len of candidateEnds()) {
                 keyBytes = concat2(c.bytes, tail.subarray(0, len));
                 const k = this.host.resolve(keyBytes) ??
                     this.host.canonResolve?.(keyBytes) ??

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

@@ -200,7 +200,7 @@ export declare function frameSlots(ctx: MindContext, query: Uint8Array, cand: Ui
  *  ANCHOR that the query displaced.  Neither implies the other, and the
  *  observed failures pass the restatement guard cleanly.
  *
- *  Three conditions, all byte-exact and all necessary:
+ *  Four conditions, all byte-exact and all necessary:
  *
  *  1. the query and the anchor must be ONE STRUCTURE — what they share has to
  *     dominate the query, or the query is not a variant of the anchor at all

package/dist/src/mind/match.js

@@ -546,7 +546,7 @@ export function frameSlots(ctx, query, cand, id) {
  *  ANCHOR that the query displaced.  Neither implies the other, and the
  *  observed failures pass the restatement guard cleanly.
  *
- *  Three conditions, all byte-exact and all necessary:
+ *  Four conditions, all byte-exact and all necessary:
  *
  *  1. the query and the anchor must be ONE STRUCTURE — what they share has to
  *     dominate the query, or the query is not a variant of the anchor at all
@@ -631,8 +631,10 @@ export function substituteAll(hay, pairs) {
     if (usable.length === 0)
         return hay;
     // Longest needle first, so a needle that is a prefix of another can never
-    // pre-empt it.  Ties cannot arise: an instance whose fillers are not
-    // pairwise distinct is refused by frameSlots.
+    // pre-empt it.  Ties cannot arise: a consumer that VOICES checks the
+    // fillers pairwise with `distinct` and refuses such an instance itself —
+    // `frameSlots` reports and does not judge (see its own doc), so the refusal
+    // lives with the mechanism that needs it, not here.
     const order = [...usable].sort((a, b) => b.needle.length - a.needle.length);
     const out = [];
     let i = 0;

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

@@ -731,7 +731,7 @@ export async function counterfactualTransfer(ctx, query, pre) {
     // grounds") — fine for ORIENTING mechanisms, not for voicing learnt
     // content the query never asked about.  Computed once here; both the
     // hub fallback below and the comparison gate consume it.
-    const rootTrusted = roots.some((r) => r.vote >= consensusFloor(corpusN(ctx)));
+    const rootTrusted = roots.some((r) => r.idfVote >= consensusFloor(corpusN(ctx))); // the IDF sum: the bar's own quantity
     // The context that ESTABLISHES a filler — the same reverse context, under
     // the same naming test, `seatOfNode` uses to VOICE an analog (a predecessor
     // whose bytes CONTAIN the node's: it names or describes it, rather than

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

@@ -98,6 +98,30 @@ export async function confluenceJoin(ctx, query, pre) {
     // constraints).  Shard-bound streams are no constraints, and their meets
     // are connective debris (". Sure,", "ngul" — observed).
     const bindsAConstituent = (cover) => cover.some(([cs, ce]) => ce - cs >= 2 * W);
+    // THE VOTE ENTERS AS ORDER, NEVER AS A BAR.  This is the only one of the
+    // climb's four consumers (recall, fuseAttention, cast, here) that uses the
+    // evidence's MAGNITUDE without a floor, and it is legitimate by construction:
+    // `ranked` answers "which anchor is stronger" — a question about votes, so the
+    // comparison stays within one dimension — and the vote is otherwise only
+    // REPORTED (Stream.vote travels to the rationale's constraint nodes).  What
+    // actually SELECTS a constraint is byte-structural and never the magnitude: a
+    // run of at least 2W (`bindsAConstituent`, with its accidental-sharing
+    // counter-examples above), disjoint covers (`disjoint`), and scaffolding never
+    // binds at all (`dominates(reachOf(…), N)`).  The MEET such a stream may
+    // produce is selected the same way: a span shorter than 2W is rejected, and
+    // the winner is the one with the smallest `reach` (ties broken by the longer
+    // span) — a corpus quantity and bytes, never the vote, which appears only in
+    // the trace item.
+    // binds at all (`dominates(reachOf(…), N)`).  The only cut in this loop is a
+    // BUDGET, and it is measured: stopping the scan at 2W anchors saves 50-70% of
+    // confluence's cost on non-conjunctive queries while preserving every genuinely
+    // conjunctive case, whose top anchors ARE its constraints.
+    // MEASURED (this goal, on THIS file's own conjunctive fixture): the two
+    // streams appear at ranks 1 and 4 against a budget of 2W = 8, on a query whose
+    // `ranked` is 9 — so the cut IS live (it would have returned null at the 8th
+    // anchor) and it does NOT prune the case it exists to protect.  The other
+    // conjunctive fixture (the Leonardo one) finds them at ranks 0 and 1.  Scope:
+    // these are the repo's conjunctive fixtures, and no more.
     const streams = [];
     const rankedCapped = ranked.length > pre.k ? ranked.slice(0, pre.k) : ranked;
     // CONJUNCTIVITY EARLY-EXIT: a conjunctive query's top-ranked anchors

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

@@ -194,9 +194,36 @@ export async function recallByResonance(ctx, query, pre) {
         // 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
@@ -265,7 +292,7 @@ export async function recallByResonance(ctx, query, pre) {
         const minVote = consensusFloor(corpusN(ctx));
         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);
             // THE ANCHOR'S OCCUPANT IS NOT THE ASKER'S.  This tier grounds an anchor
@@ -468,6 +495,7 @@ export const recallMechanism = {
                 moves: r.moves,
                 unexplained: r.unexplained,
                 provenance: r.echoed ? "recall-echo" : "recall",
+                used: new Set(),
                 ...(r.complete ? { complete: true } : {}),
             }];
     },

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

@@ -75,6 +75,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}. */
@@ -202,8 +204,8 @@ export declare 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[];
+    /** See {@link GraphSearchHost.contentKeyEnds}. */
+    contentKeyEnds(prefix: Uint8Array, tail: Uint8Array): readonly number[];
     chooseNext(node: number): number | undefined;
     constructor(opts?: MindOptions);
     constructor(cfg: MindConfig, store: Store, _fromStore: true);

package/dist/src/mind/mind.js

@@ -11,7 +11,8 @@
 import { makeKeyring, rng, setVecConfig } from "../vec.js";
 import { sampleCorpus, searchCorpus } from "./corpus.js";
 import { Alphabet } from "../alphabet.js";
-import { contentBoundaries, contentFoldIncremental, reachThreshold, } from "../geometry.js";
+import { contentFoldIncremental, reachThreshold, } from "../geometry.js";
+import { keyEnds } from "./canonical.js";
 import { BoundedMap } from "../store.js";
 import { SQliteStore } from "../store-sqlite.js";
 import { resolveConfig } from "../config.js";
@@ -160,9 +161,9 @@ export class Mind {
      *  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) {
-        return contentBoundaries(this.space, bytes);
+    /** See {@link GraphSearchHost.contentKeyEnds}. */
+    contentKeyEnds(prefix, tail) {
+        return keyEnds(this, prefix, tail);
     }
     chooseNext(node) {
         return chooseNext(this, node, this._edgeGuide);

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

@@ -151,6 +151,13 @@ 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`/`unexplained`/
+     *  `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. */

package/dist/src/mind/pipeline.js

@@ -12,7 +12,7 @@ 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 { unaccountedBytes, unexplainedSpans } from "./rationale.js";
 import { rItem } from "./trace.js";
 import { hubBound } from "./traverse.js";
 import { Precomputed } from "./pipeline-mechanism.js";
@@ -124,8 +124,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;
@@ -317,13 +316,10 @@ export async function think(ctx, query, mechs) {
     }
     const answer = decided.bytes;
     const provenance = decided.provenance;
-    const castUsed = 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()
-            : new Set(recognise(ctx, answer).sites.map((s) => s.payload));
+    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 +348,21 @@ 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 `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
+    // (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,
+    });
     // 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
@@ -378,9 +386,21 @@ export async function think(ctx, query, mechs) {
     ];
     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 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.
+    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;
     // 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
@@ -424,6 +444,13 @@ export async function think(ctx, query, mechs) {
         : 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");
+    done(fused, 
+    // 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 };
 }

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,6 +83,13 @@ 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. */
@@ -133,7 +151,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

@@ -24,6 +24,18 @@
 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. */
@@ -151,7 +163,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

@@ -13,18 +13,36 @@ import type { Precomputed } from "./pipeline-mechanism.js";
 export declare function restatesQuery(query: Uint8Array, bytes: Uint8Array): boolean;
 /** 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. */
+/** What the multi-hop extension produced, and what it cost: the bytes (the
+ *  answer), the spans of the grounding's UNCOVERED material that each step was
+ *  justified by, and how many steps were taken.  The last two exist so the
+ *  caller can price the extension in the ladder's own currency — `steps · STEP`
+ *  against `PASS · unaccounted` — instead of taking it unconditionally.  Both
+ *  are FACTS, not verdicts: nothing here says whether the extension was worth
+ *  it; that is the comparison's job, one layer up. */
+export interface ReasonedAnswer {
+    bytes: Uint8Array;
+    carried: Array<[number, number]>;
+    steps: number;
+}
 export declare function reason(ctx: MindContext, query: Uint8Array, answer: Uint8Array, preConsumed: ReadonlySet<number>, pre: Precomputed, voiced?: readonly Uint8Array[], 
 /** The query material the GROUNDING left uncovered — the cost ladder's own
  *  `unaccounted` spans.  Only the reasoner's OWN extensions are judged
  *  against it; a mechanism carrying its own `used` set owns its shape. */
-uncovered?: readonly (readonly [number, number])[]): Promise<Uint8Array>;
+uncovered?: readonly (readonly [number, number])[]): Promise<ReasonedAnswer>;
 /** 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