@hviana/sema 0.2.2 → 0.2.3

package/dist/src/mind/reasoning.js

@@ -111,7 +111,15 @@ export async function reason(ctx, query, answer, preConsumed, pre) {
  *  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 async function fuseAttention(ctx, query, primary, pre) {
+export async function fuseAttention(ctx, query, primary, pre, 
+/** 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 = false) {
     // When the answer is structurally drawn from the query itself
     // (extraction), it already spans all the query's pieces — fusion
     // would only add noise from unrelated stored contexts.  The gate is
@@ -125,17 +133,31 @@ export async function fuseAttention(ctx, query, primary, pre) {
     // query, same k, same DF mode) — read them from Precomputed instead of
     // re-climbing, so even a traced response pays for the climb once.
     const forest = (await pre.attention()).roots;
-    if (forest.length <= 1)
+    // A LONE root is ordinarily primary's own source — nothing to fuse.  But
+    // when primary is unclimbed, the lone root was never checked against
+    // anything: it is admitted by commitVotes unconditionally, so it may be
+    // genuine consensus (Attention.breadth dominates — most of the query's
+    // OWN regions corroborate it) or a coincidental echo (breadth does not
+    // dominate — see test/35-attention-confidence).  breadth is the SCALE-
+    // INVARIANT read of exactly this question: the raw IDF vote cannot serve
+    // here, since it is an absolute ln(N)-scaled quantity (a genuine root on
+    // a large store can score BELOW its own floor while a coincidental echo
+    // on a small one scores comfortably above its own, smaller, floor).
+    const lonePromotes = unclimbed && forest.length === 1 &&
+        forest[0].breadth > 0.5;
+    if (forest.length === 0 || (forest.length <= 1 && !lonePromotes)) {
         return primary;
+    }
     const pieces = [
         { start: forest[0].start, bytes: primary },
     ];
     const qv = pre.guide; // once, not per root
+    const rest = lonePromotes ? forest : forest.slice(1);
     const t = ctx.trace?.enter("fuseAttention", [
         rItem(primary, "primary"),
-        ...forest.slice(1).map((r) => rNode(ctx, r.anchor, "point", r.vote)),
+        ...rest.map((r) => rNode(ctx, r.anchor, "point", r.vote)),
     ]);
-    for (const root of forest.slice(1)) {
+    for (const root of rest) {
         const g = await project(ctx, root.anchor, qv);
         if (g === null || g.length === 0)
             continue;

package/dist/src/mind/recognition.js

@@ -41,8 +41,9 @@ function recogniseImpl(ctx, bytes) {
     const sites = [];
     const leaves = [];
     const splits = new Set();
+    const starts = new Set();
     if (bytes.length === 0)
-        return { sites, leaves, splits };
+        return { sites, leaves, splits, starts };
     // Span-resolve memo for THIS call: the structural pass (sub-runs inside
     // leaf-parents) and the canonical pass (leaf-id chains) probe overlapping
     // spans, and each resolve() is a full fold of the sub-span (fresh subarray
@@ -78,7 +79,6 @@ function recogniseImpl(ctx, bytes) {
         }
     };
     // ── structural: the query's own perceived tree ──────────────────────
-    const starts = new Set();
     starts.add(0);
     foldTree(ctx, perceive(ctx, bytes), 0, (n, start, end, node) => {
         if (n.kids === null) {
@@ -105,7 +105,16 @@ function recogniseImpl(ctx, bytes) {
                 leafOffsets.push(off);
                 off += k.leaf?.length ?? 0;
             }
+            // Sub-spans starting at i > 0 begin INSIDE the chunk, at an offset the
+            // query's own fold did not itself choose as a boundary — the same
+            // opportunistic byte-atom-chain risk `tryChain`'s `boundary` gate
+            // guards below (see its comment).  Only the chunk's own left edge
+            // (i === 0, already registered in `starts` above) carries the fold's
+            // evidence; interior sub-starts are exempt from the guard only while
+            // atoms themselves still discriminate at this corpus scale.
             for (let i = 0; i < n.kids.length; i++) {
+                if (i > 0 && atomsAreHubs)
+                    break;
                 const subIds = [];
                 for (let j = i; j < n.kids.length; j++) {
                     const kj = n.kids[j];
@@ -148,7 +157,20 @@ function recogniseImpl(ctx, bytes) {
             chunkEnd[p] = chunkLimit;
         }
     }
-    const tryChain = (p, maxIds) => {
+    // A chain rebuilt from a NON-boundary offset (the query's own perceived
+    // cut, `starts`, never chose to segment here) is opportunistic: the same
+    // byte-atom coincidence the hub guard above already exists for, just
+    // spelled over 2+ leaves instead of 1.  At small corpus scale that's fine
+    // — coincidence is rare and every chain is real evidence (see `atomIsHub`).
+    // Past the scale where atoms themselves stop discriminating, the same
+    // uniform-expectation argument bounds a CHAIN'S commonality too: it is at
+    // least as rare as its rarest atom, so a store where atoms are hubs makes
+    // interior chain reconstructions no more trustworthy than the atoms they
+    // are built from ("hi" resolving out of "W[hi]ch" is exactly this: two
+    // hub-scale atoms, chained at an offset nothing in the query's own fold
+    // selected).  Chains that start ON a boundary carry the fold's own
+    // evidence instead and are exempt.
+    const tryChain = (p, maxIds, boundary) => {
         const first = leafFrom(p);
         if (!first)
             return;
@@ -164,6 +186,8 @@ function recogniseImpl(ctx, bytes) {
             pos = nx.end;
             if (store.findBranch(ids) === null)
                 continue;
+            if (!boundary && atomsAreHubs)
+                continue;
             const id = resolveSpan(p, pos);
             if (id === null || id === prevId)
                 continue;
@@ -173,11 +197,11 @@ function recogniseImpl(ctx, bytes) {
     };
     for (let p = 0; p < bytes.length; p++) {
         if (starts.has(p)) {
-            tryChain(p, chainReach(W)); // boundary start — full reach
+            tryChain(p, chainReach(W), true); // boundary start — full reach
         }
         else {
             const limit = chunkEnd[p] + W;
-            tryChain(p, Math.min(limit - p, chainReach(W)));
+            tryChain(p, Math.min(limit - p, chainReach(W)), false);
         }
     }
     // ── splits: a form boundary that does not fall on a leaf edge ────────
@@ -195,7 +219,7 @@ function recogniseImpl(ctx, bytes) {
         s.end,
     ])), `decompose the query into ${sites.length} learnt form(s) that lead somewhere` +
         ` (over ${leaves.length} perceived leaves)`);
-    return { sites, leaves, splits };
+    return { sites, leaves, splits, starts };
 }
 /** Segment bytes using the geometry's own groupings — leaf-parent
  *  nodes from the perceived tree, with consecutive bare leaves merged

package/dist/src/mind/traverse.js

@@ -6,6 +6,7 @@
 // The PROJECTIONS built on these walks (follow, conceptHop, reverseContext,
 // project) live in match.ts — the elementary match-and-project operation.
 import { cosine } from "../vec.js";
+import { consensusFloor } from "../geometry.js";
 import { gistOf, read } from "./primitives.js";
 const structCaches = new WeakMap();
 function getStructCache(ctx) {
@@ -439,6 +440,20 @@ export function chooseNext(ctx, id, guide) {
             bestMass = mass;
         }
     }
+    // A pick among GENUINELY competing continuations still needs to clear the
+    // same genuine-corroboration floor {@link consensusFloor} draws for every
+    // other consumer that turns distinct-context support into a vote (the
+    // climb's recallByResonance/commitVotes) — below it, "most corroborated"
+    // is only the least-thin echo among several, not real evidence.  Gated to
+    // corpus scale large enough that this echo is even possible (the same
+    // scale {@link atomIsHub} already switches on for the identical reason:
+    // at small N every edge IS the evidence there is).  A hub id has no
+    // meaningful "distinct context" reading at all (id < 0 atoms are excluded
+    // from this path already, since chooseNext only ever sees real edges).
+    const N = corpusN(ctx);
+    if (capped.length > 1 && atomIsHub(ctx, N) && bestSupport < consensusFloor(N)) {
+        return undefined;
+    }
     // Trace is built lazily — the filter + map below only execute when a
     // trace listener is attached, so the common (no-trace) path pays only
     // for the prevCount calls in the loop above, never for extra rItemShort

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

@@ -34,6 +34,7 @@ export interface GraphSearchHost {
         sites: ReadonlyArray<Site>;
         leaves: ReadonlyArray<Leaf>;
         splits: ReadonlySet<number>;
+        starts: ReadonlySet<number>;
     };
     chooseNext?(node: number): number | undefined;
 }
@@ -44,6 +45,13 @@ export interface Recognition {
     leaves: Leaf[];
     /** Sub-leaf positions where a form boundary falls between leaf edges. */
     splits: Set<number>;
+    /** Leaf-parent (chunk) start positions from the query's OWN perceived
+     *  fold — the positions the fold itself chose as a grouping boundary, as
+     *  opposed to an offset a byte-level scan merely happens to land on.  The
+     *  one boundary signal opportunistic cross-leaf recovery (recognition's
+     *  own canonical chains, the search's `fuse`) can lean on instead of
+     *  ASCII/word heuristics: see the `boundary` gate in recognition.ts. */
+    starts: Set<number>;
 }
 /** How the consensus climb weights a region's Document-Frequency reach. */
 export type DFMode = "inverse" | "direct" | "combined";
@@ -56,6 +64,16 @@ export interface Attention {
     /** The union of the query byte-spans whose evidence supports this point. */
     start: number;
     end: number;
+    /** SCALE-INVARIANT confidence: the fraction of the query's OWN regions
+     *  whose evidence this point accounts for (Σ RegionVote.absorbed among
+     *  its contributors, over the query's total region count) — read PER-
+     *  ANCHOR, unlike the raw IDF vote (an absolute, ln(N)-scaled quantity
+     *  that means "strong" on a small store and "weak" on a large one for
+     *  the SAME degree of genuine consensus).  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 —
+     *  see test/35-attention-confidence.test.mjs. */
+    breadth: number;
 }
 /** Both read-outs of one consensus climb. */
 export interface AttentionRead {
@@ -89,6 +107,14 @@ export interface RegionVote {
     roots: readonly number[];
     w: number;
     wFocus: number;
+    /** How many of the query's ORIGINAL regions this one vote's evidence
+     *  accounts for.  1 for an ordinary per-region vote (itself); for a
+     *  cross-region junction vote, 1 (itself) plus however many individual
+     *  votes it explained away (see crossRegionVotes) — the junction speaks
+     *  for all of them at once, and breadth accounting must not undercount it
+     *  to "one region" just because it collapsed to one pooled axiom.
+     *  Defaults to 1 when absent. */
+    absorbed?: number;
 }
 /** The edge-bearing contexts reached by climbing from a node, plus saturation info. */
 export interface AncestorReach {

package/dist/src/mind/types.js

@@ -26,6 +26,21 @@ export function liftAnswer(segs, queryLen) {
         return null;
     if (recognised.length === 1) {
         const s = segs[recognised[0]];
+        // A COMPUTED span's query-side width is operand digit-count, not
+        // evidence of how much of the query's meaning it accounts for — the
+        // half-dominance check below (built for a genuinely RECOGNISED learned
+        // form) is not a valid framing signal for it (see the `computed` field
+        // doc on Seg/GItem): "1000 - 421" outweighs "what is …?" by width only
+        // because the operands are big, not because the framing matters less.
+        // A LITERAL PREFIX before a computed span is unambiguous framing
+        // regardless of width — an arithmetic expression is never itself
+        // preceded by more literal computed content, so anything literal before
+        // it is question wording ("what is ", "compute ") to lift clear of.
+        // With no prefix (s.i === 0) the span is judged by the ordinary
+        // half-dominance rule below, which already correctly keeps a short
+        // trailing glue byte ("2+2." → "4.", the span dominates a 4-byte query).
+        if (s.computed && s.i > 0)
+            return s.bytes;
         if (dominates(s.j - s.i, queryLen)) {
             return concatBytes(segs.map((x) => x.bytes));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "type": "module",
   "main": "dist/src/index.js",

package/src/mind/articulation.ts

@@ -105,6 +105,7 @@ export async function articulate(
     new Map(),
     ans.leaves,
     ans.splits,
+    ans.starts,
     substitutions,
     undefined,
     undefined,

package/src/mind/attention.ts

@@ -417,6 +417,9 @@ export function poolVotes(
   votes: Map<number, number>;
   votesIdf: Map<number, number>;
   support: Map<number, { start: number; 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[];
 } {
   const eligible: number[] = [];
@@ -496,6 +499,7 @@ export function poolVotes(
     number,
     { start: number; end: number; w: number }
   >();
+  const regionSupport = new Map<number, number>();
   const steps: DerivationStep[] = [];
   let order = 0;
   for (const pc of pool.values()) {
@@ -503,13 +507,16 @@ export function poolVotes(
       votes.set(pc.item.id, pc.cost);
       const premises: DerivationItem[] = [];
       const seenRi = new Set<number>();
+      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",
@@ -536,7 +543,7 @@ export function poolVotes(
       }
     }
   }
-  return { votes, votesIdf, support, steps };
+  return { votes, votesIdf, support, regionSupport, steps };
 }
 
 export function commitVotes(
@@ -545,6 +552,7 @@ export function commitVotes(
     votes: Map<number, number>;
     votesIdf: Map<number, number>;
     support: Map<number, { start: number; end: number; w: number }>;
+    regionSupport: Map<number, number>;
     steps: DerivationStep[];
   },
   sat: SaturationInfo,
@@ -552,16 +560,27 @@ export function commitVotes(
   regionVoter: ReadonlyArray<{ id: number; score: number; w: number } | null>,
   N: number,
 ): AttentionRead {
-  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);
 
@@ -1016,14 +1035,6 @@ async function crossRegionVotes(
         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) consumed.add(ei);
@@ -1033,14 +1044,33 @@ async function crossRegionVotes(
       // 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) superseded.add(rv);
+        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/src/mind/graph-search.ts

@@ -96,6 +96,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;
   };
 type OutItem = Extract<GItem, { kind: "out" }>;
 
@@ -138,6 +150,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;
 }
 
 /** Read the chosen spans back off a derivation: the goal is a chain of bridge
@@ -155,6 +170,7 @@ function readCover(derivation: Derivation<GItem>): Seg[] {
         bytes: out.bytes,
         rec: out.rec,
         node: out.node,
+        computed: out.computed,
       });
     }
     node = node.premises[0];
@@ -356,6 +372,7 @@ export class GraphSearch {
     conceptTarget: ReadonlyMap<number, number>,
     leaves: ReadonlyArray<Leaf>,
     splits: ReadonlySet<number>,
+    starts: ReadonlySet<number>,
     substitutions?: ReadonlyMap<number, Uint8Array>,
     connectors?: ReadonlyMap<string, Uint8Array>,
     computedResults?: ReadonlyArray<ComputedResult>,
@@ -377,6 +394,7 @@ export class GraphSearch {
         sites,
         leaves,
         splits,
+        starts,
       },
       conceptTarget,
       substitutions,
@@ -405,6 +423,7 @@ export class GraphSearch {
       sites: ReadonlyArray<Site>;
       leaves: ReadonlyArray<Leaf>;
       splits: ReadonlySet<number>;
+      starts: ReadonlySet<number>;
     },
     conceptTarget: ReadonlyMap<number, number>,
     substitutions?: ReadonlyMap<number, Uint8Array>,
@@ -418,6 +437,7 @@ export class GraphSearch {
       conceptTarget,
       recognition.leaves,
       recognition.splits,
+      recognition.starts,
       substitutions,
       connectors,
       computedResults,
@@ -448,11 +468,22 @@ export class GraphSearch {
     conceptTarget: ReadonlyMap<number, number>,
     leaves: ReadonlyArray<Leaf>,
     splits: ReadonlySet<number>,
+    starts: ReadonlySet<number>,
     substitutions?: ReadonlyMap<number, Uint8Array>,
     connectors?: ReadonlyMap<string, Uint8Array>,
     computedResults?: ReadonlyArray<ComputedResult>,
   ): DeductionSystem<GItem> {
     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: number) => 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.
@@ -550,6 +581,7 @@ export class GraphSearch {
               cover: true,
               rec: true,
               node: u.node,
+              computed: true,
             },
             cost: STEP,
           };
@@ -588,6 +620,8 @@ export class GraphSearch {
         return this.outRules(it, {
           W,
           splits,
+          starts,
+          atomsAreHubs,
           coversDone,
           outsByStart,
           outsByEnd,
@@ -949,6 +983,8 @@ export class GraphSearch {
     ctx: {
       W: number;
       splits: ReadonlySet<number>;
+      starts: ReadonlySet<number>;
+      atomsAreHubs: boolean;
       coversDone: Set<number>;
       outsByStart: Map<number, OutItem[]>;
       outsByEnd: Map<number, OutItem[]>;
@@ -1095,12 +1131,30 @@ export class GraphSearch {
     r: OutItem,
     ctx: {
       W: number;
+      starts: ReadonlySet<number>;
+      atomsAreHubs: boolean;
       findLeafU: (b: Uint8Array) => number | undefined;
       findBranchU: (k: number[]) => number | undefined;
     },
   ): Iterable<Rule<GItem>> {
     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
@@ -1108,7 +1162,10 @@ 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/src/mind/mechanisms/alu.ts

@@ -16,7 +16,14 @@ import type { PipelineMechanism } from "../pipeline-mechanism.js";
 export function aluToMechanism(alu: Alu): PipelineMechanism {
   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/src/mind/mechanisms/cast.ts

@@ -102,18 +102,43 @@ export async function counterfactualTransfer(
   query: Uint8Array,
   pre: Precomputed,
 ): Promise<CastResult[]> {
+  // 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: string): CastResult[] => {
+    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`,
+    );
+  }
 
   type Point = typeof points[0];
 
@@ -154,18 +179,31 @@ export async function counterfactualTransfer(
   const isRoot = (id: number) => 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))) return [];
+  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 [];
+  if (!woven) {
+    return fail(
+      `every aligned run restates a recognised query site — nothing was ` +
+        `actually WOVEN across structures, so there is nothing to transfer`,
+    );
+  }
 
-  const t = ctx.trace?.enter("counterfactual", [
-    rItem(query, "query"),
-  ]);
   // 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