@hviana/sema 0.2.2 → 0.2.3

package/dist/src/mind/articulation.js

@@ -83,7 +83,7 @@ export async function articulate(ctx, answer, query) {
             s.end,
         ])),
     ]);
-    const solved = ctx.search.cover(answer.length, voicedSites, new Map(), ans.leaves, ans.splits, substitutions, undefined, undefined, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
+    const solved = ctx.search.cover(answer.length, voicedSites, new Map(), ans.leaves, ans.splits, ans.starts, substitutions, undefined, undefined, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
     const segs = solved && solved.segs;
     tArtCover?.done(segs === null
         ? []

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

@@ -39,6 +39,9 @@ export declare function poolVotes(ctx: MindContext, regionVotes: readonly Region
         end: number;
         w: number;
     }>;
+    /** Per-anchor SCALE-INVARIANT support: Σ RegionVote.absorbed over the
+     *  distinct contributing regions — see Attention.breadth. */
+    regionSupport: Map<number, number>;
     steps: DerivationStep[];
 };
 export declare function commitVotes(ctx: MindContext, pooled: {
@@ -49,6 +52,7 @@ export declare function commitVotes(ctx: MindContext, pooled: {
         end: number;
         w: number;
     }>;
+    regionSupport: Map<number, number>;
     steps: DerivationStep[];
 }, sat: SaturationInfo, regions: readonly Region[], regionVoter: ReadonlyArray<{
     id: number;

package/dist/src/mind/attention.js

@@ -400,6 +400,7 @@ export function poolVotes(ctx, regionVotes, sat, N) {
     const votes = new Map();
     const votesIdf = new Map();
     const support = new Map();
+    const regionSupport = new Map();
     const steps = [];
     let order = 0;
     for (const pc of pool.values()) {
@@ -407,14 +408,17 @@ export function poolVotes(ctx, regionVotes, sat, N) {
             votes.set(pc.item.id, pc.cost);
             const premises = [];
             const seenRi = new Set();
+            let breadthSum = 0;
             for (const c of pc.contributions) {
                 const p0 = c.premises[0].item;
                 if (p0.kind !== "region" || seenRi.has(p0.ri))
                     continue;
                 seenRi.add(p0.ri);
                 const rv = regionVotes[p0.ri];
+                breadthSum += rv.absorbed ?? 1;
                 premises.push({ kind: "form", span: [rv.start, rv.end] });
             }
+            regionSupport.set(pc.item.id, breadthSum);
             steps.push({
                 order: order++,
                 move: "pool-vote",
@@ -444,18 +448,29 @@ export function poolVotes(ctx, regionVotes, sat, N) {
             }
         }
     }
-    return { votes, votesIdf, support, steps };
+    return { votes, votesIdf, support, regionSupport, steps };
 }
 export function commitVotes(ctx, pooled, sat, regions, regionVoter, N) {
-    const { votes, votesIdf, support, steps } = pooled;
+    const { votes, votesIdf, support, regionSupport, steps } = pooled;
     if (votes.size === 0) {
         traceAttention(ctx, regions, regionVoter, [], steps);
         return { roots: [], ranked: [] };
     }
+    // SCALE-INVARIANT confidence — see Attention.breadth's doc.  regions.length
+    // is the query's OWN full candidate count (most never vote at all), the
+    // same denominator the "N of M sub-regions voted" rationale text already
+    // reports; regionSupport is that same accounting read PER ANCHOR.
+    const totalRegions = Math.max(1, regions.length);
     const ranked = [...votes.entries()]
         .map(([anchor, vote]) => {
         const s = support.get(anchor);
-        return { anchor, vote, start: s.start, end: s.end };
+        return {
+            anchor,
+            vote,
+            start: s.start,
+            end: s.end,
+            breadth: (regionSupport.get(anchor) ?? 0) / totalRegions,
+        };
     })
         .sort((a, b) => b.vote - a.vote);
     const overlaps = (a, b) => a.start < b.end && b.start < a.end;
@@ -855,14 +870,6 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo) {
                 spanStart = Math.min(spanStart, regions[ei].start);
                 spanEnd = Math.max(spanEnd, regions[ei].end);
             }
-            out.push({
-                start: spanStart,
-                end: spanEnd,
-                canonicalFailed: false, // content-addressed: never saturation-masked
-                roots: reach.roots,
-                w,
-                wFocus: w,
-            });
             consumed.add(cand[a]);
             consumed.add(cand[b]);
             for (const ei of bestExtras)
@@ -872,15 +879,32 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo) {
             // vote's bytes are literally part of the learnt whole), and FULL root
             // disjointness is the disagreement test: a vote sharing even one root
             // with the junction corroborates it and keeps its say elsewhere.
+            // Counted BEFORE pushing the junction's own vote below: each ORIGINAL
+            // region this ascent explains away is evidence the junction speaks
+            // for, not evidence lost — `absorbed` (RegionVote's breadth-accounting
+            // field) must credit the junction with all of it, not just the ONE
+            // pooled axiom it collapses to.
             const containerBytes = cachedRead(ctx, cache, best.id, cap);
             const jointRoots = new Set(reach.roots);
+            let explainedAway = 0;
             for (const rv of rvs.votes) {
                 if (rv.roots.some((r) => jointRoots.has(r)))
                     continue;
                 const bytes = query.subarray(rv.start, rv.end);
-                if (indexOf(containerBytes, bytes, 0) >= 0)
+                if (indexOf(containerBytes, bytes, 0) >= 0 && !superseded.has(rv)) {
                     superseded.add(rv);
+                    explainedAway++;
+                }
             }
+            out.push({
+                start: spanStart,
+                end: spanEnd,
+                canonicalFailed: false, // content-addressed: never saturation-masked
+                roots: reach.roots,
+                w,
+                wFocus: w,
+                absorbed: 1 + explainedAway,
+            });
             const label = [cand[a], cand[b], ...bestExtras]
                 .sort((x, y) => regions[x].start - regions[y].start)
                 .map((ri) => dec(query.subarray(regions[ri].start, regions[ri].end)))

package/dist/src/mind/graph-search.d.ts

@@ -54,6 +54,18 @@ export type GItem = {
     cover: boolean;
     rec: boolean;
     node?: number;
+    /** Set only for a {@link ComputedResult} axiom (an extension's derived
+     *  value, e.g. ALU arithmetic) — as opposed to a genuinely RECOGNISED
+     *  learned form.  Both set `rec: true` (a computation bridges the cover
+     *  exactly like a learned terminal answer), but they mean different
+     *  things for `i..j`'s WIDTH: a recognised form's query-span width is
+     *  real evidence of how much of the query's meaning it accounts for
+     *  (liftAnswer's half-dominance framing decision); a computed span's
+     *  width is operand digit-count, uncorrelated with meaning ("1000 - 421"
+     *  is wider than "15 * 7" only because the numbers are bigger, not
+     *  because subtraction is more "the point" of its query).  See
+     *  {@link liftAnswer}. */
+    computed?: boolean;
 };
 export declare const STEP = 1;
 export declare const CONCEPT = 10;
@@ -72,6 +84,9 @@ export interface Seg {
     bytes: Uint8Array;
     rec: boolean;
     node?: number;
+    /** See the `computed` field of the "out" {@link GItem} — set only for an
+     *  extension's derived value, never a genuinely recognised learned form. */
+    computed?: boolean;
 }
 /** One rule application inside the cover's lightest derivation — the FINEST
  *  grain of Sema's core reasoning, one node of the adapted A*LD proof tree.  `move`
@@ -144,7 +159,7 @@ export declare class GraphSearch {
      *  Any learnt connector between two rewrites is spliced IN by the in-search
      *  connector rule (see {@link outRules}), so the returned spans already carry
      *  it — there is no post-pass. */
-    cover(queryLen: number, sites: ReadonlyArray<Site>, conceptTarget: ReadonlyMap<number, number>, leaves: ReadonlyArray<Leaf>, splits: ReadonlySet<number>, substitutions?: ReadonlyMap<number, Uint8Array>, connectors?: ReadonlyMap<string, Uint8Array>, computedResults?: ReadonlyArray<ComputedResult>, 
+    cover(queryLen: number, sites: ReadonlyArray<Site>, conceptTarget: ReadonlyMap<number, number>, leaves: ReadonlyArray<Leaf>, splits: ReadonlySet<number>, starts: ReadonlySet<number>, substitutions?: ReadonlyMap<number, Uint8Array>, connectors?: ReadonlyMap<string, Uint8Array>, computedResults?: ReadonlyArray<ComputedResult>, 
     /** When given, receives the lightest derivation's rule applications — the
      *  full adapted A*LD proof tree as classified {@link DerivationStep}s — for the TOP
      *  cover only (a recursive recompletion solves its own sub-cover and is not

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

@@ -63,6 +63,7 @@ function readCover(derivation) {
                 bytes: out.bytes,
                 rec: out.rec,
                 node: out.node,
+                computed: out.computed,
             });
         }
         node = node.premises[0];
@@ -205,7 +206,7 @@ export class GraphSearch {
      *  Any learnt connector between two rewrites is spliced IN by the in-search
      *  connector rule (see {@link outRules}), so the returned spans already carry
      *  it — there is no post-pass. */
-    cover(queryLen, sites, conceptTarget, leaves, splits, substitutions, connectors, computedResults, 
+    cover(queryLen, sites, conceptTarget, leaves, splits, starts, substitutions, connectors, computedResults, 
     /** When given, receives the lightest derivation's rule applications — the
      *  full adapted A*LD proof tree as classified {@link DerivationStep}s — for the TOP
      *  cover only (a recursive recompletion solves its own sub-cover and is not
@@ -221,6 +222,7 @@ export class GraphSearch {
             sites,
             leaves,
             splits,
+            starts,
         }, conceptTarget, substitutions, connectors, computedResults, onDerivation);
     }
     /** Build the deduction system for one span and return its lightest cover's
@@ -237,7 +239,7 @@ export class GraphSearch {
      *  decomposes, two recomposes, any mix — and stops only when it reaches a node
      *  that leads nowhere new, never at an arbitrary count. */
     solve(spanLen, recognition, conceptTarget, substitutions, connectors, computedResults, onDerivation) {
-        const system = this.buildSearch(spanLen, recognition.sites, conceptTarget, recognition.leaves, recognition.splits, substitutions, connectors, computedResults);
+        const system = this.buildSearch(spanLen, recognition.sites, conceptTarget, recognition.leaves, recognition.splits, recognition.starts, substitutions, connectors, computedResults);
         const derivation = lightestDerivation(system);
         // When covering under a substitution map (articulation), a form→out rule is
         // the form EMITTING the asker's voice, not grounding to its own answer — so
@@ -257,8 +259,15 @@ export class GraphSearch {
      *  adjacent fragments toward a known leaf (findLeaf) or branch (findBranch);
      *  a completion fused with its neighbour may spell a deeper learned form the
      *  flat probes can't name, recovered canonically by {@link resolve}. */
-    buildSearch(queryLen, sites, conceptTarget, leaves, splits, substitutions, connectors, computedResults) {
+    buildSearch(queryLen, sites, conceptTarget, leaves, splits, starts, substitutions, connectors, computedResults) {
         const W = this.maxGroup; // fusible span ceiling (shortest composite bound)
+        // Same corpus-scale hub floor {@link atomIsHub}/{@link atomReach} (traverse.ts)
+        // derive for byte atoms — duplicated here rather than imported because this
+        // module is deliberately host-based (no MindContext), and both inputs
+        // (maxGroup, edgeSourceCount) are already in scope with no ctx needed.  If
+        // the formula ever changes, it must change in BOTH places (see canonical.ts's
+        // header for the same write/read-side duplication convention).
+        const atomsAreHubs = Math.max(1, Math.ceil((this.store.edgeSourceCount() * W) / 256)) > Math.ceil(Math.sqrt(Math.max(2, this.store.edgeSourceCount())));
         const nodeBytes = (n) => this.store.bytesPrefix(n, ALL);
         // Content-addressed probes over the store's hash-cons maps — the same keys
         // training filled.  No byte-by-byte trie walk.
@@ -350,6 +359,7 @@ export class GraphSearch {
                             cover: true,
                             rec: true,
                             node: u.node,
+                            computed: true,
                         },
                         cost: STEP,
                     };
@@ -388,6 +398,8 @@ export class GraphSearch {
                 return this.outRules(it, {
                     W,
                     splits,
+                    starts,
+                    atomsAreHubs,
                     coversDone,
                     outsByStart,
                     outsByEnd,
@@ -845,7 +857,23 @@ export class GraphSearch {
      *  enters the graph as a form the moment it names a node. */
     *fuse(l, r, ctx) {
         const bytes = concat2(l.bytes, r.bytes);
-        let node = bytes.length <= ctx.W ? ctx.findLeafU(bytes) : undefined;
+        // A PURE leaf-leaf fuse (neither side already a recognised completion)
+        // is opportunistic cross-leaf recovery exactly like recognition.ts's own
+        // canonical chain — findLeaf/findBranch here have no idea WHY these two
+        // leaves are adjacent, only that their concatenation happens to spell a
+        // trained form ("hi" recovered from "W[hi]ch").  The same corpus-scale
+        // caution recognition.ts's `boundary` gate applies: trust it fully when
+        // `l.i` is a position the query's OWN fold chose as a boundary (real
+        // structural evidence); past the scale where atoms themselves stop
+        // discriminating, an interior offset's opportunistic match is noise, not
+        // a genuine cross-leaf recovery.  A completion-involved fuse (l.rec ||
+        // r.rec) is a different, legitimate case — a rewrite growing into its
+        // neighbour — and is exempt, same as recognition.ts's rec-derived sites.
+        const trusted = l.rec || r.rec || ctx.starts.has(l.i) ||
+            !ctx.atomsAreHubs;
+        let node = (trusted && bytes.length <= ctx.W)
+            ? ctx.findLeafU(bytes)
+            : undefined;
         // Whether this pair ACTUALLY forms a 2-child branch — the hard evidence
         // that the fused bytes are a learned form worth keeping alive.  Derived
         // from the same findBranchU probe that sets `node`; when false, the pair
@@ -853,7 +881,8 @@ export class GraphSearch {
         // node cannot contribute to any further fusion (findBranch needs two
         // nodes, resolve needs a completion, and findLeaf already had its chance).
         let pairFormsBranch = false;
-        if (node === undefined && l.node !== undefined && r.node !== undefined) {
+        if (trusted && node === undefined && l.node !== undefined &&
+            r.node !== undefined) {
             node = ctx.findBranchU([l.node, r.node]);
             pairFormsBranch = node !== undefined;
         }

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

@@ -12,7 +12,14 @@ import { unexplainedLabel } from "../rationale.js";
 export function aluToMechanism(alu) {
     return {
         name: "alu",
-        provenance: "cover",
+        // Not a cover derivation: cover.ts composes an answer by walking
+        // recognised query STRUCTURE; the ALU evaluates a recognised expression
+        // to its authoritative result and hands the bytes back untouched. It
+        // shares cover's near-zero floor (computation always wins, masked into
+        // cover's own search — see mechanisms/cover.ts), but the candidate this
+        // produces is not one of cover's derivations, so it carries its own
+        // honest label, the same way extract/cast/recall each carry theirs.
+        provenance: "alu",
         parse: (query) => alu.parse(query),
         async floor(_ctx, _query, pre, _worthRunning) {
             return pre.computed.length > 0 ? 0 : null;

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

@@ -70,19 +70,37 @@ const MIN_WEAVE = 2;
  *
  *  Returns the array of {@link CastResult}s that fired (possibly empty). */
 export async function counterfactualTransfer(ctx, query, pre) {
+    // Opened unconditionally, at entry — the same convention recall.ts's
+    // recallByResonance and extraction.ts's extractBySkill use, so every exit
+    // path (five gates below, then the schemas themselves) closes through
+    // ONE scope and inspectRationale never hits a silent dead end.  Only the
+    // first two gates duplicate floor()'s own admissible bound (query length,
+    // ranked anchor count) — required to stay in sync per this function's own
+    // doc comment above, and effectively dead through the ordinary pipeline
+    // (floor() returning null already stops run() from being called at all),
+    // but this function is also exported and callable directly, so they stay
+    // and get the same honest trace as everything past them.
+    const t = ctx.trace?.enter("counterfactual", [rItem(query, "query")]);
+    const fail = (note) => {
+        t?.done([], note);
+        return [];
+    };
     const quantum = ctx.space.maxGroup;
     if (query.length < 2 * quantum || ctx.store.edgeSourceCount() === 0) {
-        return [];
+        return fail("query below the two-quantum floor, or no edges learnt yet");
     }
     const { roots, ranked } = await pre.attention();
-    if (ranked.length < 2)
-        return [];
+    if (ranked.length < 2) {
+        return fail(`only ${ranked.length} ranked anchor(s) — CAST needs at least two`);
+    }
     const weave = await pre.weave();
     const points = weave.points;
     const depth = weave.depth;
     const aligned = points.length;
-    if (aligned < 2)
-        return [];
+    if (aligned < 2) {
+        return fail(`only ${aligned} structure(s) aligned across the query — CAST needs ` +
+            `at least two to transfer between`);
+    }
     // ── Frame gate (half-dominance, weave-local) ─────────────────────────
     // A byte is FRAME when more than MIN_WEAVE aligned structures cover it
     // AND those structures are a majority of all aligned structures.
@@ -120,14 +138,20 @@ export async function counterfactualTransfer(ctx, query, pre) {
     const isRoot = (id) => roots.some((r) => r.anchor === id);
     // The weave must touch a COMMITTED point of attention: the dominant
     // structure itself, or another aligned point the climb committed to.
-    if (!points.some((p) => isRoot(p.anchor)))
+    if (!points.some((p) => isRoot(p.anchor))) {
+        t?.done([
+            ...points.map((p) => rNode(ctx, p.anchor, "aligned")),
+            ...roots.map((r) => rNode(ctx, r.anchor, "committed-root")),
+        ], `${points.length} aligned structure(s), but none is one of the climb's ` +
+            `${roots.length} committed root(s) — CAST refuses to transfer through ` +
+            `content the climb itself never settled on`);
         return [];
+    }
     const woven = points.some((p) => p.runs.some((r) => !pre.rec.sites.some((s) => r.qs >= s.start && r.qe <= s.end)));
-    if (!woven)
-        return [];
-    const t = ctx.trace?.enter("counterfactual", [
-        rItem(query, "query"),
-    ]);
+    if (!woven) {
+        return fail(`every aligned run restates a recognised query site — nothing was ` +
+            `actually WOVEN across structures, so there is nothing to transfer`);
+    }
     // Each schema tried below RECORDS its candidate (when it fires) rather than
     // returning immediately — every schema that succeeds contributes its own
     // candidate, and the grounding decider's own weight comparison (not CAST's

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

@@ -122,11 +122,18 @@ export const coverMechanism = {
             return [];
         const connectors = await resolveConnectors(ctx, sites);
         let splits = rec.splits;
+        let starts = rec.starts;
         if (computed.length > 0) {
             splits = new Set(rec.splits);
+            starts = new Set(rec.starts);
             for (const u of computed) {
                 splits.add(u.i);
                 splits.add(u.j);
+                // A computation's own boundaries carry the same fold-level evidence
+                // a chunk boundary does — "computation always wins" (see the header
+                // comment) extends to being trusted ground for cross-leaf recovery.
+                starts.add(u.i);
+                starts.add(u.j);
             }
         }
         const concepts = await resolveConcepts(ctx, sites);
@@ -150,7 +157,7 @@ export const coverMechanism = {
             ])),
             ...computedResults.map((u) => rItem(u.bytes, "computed")),
         ], coverDeps.length ? coverDeps : undefined);
-        const solved = ctx.search.cover(query.length, sites, concepts, rec.leaves, splits, undefined, connectors, computedResults, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
+        const solved = ctx.search.cover(query.length, sites, concepts, rec.leaves, splits, starts, undefined, connectors, computedResults, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
         const segs = solved && solved.segs;
         tCover?.done(segs === null
             ? []

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

@@ -49,32 +49,86 @@ export async function extractBySkill(ctx, query, pre) {
     if (ranked.length === 0) {
         return fail("no consensus anchor — no skill to apply");
     }
-    let exemplar = null;
-    let chosenAnchor = null;
-    let skipped = 0;
-    for (const cand of ranked) {
-        const ex = await pre.spanShapedOf(cand.anchor);
-        if (ex) {
-            exemplar = ex;
-            chosenAnchor = cand.anchor;
-            break;
+    // Try ranked anchors IN ORDER until one yields a USABLE extraction — not
+    // merely a span-shaped exemplar, but one whose extracted span clears the
+    // same one-river-fold quantum (W) cover.ts's restatedSpan gate already
+    // treats as the floor below which byte overlap is chance, not evidence.
+    // isSpanShaped (spanShapedOf) is a deliberately permissive sparse-
+    // subsequence check — see the section note below — so it accepts exemplars
+    // whose relation to the query is coincidental gap-matching, not genuine
+    // structure.  Stopping at the FIRST such exemplar let a coincidental match
+    // early in the ranked list win outright and read out a sub-quantum
+    // fragment (observed: a 3-byte "Hel" pulled from an unrelated exemplar,
+    // while a later ranked anchor would have read the query's own "Hello…"
+    // correctly).  Trying further anchors when one produces nothing usable is
+    // the same idiom this loop already uses for non-exemplars — extended to
+    // cover a bad extraction, not just a structural non-match.
+    //
+    // The retry is bounded at pre.k — the SAME evidence-breadth constant every
+    // other consumer of a ranked list already self-limits to (resonance, the
+    // weave, the climb itself; see Precomputed.k's own doc comment) — not the
+    // full ranked list.  locate()'s frame match has an EXACT-byte tier with no
+    // significance correction of its own (short W-byte frames are cheap to
+    // match by pure chance), so trying every ranked anchor turns that per-
+    // anchor chance into a near-certainty over enough attempts: on a pure-
+    // gibberish query, 170 anchors deep found an unrelated Zulu exemplar whose
+    // short frame happened to byte-match, producing "xyzzy pl" — a coincidence
+    // no different in kind from the "RaBitQ estimate overshot the reach bar
+    // and grounded pure gibberish" failure recall.ts's own significance
+    // correction exists to prevent (see recallByResonance's reach-threshold
+    // comment).  Bounding the search to the ranked list's own top-k restores
+    // the "genuinely relevant but not root-significant" exemplars this loop
+    // was built for, without the unbounded tail's chance collisions.
+    const W = ctx.space.maxGroup;
+    const searched = ranked.slice(0, pre.k);
+    let shapeMisses = 0;
+    let subQuantum = 0;
+    for (const cand of searched) {
+        const exemplar = await pre.spanShapedOf(cand.anchor);
+        if (!exemplar) {
+            shapeMisses++;
+            continue;
+        }
+        const built = buildFromExemplar(ctx, query, pre, exemplar);
+        if (built === null || built.bytes.length < W) {
+            subQuantum++;
+            continue;
+        }
+        if (shapeMisses > 0 || subQuantum > 0) {
+            ctx.trace?.step("trySkillAnchors", [
+                rItem(query.subarray(0, 0), `skipped ${shapeMisses + subQuantum}`),
+                rNode(ctx, cand.anchor, "chosen"),
+            ], [], `skipped ${shapeMisses} non-exemplar and ${subQuantum} sub-quantum ` +
+                `anchor(s) before one yielded a usable extraction`);
         }
-        skipped++;
+        t?.done([rItem(built.bytes, "extracted")], built.pieces === 1
+            ? `apply a learnt extraction skill — read the analogous span of the query` +
+                ` framed like "${decodeText(exemplar.answerBytes)}" sits in its exemplar`
+            : `apply a learnt MULTI-PIECE skill — read ${built.pieces} analogous` +
+                ` pieces of the query and synthesize them like "${decodeText(exemplar.answerBytes)}"`);
+        return {
+            bytes: built.bytes,
+            accounted: built.accounted,
+            unexplained: unexplainedLabel(query, built.accounted),
+        };
     }
-    if (exemplar === null) {
-        ctx.trace?.step("trySkillAnchors", [], [], `none of ${ranked.length} ranked anchor(s) is a span-shaped skill exemplar`);
+    if (shapeMisses === searched.length) {
+        ctx.trace?.step("trySkillAnchors", [], [], `none of the top ${searched.length} ranked anchor(s) (of ${ranked.length} total) ` +
+            `is a span-shaped skill exemplar`);
         return fail("no consensus root is a span-shaped skill exemplar");
     }
-    if (skipped > 0) {
-        ctx.trace?.step("trySkillAnchors", [
-            rItem(query.subarray(0, 0), `skipped ${skipped}`),
-            rNode(ctx, chosenAnchor, "chosen"),
-        ], [], `skipped ${skipped} anchor(s) that are not skill exemplars`);
-    }
+    return fail("no ranked anchor yielded an extraction at or above the quantum floor");
+}
+/** Build the extracted bytes for ONE already-accepted span-shaped exemplar —
+ *  factored out of {@link extractBySkill} so its anchor loop can try
+ *  successive ranked candidates instead of committing to the first
+ *  structural match.  Null when the exemplar's answer does not decompose
+ *  against its context, or no piece's frame locates in the query. */
+function buildFromExemplar(ctx, query, pre, exemplar) {
     const { contextBytes, answerBytes } = exemplar;
     const ansCtxRuns = answerRunsInContext(ctx, contextBytes, answerBytes);
     if (ansCtxRuns === null || ansCtxRuns.length === 0) {
-        return fail("answer is not a subsequence of the context");
+        return null;
     }
     if (ansCtxRuns.length > 1) {
         ctx.trace?.step("decomposeAnswer", [rItem(answerBytes, "multi-piece-answer")], ansCtxRuns.map((r) => rItem(contextBytes.subarray(r.start, r.end), "piece", undefined, [
@@ -142,19 +196,10 @@ export async function extractBySkill(ctx, query, pre) {
             accounted.push([start, end]);
     }
     if (pieces.length === 0) {
-        return fail("no answer piece's frame located in the query");
+        return null;
     }
     const out = pieces.length === 1 ? pieces[0] : concatBytes(pieces);
-    t?.done([rItem(out, "extracted")], pieces.length === 1
-        ? `apply a learnt extraction skill — read the analogous span of the query` +
-            ` framed like "${decodeText(answerBytes)}" sits in its exemplar`
-        : `apply a learnt MULTI-PIECE skill — read ${pieces.length} analogous` +
-            ` pieces of the query and synthesize them like "${decodeText(answerBytes)}"`);
-    return {
-        bytes: out,
-        accounted,
-        unexplained: unexplainedLabel(query, accounted),
-    };
+    return { bytes: out, accounted, pieces: pieces.length };
 }
 // ── The two span-shape readings: OPEN acceptance vs. STRONG decomposition ──
 //

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

@@ -122,6 +122,7 @@ export declare class Mind implements MindContext {
         sites: ReadonlyArray<Site>;
         leaves: ReadonlyArray<Leaf>;
         splits: ReadonlySet<number>;
+        starts: ReadonlySet<number>;
     };
     /** Disambiguate among multiple learnt continuations of the same context node.
      *  Required by {@link GraphSearchHost} — the graph search calls this through the

package/dist/src/mind/mind.js

@@ -95,7 +95,12 @@ export class Mind {
     // recogniseSpan wraps recognise
     recogniseSpan(bytes) {
         const r = recognise(this, bytes);
-        return { sites: r.sites, leaves: r.leaves, splits: r.splits };
+        return {
+            sites: r.sites,
+            leaves: r.leaves,
+            splits: r.splits,
+            starts: r.starts,
+        };
     }
     /** Disambiguate among multiple learnt continuations of the same context node.
      *  Required by {@link GraphSearchHost} — the graph search calls this through the

package/dist/src/mind/pipeline.js

@@ -177,8 +177,40 @@ export async function think(ctx, query, mechs) {
             ? new Set()
             : new Set(recognise(ctx, answer).sites.map((s) => s.payload));
     const reasoned = await reason(ctx, query, answer, preConsumed, pre);
-    const fused = provenance === "recall" || provenance === "recall-echo"
-        ? await fuseAttention(ctx, query, reasoned, pre)
+    // 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
+    // masked/computed spans at near-zero and deliberately leaves them out of
+    // `accounted` so PASS-bridged bytes are still charged), not a coverage
+    // one — a query fully explained by one computed span plus bridged
+    // connectors can report `accounted: []` while nothing is actually left
+    // unexplained.  The genuine remainder is what NEITHER the winning
+    // candidate's accounted spans NOR any recognised extension's computed
+    // span (`pre.computed` — every mechanism's parse() output, ALU included)
+    // ever touched.  A remainder under one river-fold quantum (W, the same
+    // floor cover.ts's restatedSpan and the honesty-density bar above both
+    // use) is bridging punctuation/whitespace, never a second topic —
+    // 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 explained = [
+        ...decided.accounted,
+        ...pre.computed.map((u) => [u.i, u.j]),
+    ];
+    const remainder = unaccounted(explained);
+    // 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
+    // shortcut assumes a single point of attention already IS primary's own
+    // source; that assumption is exactly backwards for a pure computation
+    // (an ALU result has no anchor of its own) — see fuseAttention's
+    // `unclimbed` parameter, gated there by Attention.breadth so a
+    // coincidental echo (which this flag alone cannot distinguish) is still
+    // rejected.
+    const unclimbed = decided.accounted.length > 0 &&
+        decided.accounted.every(([i, j]) => pre.computed.some((u) => u.i === i && u.j === j));
+    const fused = remainder >= ctx.space.maxGroup
+        ? await fuseAttention(ctx, query, reasoned, pre, unclimbed)
         : reasoned;
     done(fused, "grounded, reasoned forward, fused across points of attention");
     return { bytes: fused, provenance };

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

@@ -12,4 +12,12 @@ export declare function reason(ctx: MindContext, query: Uint8Array, answer: Uint
  *  When the consensus climb finds more than one dominant point, each
  *  independent point grounds its own answer; they are bridged together
  *  by any learnt connector the graph holds between them. */
-export declare function fuseAttention(ctx: MindContext, query: Uint8Array, primary: Uint8Array, pre: Precomputed): Promise<Uint8Array>;
+export declare function fuseAttention(ctx: MindContext, query: Uint8Array, primary: Uint8Array, pre: Precomputed, 
+/** True when `primary` never touched the consensus climb at all — e.g. a
+ *  pure ALU computation, which has no anchor of its own.  commitVotes
+ *  ALWAYS admits the dominant root regardless of its vote (attention.ts:
+ *  "roots.length === 0 || …") on the assumption a lone root already IS
+ *  primary's own source; that assumption is exactly backwards when
+ *  primary is unclimbed.  Absent or false preserves the original
+ *  behaviour exactly. */
+unclimbed?: boolean): Promise<Uint8Array>;