@hviana/sema 0.2.9 → 0.4.0

package/dist/src/mind/pipeline-mechanism.js

@@ -12,11 +12,13 @@
 //   3. VISIBLE BUDGET — every mechanism carries its own caps internally (√N, k).
 //   4. TRAVELING EVIDENCE — run() returns MechanismResult with accounted, moves,
 //      and unexplained.  The pipeline computes the weight.
+import { indexOf } from "../bytes.js";
+import { dominates } from "../geometry.js";
 import { windowIds } from "./canonical.js";
 import { read, resolve } from "./primitives.js";
-import { alignGraded } from "./match.js";
+import { alignGraded, skillExemplar } from "./match.js";
 import { climbAttentionAll } from "./attention.js";
-import { skillExemplar } from "./mechanisms/extraction.js";
+import { sharedReachMemo } from "./traverse.js";
 // ── Precomputed ──────────────────────────────────────────────────────────────
 //
 // Precomputed is a LAZY container for structural analyses of the query — the
@@ -88,29 +90,46 @@ export class Precomputed {
         return w;
     }
     /** Shared memo for {@link reachOf} (structural-IDF reads): a window's
-     *  ancestor reach is a pure function of the read-only store, so one
-     *  response-scoped memo serves every mechanism that prices commonality. */
-    reachMemo = new Map();
+     *  ancestor reach is a pure function of the read-only store, so one memo
+     *  serves every mechanism that prices commonality — AND the consensus
+     *  climb, which is the largest consumer and used to build its own.  The
+     *  ONE definition of its lifetime lives in traverse.ts
+     *  ({@link sharedReachMemo}): response-scoped for respond(),
+     *  conversation-scoped across turns, always cold under a trace. */
+    _reach;
+    get reachMemo() {
+        return this._reach ??= sharedReachMemo(this.ctx);
+    }
     // ── Expensive lazy analyses ───────────────────────────────────────────
     //
     // Async, cached-by-promise: the first caller starts the computation, every
     // later caller (any mechanism, any phase) awaits the same promise.  A
     // mechanism MUST check its cheap floor gates and the pipeline's
     // `worthRunning` predicate before first-touching one of these.
+    /** Charge a lazily-shared analysis to its OWN phase rather than to the
+     *  mechanism that happened to first-touch it.  Without this the profile
+     *  reads as "cast.floor costs 2 s" when what actually cost 2 s is the
+     *  consensus climb — which cast merely paid for on everyone's behalf, and
+     *  which every later consumer then got free.  Attribution must follow the
+     *  work, not the caller. */
+    shared(phase, fn) {
+        const meter = this.ctx.meter;
+        return meter ? meter.time(phase, fn) : fn();
+    }
     _attention;
     /** The full consensus climb (roots + ranked anchors) — the query-level
      *  evidence CAST, confluence, extraction, recall's scaffolding tier, and
      *  fusion all share.  Computed on first access; a query no mechanism
      *  climbs for (e.g. one an extension decided outright) never pays for it. */
     attention() {
-        return this._attention ??= climbAttentionAll(this.ctx, this.query, this.k);
+        return this._attention ??= this.shared("attention", () => climbAttentionAll(this.ctx, this.query, this.k));
     }
     _weave;
     /** Result of {@link alignGraded} for the first k ranked anchors —
      *  O(k · |query| · |ctx|).  Consumed by CAST; reusable by any future
      *  mechanism doing analogical transfer. */
     weave() {
-        return this._weave ??= this.attention().then((climb) => computeWeave(this.ctx, this.query, this, climb));
+        return this._weave ??= this.attention().then((climb) => this.shared("weave", async () => computeWeave(this.ctx, this.query, this, climb)));
     }
     /** Span-shaped classification of one ranked anchor, memoised per anchor id
      *  so repeated calls (extraction's own early-exit scan, any future
@@ -124,7 +143,7 @@ export class Precomputed {
     spanShapedOf(anchor) {
         let p = this._spanShaped.get(anchor);
         if (p === undefined) {
-            p = skillExemplar(this.ctx, anchor, this.guide);
+            p = this.shared("spanShaped", () => skillExemplar(this.ctx, anchor, this.guide));
             this._spanShaped.set(anchor, p);
         }
         return p;
@@ -152,6 +171,7 @@ function computeWeave(ctx, query, pre, climb) {
     const rankedCapped = ranked.length > pre.k ? ranked.slice(0, pre.k) : ranked;
     const depth = new Float64Array(query.length);
     const points = [];
+    const byAnchor = new Map();
     // WEAVE-SCALE anchors only: CAST transfers structure between things the
     // QUERY weaves together — query-scale structures.  A context an order of
     // magnitude beyond the query is not woven BY the query (the query can at
@@ -166,6 +186,34 @@ function computeWeave(ctx, query, pre, climb) {
     // uncapped weaves spent 5–8s per query recognising conversation-length
     // anchors that could never form a weave point.
     const capBytes = query.length * quantum;
+    // EXCLUSIVITY IS ARBITRATED BY THE CLIMB'S VOTE ORDER, DELIBERATELY.  A query
+    // byte can only be independent evidence for ONE point, so points are built in
+    // ranked order and each new point's runs are trimmed against every point
+    // already accepted; a point left with no run of a full quantum drops out of
+    // the weave.
+    //
+    // That reads like first-come-wins — a point that merely ranked higher taking
+    // a span from the point that actually explains it — and arbitrating by LOCAL
+    // evidence instead (ownership of each byte to the longest covering run, then
+    // the heavier weight, then rank) was implemented and MEASURED: test/29 went
+    // 9/2 to 7/4, and the new failures name the reason. CAST requires the weave
+    // to touch a COMMITTED point of attention ("2 aligned structure(s), but none
+    // is one of the climb's 1 committed root(s)"), and it was precisely the vote
+    // order that kept the committed root's own point alive in the weave. Local
+    // run length knows nothing about what the climb settled on, so it evicted the
+    // root's evidence and left CAST refusing on its own consistency check.
+    //
+    // So the vote order here is not an accident of construction — it is what
+    // holds the weave and the climb to the same conclusion. Weave-local
+    // measures decide what is FRAME inside the weave (see the frame gates in
+    // cast.ts); which structures are in the weave at all stays the climb's call.
+    //
+    // TWO PASSES.  `depth` — how much of the weave agrees on each query byte, and
+    // therefore what counts as FRAME — must be the whole weave's, not "whatever
+    // has been processed so far": read in one pass it made a candidate's own
+    // frame reading depend on its rank, and the proposed-run gate below needs the
+    // real thing.
+    const cands = [];
     for (const cand of rankedCapped) {
         const ctxBytes = read(ctx, cand.anchor, capBytes + 1);
         if (ctxBytes.length === 0 || ctxBytes.length > capBytes)
@@ -177,6 +225,9 @@ function computeWeave(ctx, query, pre, climb) {
             for (let i = r.qs; i < r.qe; i++)
                 depth[i] += r.weight;
         }
+        cands.push({ cand, ctxBytes, raw });
+    }
+    for (const { cand, ctxBytes, raw } of cands) {
         const free = [];
         for (const r of raw) {
             let { qs, qe, cs, weight } = r;
@@ -201,12 +252,130 @@ function computeWeave(ctx, query, pre, climb) {
             }
         }
         if (free.length > 0) {
-            points.push({
+            const pt = {
                 anchor: cand.anchor,
                 vote: cand.vote,
                 ctx: ctxBytes,
                 runs: free,
-            });
+            };
+            byAnchor.set(cand.anchor, pt);
+            points.push(pt);
+        }
+    }
+    // A byte is FRAME when more than half the weave shares it, and a SPAN is
+    // frame when more than half its bytes are — the same two-level
+    // half-dominance reading cast.ts's own frame gate uses, over the same
+    // `depth`.  Read against the accepted POINTS (as cast.ts does), so it is
+    // only meaningful once phase 1 has run.
+    const framed = (from, to) => {
+        let n = 0;
+        for (let i = from; i < to; i++)
+            if (dominates(depth[i], points.length))
+                n++;
+        return dominates(n, to - from);
+    };
+    // PHASE 2 — THE CLIMB'S OWN CONCLUSION IS AN ALIGNMENT THE LITERAL MATCHER
+    // CANNOT SEE.  `alignRuns` seeds on W-grams, so two forms differing by a
+    // single byte share no run at all: on `How is ice like steel?` against a
+    // store holding `Ice is cold`, the query's `ice` and the stored `Ice` agree
+    // on only `ce ` — three bytes, never seeded — so that structure entered the
+    // weave carrying nothing but the ` is ` scaffolding every exemplar shares,
+    // lost it to the first point that claimed it, and vanished.  The climb had
+    // ALREADY identified it: its resonance elected `Ice is cold` from the query
+    // span `ce l` and `Steel is hard` from `stee`, two disjoint spans each naming
+    // its own structure, weighed through the region's contrastive margin and its
+    // IDF — gates the aligner has no equivalent of.
+    //
+    // So the climb PROPOSES the pairing (which structure, which query span) and
+    // bytes DECIDE its terms (§2.3).  Three gates, each one measured:
+    //
+    //   • it may only take query bytes NO literal run claimed.  Run inline with
+    //     phase 1 this did the opposite of "exact decides" — a higher-ranked
+    //     candidate's proposal trimmed a lower-ranked candidate's byte-for-byte
+    //     match out of existence (`he W`, proposed for `a nickname meaning the
+    //     divine one`, cut the literal `The ` out of `The Starry Night was
+    //     painted by Vincent van Gogh.` and CAST's redirection lost its
+    //     dominant — test/29 C4).  Hence a second pass, after every literal run
+    //     is placed.
+    //   • the literal agreement must DOMINATE the span.  A climb vote is not by
+    //     itself an alignment: on `The Persistence of Memory was painted by
+    //     Salvador Dali.` the climb elects `The Starry Night…` from the span
+    //     ` Dali.`, which shares barely a byte with it — the resonance was
+    //     carried by the frame those exemplars share.  Admitting it let CAST
+    //     weave points out of pure scaffolding and out-account the correct
+    //     extraction (test/00, test/24).  Where the proposal is real the
+    //     agreement is overwhelming: both C1 spans agree on three of four bytes.
+    //   • and the span must not be FRAME.  Literal dominance alone is too weak
+    //     at this scale — a 4-byte span agrees three-of-four with half the
+    //     corpus by accident (`he W` against `a nickname meaning the divine
+    //     one`).  Frame is the weave-local measure of exactly that.
+    const claimed = new Uint8Array(query.length);
+    for (const p of points) {
+        for (const r of p.runs)
+            claimed.fill(1, r.qs, r.qe);
+    }
+    for (const { cand, ctxBytes } of cands) {
+        if (cand.end > cand.start) {
+            let qs = cand.start;
+            let qe = cand.end;
+            while (qs < qe && claimed[qs])
+                qs++;
+            while (qe > qs && claimed[qe - 1])
+                qe--;
+            let clear = true;
+            for (let i = qs; i < qe; i++)
+                if (claimed[i])
+                    clear = false;
+            if (clear && qe - qs >= Math.min(quantum, ctxBytes.length)) {
+                // The gate only asks whether the agreement DOMINATES the span, so
+                // search DOWNWARD from the whole span and stop at the first hit: the
+                // first length found is both the longest agreement and, by
+                // construction, already past the dominance bar.  At most O(W²) bounded
+                // substring probes — a span is one segment (≤ 2W) — where a full
+                // longest-common-substring scan would be O(|span|² · |ctx|) against a
+                // context that may be W× the query.
+                const span = query.subarray(qs, qe);
+                const bar = Math.floor(span.length / 2) + 1; // dominates(bar, length)
+                let bestLen = 0;
+                let bestCs = 0;
+                for (let len = span.length; len >= bar && bestLen === 0; len--) {
+                    for (let off = 0; off + len <= span.length; off++) {
+                        const at = indexOf(ctxBytes, span.subarray(off, off + len), 0);
+                        if (at < 0)
+                            continue;
+                        bestLen = len;
+                        // Where the span's FIRST byte lands, so `cs` means the same thing
+                        // it does for a literal run: the context offset the run starts at.
+                        bestCs = Math.max(0, at - off);
+                        break;
+                    }
+                }
+                if (bestLen > 0 && !framed(qs, qe)) {
+                    const run = {
+                        qs,
+                        qe,
+                        cs: bestCs,
+                        weight: bestLen / (qe - qs),
+                        proposed: true,
+                    };
+                    claimed.fill(1, qs, qe);
+                    const pt = byAnchor.get(cand.anchor);
+                    if (!pt) {
+                        const made = {
+                            anchor: cand.anchor,
+                            vote: cand.vote,
+                            ctx: ctxBytes,
+                            runs: [run],
+                        };
+                        byAnchor.set(cand.anchor, made);
+                        points.push(made);
+                    }
+                    else {
+                        pt.runs.push(run);
+                        pt.runs.sort((x, y) => x.qs - y.qs);
+                    }
+                }
+            }
         }
     }
     return { points, depth };

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

@@ -8,6 +8,35 @@ export interface Thought {
     bytes: Uint8Array;
     provenance: Provenance;
 }
+/** Structured payload of the "decideGrounding" rationale step — the same
+ *  numbers the human-readable candidate labels already carry, exposed as
+ *  data so a downstream tool need not parse free text.  Purely additive
+ *  instrumentation: built only under `ctx.trace?.` (optional chaining
+ *  short-circuits its arguments), never read by inference. */
+export interface DecideGroundingData {
+    version: 1;
+    /** Every grounding candidate weighed, in consideration order. */
+    candidates: Array<{
+        provenance: string;
+        /** The candidate's exact weight in the one cost ladder. */
+        weight: number;
+        /** The DISCRETE grade the decision actually compares (floor(weight/STEP)). */
+        grade: number;
+        /** Query bytes the candidate's accounted spans leave unexplained. */
+        unexplainedBytes: number;
+        /** Whether this candidate won the decision. */
+        decided: boolean;
+    }>;
+    /** Grade margin between the winner and the runner-up, when both exist —
+     *  the same quantity the "narrowDecision" step reports as narrow when
+     *  ≤ 1.  Absent for a single-candidate decision. */
+    runnerUpMargin?: number;
+}
+/** Structured payload of the "narrowDecision" rationale step. */
+export interface NarrowDecisionData {
+    version: 1;
+    margin: number;
+}
 /** Think: a single lightest-derivation exploration of the Sema graph.
  *
  *  Every answer travels the same path:

package/dist/src/mind/pipeline.js

@@ -25,11 +25,16 @@ import { recallMechanism } from "./mechanisms/recall.js";
 export { resolveConcepts, resolveConnectors } from "./mechanisms/cover.js";
 export { aluToMechanism } from "./mechanisms/alu.js";
 // ── Extension dispatch (pre-loop parse) ─────────────────────────────────────
-async function collectComputed(mechanisms, query) {
+async function collectComputed(ctx, mechanisms, query) {
     const out = [];
+    const meter = ctx.meter;
     for (const m of mechanisms) {
-        if (m.parse)
-            out.push(...await m.parse(query));
+        if (!m.parse)
+            continue;
+        const spans = meter
+            ? await meter.time(`${m.name}.parse`, () => m.parse(query))
+            : await m.parse(query);
+        out.push(...spans);
     }
     return out;
 }
@@ -76,7 +81,7 @@ export async function think(ctx, query, mechs) {
     const mechanisms = mechs ?? defaultMechanisms;
     const rec = recognise(ctx, query);
     // Phase 1: collect computed spans from mechanisms that implement parse()
-    const computed = await collectComputed(mechanisms, query);
+    const computed = await collectComputed(ctx, mechanisms, query);
     if (computed.length > 0) {
         ctx.trace?.step("computeExtensions", [rItem(query, "query")], computed.map((u) => rItem(query.subarray(u.i, u.j), "operand", undefined, [u.i, u.j])), `extensions recognised and evaluated ${computed.length} computation(s)`);
         for (const u of computed) {
@@ -99,14 +104,28 @@ export async function think(ctx, query, mechs) {
     const consider = (c) => {
         if (c.bytes.length === 0)
             return;
+        if (ctx.meter)
+            ctx.meter.candidates++;
         candidates.push(c);
         if (best === null || grade(c.weight) < grade(best.weight))
             best = c;
     };
     const worthRunning = (floor) => best === null || grade(floor) < grade(best.weight);
     // Phase 3: grounding loop
+    // Per-mechanism accounting (src/meter.ts).  The market's whole premise is
+    // that mechanisms compete on one cost scale — so the profiling read-out is
+    // also per-mechanism, uniformly: the loop never asks which one it holds.
+    const meter = ctx.meter;
     for (const mech of mechanisms) {
-        const floor = await mech.floor(ctx, query, pre, worthRunning);
+        const floor = meter
+            ? await meter.time(`${mech.name}.floor`, () => mech.floor(ctx, query, pre, worthRunning))
+            : await mech.floor(ctx, query, pre, worthRunning);
+        if (meter) {
+            if (floor === null)
+                meter.mechanismSkips++;
+            else
+                meter.mechanismFloors++;
+        }
         if (floor === null) {
             ctx.trace?.step("skipMechanism", [], [], `${mech.name} skipped — structural precondition failed`);
             continue;
@@ -115,7 +134,11 @@ export async function think(ctx, query, mechs) {
             ctx.trace?.step("skipMechanism", [], [], `${mech.name} skipped — floor ${floor} cannot beat incumbent (grade ${grade(best.weight)})`);
             continue;
         }
-        const results = await mech.run(ctx, query, pre);
+        if (meter)
+            meter.mechanismRuns++;
+        const results = meter
+            ? await meter.time(`${mech.name}.run`, () => mech.run(ctx, query, pre))
+            : await mech.run(ctx, query, pre);
         for (const r of results) {
             const weight = r.weight ?? weigh(r.accounted, r.moves);
             consider({
@@ -125,6 +148,7 @@ export async function think(ctx, query, mechs) {
                 used: r.used,
                 accounted: r.accounted,
                 unexplained: r.unexplained,
+                complete: r.complete,
             });
         }
     }
@@ -132,9 +156,12 @@ export async function think(ctx, query, mechs) {
     // initial null, so the read-back needs the assertion.)
     const decided = best;
     if (candidates.length > 1) {
-        ctx.trace?.step("decideGrounding", candidates.map((c) => rItem(c.bytes, `${c.provenance} (weight ${c.weight.toFixed(3)}${c.unexplained ? `, unexplained: "${c.unexplained}"` : ""})`)), decided ? [rItem(decided.bytes, decided.provenance)] : [], "the lightest grounding derivation wins — every mechanism weighed in the one cost ladder");
+        // The runner-up is computed BEFORE the decideGrounding step so its grade
+        // margin can ride along in the step's structured data payload; the
+        // computation itself is pure and was always unconditional — only its
+        // position moved.
+        let runnerUp = null;
         if (decided !== null) {
-            let runnerUp = null;
             for (const c of candidates) {
                 if (c === decided)
                     continue;
@@ -142,15 +169,28 @@ export async function think(ctx, query, mechs) {
                     runnerUp = c;
                 }
             }
-            if (runnerUp !== null) {
-                const margin = grade(runnerUp.weight) - grade(decided.weight);
-                if (margin <= 1) {
-                    ctx.trace?.step("narrowDecision", [
-                        rItem(decided.bytes, `${decided.provenance} (weight ${decided.weight.toFixed(3)})`),
-                    ], [
-                        rItem(runnerUp.bytes, `${runnerUp.provenance} (weight ${runnerUp.weight.toFixed(3)})`),
-                    ], `margin ${margin} grade-unit(s) — the decision could change with one more training fact`);
-                }
+        }
+        const margin = decided !== null && runnerUp !== null
+            ? grade(runnerUp.weight) - grade(decided.weight)
+            : null;
+        ctx.trace?.step("decideGrounding", candidates.map((c) => rItem(c.bytes, `${c.provenance} (weight ${c.weight.toFixed(3)}${c.unexplained ? `, unexplained: "${c.unexplained}"` : ""})`)), decided ? [rItem(decided.bytes, decided.provenance)] : [], "the lightest grounding derivation wins — every mechanism weighed in the one cost ladder", undefined, {
+            version: 1,
+            candidates: candidates.map((c) => ({
+                provenance: c.provenance,
+                weight: c.weight,
+                grade: grade(c.weight),
+                unexplainedBytes: unaccounted(c.accounted),
+                decided: c === decided,
+            })),
+            ...(margin !== null ? { runnerUpMargin: margin } : {}),
+        });
+        if (decided !== null && runnerUp !== null && margin !== null) {
+            if (margin <= 1) {
+                ctx.trace?.step("narrowDecision", [
+                    rItem(decided.bytes, `${decided.provenance} (weight ${decided.weight.toFixed(3)})`),
+                ], [
+                    rItem(runnerUp.bytes, `${runnerUp.provenance} (weight ${runnerUp.weight.toFixed(3)})`),
+                ], `margin ${margin} grade-unit(s) — the decision could change with one more training fact`, undefined, { version: 1, margin });
             }
         }
     }
@@ -176,7 +216,13 @@ export async function think(ctx, query, mechs) {
         : provenance === "recall" || provenance === "recall-echo"
             ? new Set()
             : new Set(recognise(ctx, answer).sites.map((s) => s.payload));
-    const reasoned = await reason(ctx, query, answer, preConsumed, pre);
+    // 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
+    // fact that produced it (see MechanismResult.complete).
+    const reasoned = decided.complete ? answer : meter
+        ? await meter.time("reason", () => reason(ctx, query, answer, preConsumed, pre))
+        : await reason(ctx, query, answer, preConsumed, 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
@@ -209,9 +255,21 @@ export async function think(ctx, query, mechs) {
     // 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;
+    // Where the winning grounding stands in the query — fusion places primary
+    // by it (see fuseAttention's `primarySpans`).  `accounted` is the
+    // cost-ladder read and is authoritative when non-empty; when it is empty
+    // the grounding is a pure COMPUTATION, whose evidence is its computed span.
+    // Exactly the cost-ladder-vs-coverage distinction `explained` above draws,
+    // read here for POSITION instead of for coverage — and resolved here, where
+    // both readings are in hand, rather than inside fuseAttention.
+    const primarySpans = decided.accounted.length > 0
+        ? decided.accounted
+        : pre.computed.map((u) => [u.i, u.j]);
+    const fused = remainder < ctx.space.maxGroup
+        ? reasoned
+        : meter
+            ? await meter.time("fuse", () => fuseAttention(ctx, query, reasoned, pre, unclimbed, primarySpans))
+            : await fuseAttention(ctx, query, reasoned, pre, unclimbed, decided.accounted);
     done(fused, "grounded, reasoned forward, fused across points of attention");
     return { bytes: fused, provenance };
 }

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

@@ -15,21 +15,17 @@ export declare function latin1Key(bytes: Uint8Array): string;
  *  CALLER — who assembled the multi-turn context — knows where those
  *  boundaries are; the geometry never guesses them from the bytes. */
 export declare function perceive(ctx: MindContext, input: Input, leafAt?: (i: number) => number | null, lookup?: (ids: number[]) => number | null, boundaries?: readonly number[]): Sema;
-/** The DEPOSIT-shaped perceive.  A FIRST-SEEN input takes the PLAIN fold
- *  (bit-identical to inference perception of a standalone query — that
- *  structural train/inference agreement is load-bearing for exact recall),
- *  computed incrementally via the fold's level pyramid
- *  ({@link bytesToTreePyramid}).  An input that EXTENDS a previously
- *  deposited one is a conversation context grown by one turn — the cached
- *  prefix length IS the turn boundary (derived from the deposit sequence
- *  itself, never from content conventions) — and takes the STABLE-PREFIX
- *  fold over the accumulated boundaries, bit-identical to the boundary
- *  fold query-time conversation perception uses, so the trained context
- *  node and the query's context subtree are the SAME node.  Segment folds
- *  reuse across deposits ({@link stablePrefixFoldIncremental}) — O(turn)
- *  instead of O(context) per turn.  The fold state is purely a cache; the
- *  boundary accumulation is what an evicted chain loses (falling back to
- *  the plain fold, the pre-boundary shape — a warm replay restores it). */
+/** The DEPOSIT-shaped perceive.  Folds over the stream's own content cuts —
+ *  bit-identical to what inference computes for the same bytes, and that
+ *  train/inference agreement is load-bearing for exact recall.  An input that
+ *  EXTENDS a previously deposited one is a conversation context grown by one
+ *  turn; the cached prefix length IS the turn boundary (derived from the deposit
+ *  sequence itself, never from a content convention) and joins the cut set, so
+ *  the trained context node and the query's context subtree are the SAME node.
+ *  Segment folds reuse across deposits ({@link stablePrefixFoldIncremental}) —
+ *  O(turn) instead of O(context) per turn.  All of it is purely a cache: an
+ *  evicted chain loses only the turn boundaries, and since the content cuts do
+ *  not depend on the cache, the segments themselves are unchanged. */
 export declare function perceiveDeposit(ctx: MindContext, bytes: Uint8Array, conversational?: boolean): Sema;
 /** The raw bytes of an input — modality-neutral conversion. */
 export declare function inputBytes(ctx: MindContext, input: Input): Uint8Array;

package/dist/src/mind/primitives.js

@@ -2,7 +2,7 @@
 //
 //   Address  — bytes → node   (perceive, foldTree, resolve)
 //   Read     — node → bytes   (read)
-import { bytesToTree, bytesToTreePyramid, gridToTree, hilbertBytes, stablePrefixFoldIncremental, stackGrids, } from "../geometry.js";
+import { bytesToTree, gridToTree, hilbertBytes, stablePrefixFoldIncremental, stackGrids, } from "../geometry.js";
 import { canonHash } from "../canon.js";
 import { bytesEqual } from "../bytes.js";
 import { ALL } from "./types.js";
@@ -43,12 +43,23 @@ export function perceive(ctx, input, leafAt, lookup, boundaries) {
             if (memo) {
                 const key = latin1Key(bytes);
                 const hit = memo.get(key);
-                if (hit !== undefined)
+                if (hit !== undefined) {
+                    if (ctx.meter)
+                        ctx.meter.perceiveHits++;
                     return hit;
+                }
+                if (ctx.meter) {
+                    ctx.meter.perceptions++;
+                    ctx.meter.perceivedBytes += bytes.length;
+                }
                 const tree = bytesToTree(ctx.space, ctx.alphabet, bytes, undefined, undefined, boundaries);
                 memo.set(key, tree);
                 return tree;
             }
+            if (ctx.meter) {
+                ctx.meter.perceptions++;
+                ctx.meter.perceivedBytes += bytes.length;
+            }
             return bytesToTree(ctx.space, ctx.alphabet, bytes, undefined, undefined, boundaries);
         }
         return bytesToTree(ctx.space, ctx.alphabet, bytes, leafAt, lookup);
@@ -58,21 +69,17 @@ export function perceive(ctx, input, leafAt, lookup, boundaries) {
     }
     return gridToTree(ctx.space, ctx.alphabet, input);
 }
-/** The DEPOSIT-shaped perceive.  A FIRST-SEEN input takes the PLAIN fold
- *  (bit-identical to inference perception of a standalone query — that
- *  structural train/inference agreement is load-bearing for exact recall),
- *  computed incrementally via the fold's level pyramid
- *  ({@link bytesToTreePyramid}).  An input that EXTENDS a previously
- *  deposited one is a conversation context grown by one turn — the cached
- *  prefix length IS the turn boundary (derived from the deposit sequence
- *  itself, never from content conventions) — and takes the STABLE-PREFIX
- *  fold over the accumulated boundaries, bit-identical to the boundary
- *  fold query-time conversation perception uses, so the trained context
- *  node and the query's context subtree are the SAME node.  Segment folds
- *  reuse across deposits ({@link stablePrefixFoldIncremental}) — O(turn)
- *  instead of O(context) per turn.  The fold state is purely a cache; the
- *  boundary accumulation is what an evicted chain loses (falling back to
- *  the plain fold, the pre-boundary shape — a warm replay restores it). */
+/** The DEPOSIT-shaped perceive.  Folds over the stream's own content cuts —
+ *  bit-identical to what inference computes for the same bytes, and that
+ *  train/inference agreement is load-bearing for exact recall.  An input that
+ *  EXTENDS a previously deposited one is a conversation context grown by one
+ *  turn; the cached prefix length IS the turn boundary (derived from the deposit
+ *  sequence itself, never from a content convention) and joins the cut set, so
+ *  the trained context node and the query's context subtree are the SAME node.
+ *  Segment folds reuse across deposits ({@link stablePrefixFoldIncremental}) —
+ *  O(turn) instead of O(context) per turn.  All of it is purely a cache: an
+ *  evicted chain loses only the turn boundaries, and since the content cuts do
+ *  not depend on the cache, the segments themselves are unchanged. */
 export function perceiveDeposit(ctx, bytes, conversational = false) {
     let prev;
     let prefixLen = 0;
@@ -99,19 +106,27 @@ export function perceiveDeposit(ctx, bytes, conversational = false) {
             }
         }
     }
-    let tree;
-    let entry;
+    // ONLY turn boundaries belong here.  The stream's own content cuts are NOT
+    // passed in: `bytesToTree` and `stablePrefixFoldIncremental` both derive them
+    // per span, at every level, and handing the level-0 cuts in as stable-prefix
+    // boundaries instead produces a LEFT-NESTED join of flat segments — a
+    // different tree from the one inference builds for the same bytes.  When that
+    // happened, a deposit's context root and `resolve(question)` were different
+    // nodes, so the trained edge hung off a node inference never reached and
+    // recall went silent (test/44 caught it as a site that could not be emitted
+    // because the resolved node led nowhere).  Train and infer must fold
+    // identically; the way to guarantee that is to give this function nothing
+    // extra to say.
+    const cuts = new Set();
     if (prev !== undefined) {
-        const boundaries = [...prev.boundaries, prefixLen];
-        const folded = stablePrefixFoldIncremental(ctx.space, ctx.alphabet, bytes, boundaries, prev.stable);
-        tree = folded.tree;
-        entry = { boundaries, stable: folded.fold };
-    }
-    else {
-        const plain = bytesToTreePyramid(ctx.space, ctx.alphabet, bytes);
-        tree = plain.tree;
-        entry = { boundaries: [], pyramid: plain.pyramid };
+        for (const b of prev.boundaries)
+            cuts.add(b);
+        cuts.add(prefixLen);
     }
+    const boundaries = [...cuts].sort((a, b) => a - b);
+    const folded = stablePrefixFoldIncremental(ctx.space, ctx.alphabet, bytes, boundaries, prev?.stable);
+    const tree = folded.tree;
+    const entry = { boundaries, stable: folded.fold };
     // Only a conversational deposit writes the cache too — otherwise a bare
     // fact's plain fold could later be misread as a conversation's turn-zero
     // boundary by an unrelated conversational deposit that happens to extend
@@ -193,6 +208,8 @@ export function foldTree(ctx, n, start, visit) {
 export function resolve(ctx, bytes) {
     if (bytes.length === 0)
         return null;
+    if (ctx.meter)
+        ctx.meter.resolves++;
     const exact = foldTree(ctx, perceive(ctx, bytes), 0).node;
     if (exact !== null)
         return exact;
@@ -235,6 +252,8 @@ export function canonResolve(ctx, bytes) {
         if (direct !== null)
             return set(direct);
     }
+    if (ctx.meter)
+        ctx.meter.canonLookups++;
     const candidates = store.canonFind(canonHash(key));
     if (candidates.length === 0)
         return set(null);

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

@@ -31,4 +31,10 @@ export declare function fuseAttention(ctx: MindContext, query: Uint8Array, prima
  *  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>;
+unclimbed?: boolean, 
+/** The query spans `primary`'s own grounding stands on — used ONLY to place
+ *  primary in the fused reading order (see below).  Resolved by the caller,
+ *  which is the layer that knows how a given grounding records its evidence;
+ *  fuseAttention just reads a position from it.  Empty or absent preserves
+ *  the original behaviour exactly. */
+primarySpans?: ReadonlyArray<readonly [number, number]>): Promise<Uint8Array>;