@hviana/sema 0.4.1 → 0.4.3

package/dist/src/mind/junction.js

@@ -53,15 +53,24 @@ export function junctionSeeds(ctx, b) {
     return [wids[0], wids[wids.length - 1]];
 }
 const walkCaches = new WeakMap();
+const WALK_CACHE_MAX = 100_000;
 export function walkCache(ctx) {
     if (ctx.climbMemo === null)
         return null;
-    let c = walkCaches.get(ctx.climbMemo);
+    let c = walkCaches.get(ctx._structMemoKey);
     if (c === undefined) {
-        walkCaches.set(ctx.climbMemo, c = { reads: new Map(), parents: new Map(), containers: new Map() });
+        walkCaches.set(ctx._structMemoKey, c = { reads: new Map(), parents: new Map(), containers: new Map() });
+    }
+    else if (c.reads.size + c.parents.size + c.containers.size >= WALK_CACHE_MAX) {
+        c.reads.clear();
+        c.parents.clear();
+        c.containers.clear();
     }
     return c;
 }
+export function invalidateJunctionCache(ctx) {
+    walkCaches.delete(ctx._structMemoKey);
+}
 export function cachedRead(ctx, cache, id, cap) {
     if (cache === null)
         return read(ctx, id, cap + 1);
@@ -253,13 +262,14 @@ export function junctionContainers(ctx, left, right, maxContainer, unordered = f
  *  cost is bounded at √N·W pops total regardless of how many siblings are
  *  tried.  A sibling whose bytes exceed `maxInterior` is skipped (it
  *  cannot be junction-sized). */
-export async function junctionSynonyms(ctx, left, right, maxInterior, unordered = false, sides) {
+export async function junctionSynonyms(ctx, left, right, maxInterior, unordered = false, sides, sharedBudget) {
     const s = sides ?? await loadJunctionSynonymSides(ctx, left, right);
     if (s.leftId === null && s.rightId === null)
         return [];
     // ── Tier 2.5a: single-synonym — one side replaced by a halo sibling ──────
     // ONE shared expansion budget across BOTH directions of this tier.
-    const singleBudget = { n: hubBound(ctx) * ctx.space.maxGroup };
+    const singleBudget = sharedBudget ??
+        { n: hubBound(ctx) * ctx.space.maxGroup };
     const singleOut = new Map();
     const keepBest = (map, j, tier, confidence) => {
         const prev = map.get(j.id);
@@ -313,7 +323,8 @@ export async function junctionSynonyms(ctx, left, right, maxInterior, unordered
         a.l.id - b.l.id ||
         a.r.id - b.r.id);
     const doubleOut = new Map();
-    const budget = { n: hubBound(ctx) * ctx.space.maxGroup };
+    const budget = sharedBudget ??
+        { n: hubBound(ctx) * ctx.space.maxGroup };
     const tries = Math.min(pairs.length, ctx.cfg.haloQueryK);
     for (let i = 0; i < tries; i++) {
         const { l, r, confidence } = pairs[i];

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

@@ -67,6 +67,21 @@ export declare function bestHaloMate<T>(ctx: MindContext, halo: Vec, items: Iter
     score: number;
 } | null;
 export declare function haloSiblings(ctx: MindContext, id: number, halo?: Vec | null, bar?: number): Promise<Hit[]>;
+/** Bundle the distributional company of every addressable W-window in a
+ *  byte span.  This is the query-time counterpart of the write-side halo
+ *  pours: no lexical unit or storage row is invented; the span is represented
+ *  by VSA superposition of the window concepts the store already knows.
+ *
+ *  Components are normalized before bundling so repetition mass remains
+ *  evidence about each stored node, not an accidental weight on one window
+ *  inside the composed phrase.  Returns null when the corpus provides no
+ *  distributional evidence for the span. */
+export declare function spanHalo(ctx: MindContext, bytes: Uint8Array, from?: number, to?: number): Vec | null;
+/** Distributional synonym evidence between arbitrary byte spans. Whole words
+ *  need not be independently interned: their stored W-window occurrences are
+ *  lifted to episode halos, bundled, and compared. The caller chooses the
+ *  derived gate appropriate to its claim (concept identity or analogy). */
+export declare function spanSynonymStrength(ctx: MindContext, a: Uint8Array, b: Uint8Array): number;
 /** The DISTRIBUTIONAL matcher between two nodes: mutual-nearest-neighbour
  *  strength, not a pick.  Returns the direct halo cosine, or failing that the
  *  highest mutual-halo-sibling min-score (second-order analogy), or failing

package/dist/src/mind/match.js

@@ -24,12 +24,12 @@
 // the PROJECTIONS (follow, conceptHop, reverseContext, project) — so each
 // mechanism file states only its configuration, never its own copy of the
 // machinery.  The gates all live in geometry.ts (derived, never tuned).
-import { cosine } from "../vec.js";
+import { addInto, cosine, dot, normalize, zeros } from "../vec.js";
 import { conceptThreshold, identityBar, significanceBar } from "../geometry.js";
 import { indexOf } from "../bytes.js";
 import { leafIdRun } from "./canonical.js";
 import { foldTree, gistOf, perceive, read, resolve } from "./primitives.js";
-import { argmaxCosine, chooseAmong, chooseNext, guidedFirst, hubBound, hubCap, } from "./traverse.js";
+import { argmaxCosine, chooseAmong, chooseNext, corpusN, edgeAncestors, guidedFirst, hubBound, hubCap, sharedReachMemo, } from "./traverse.js";
 import { recognise, segment } from "./recognition.js";
 // ═══════════════════════════════════════════════════════════════════════════
 // MATCHERS — locating learned structure in/against bytes, by graded strictness
@@ -276,6 +276,96 @@ export async function haloSiblings(ctx, id, halo, bar = conceptThreshold(ctx.sto
         memo.set(id, out);
     return out;
 }
+/** Bundle the distributional company of every addressable W-window in a
+ *  byte span.  This is the query-time counterpart of the write-side halo
+ *  pours: no lexical unit or storage row is invented; the span is represented
+ *  by VSA superposition of the window concepts the store already knows.
+ *
+ *  Components are normalized before bundling so repetition mass remains
+ *  evidence about each stored node, not an accidental weight on one window
+ *  inside the composed phrase.  Returns null when the corpus provides no
+ *  distributional evidence for the span. */
+export function spanHalo(ctx, bytes, from = 0, to = bytes.length) {
+    const W = ctx.space.maxGroup;
+    if (to - from < W)
+        return null;
+    if (ctx.meter)
+        ctx.meter.spanHalos++;
+    const out = zeros(ctx.store.D);
+    let found = false;
+    const added = new Set();
+    const episodeRoots = [];
+    const N = corpusN(ctx);
+    const reachMemo = sharedReachMemo(ctx);
+    const addHalo = (id) => {
+        if (added.has(id))
+            return;
+        const halo = ctx.store.halo(id);
+        if (halo === null)
+            return;
+        const norm = Math.sqrt(dot(halo, halo));
+        if (norm === 0)
+            return;
+        added.add(id);
+        addInto(out, halo, 1 / norm);
+        found = true;
+    };
+    const windowCount = to - from - W + 1;
+    const offsets = [];
+    const samples = Math.min(W, windowCount);
+    for (let i = 0; i < samples; i++) {
+        const relative = samples === 1
+            ? 0
+            : Math.floor((i * (windowCount - 1)) / (samples - 1));
+        const off = from + relative;
+        if (offsets[offsets.length - 1] !== off)
+            offsets.push(off);
+    }
+    for (const off of offsets) {
+        if (ctx.meter)
+            ctx.meter.spanHaloWindows++;
+        const ids = leafIdRun(ctx, bytes, off, off + W);
+        if (ids === null)
+            continue;
+        const id = ctx.store.findBranch(ids);
+        if (id === null)
+            continue;
+        addHalo(id);
+        // Canonical flat windows are retrieval addresses and normally carry no
+        // halo themselves. Their bounded structural ascent reaches the learned
+        // episode forms that contain them; bundling those forms' company is the
+        // distributional meaning of the window, derived entirely from existing
+        // containment and halo state.
+        if (!added.has(id)) {
+            episodeRoots.push(edgeAncestors(ctx, id, N, reachMemo).roots);
+        }
+    }
+    for (let rank = 0; added.size < ctx.cfg.haloQueryK; rank++) {
+        let any = false;
+        for (const roots of episodeRoots) {
+            if (rank >= roots.length)
+                continue;
+            any = true;
+            addHalo(roots[rank]);
+            if (added.size >= ctx.cfg.haloQueryK)
+                break;
+        }
+        if (!any)
+            break;
+    }
+    return found ? normalize(out) : null;
+}
+/** Distributional synonym evidence between arbitrary byte spans. Whole words
+ *  need not be independently interned: their stored W-window occurrences are
+ *  lifted to episode halos, bundled, and compared. The caller chooses the
+ *  derived gate appropriate to its claim (concept identity or analogy). */
+export function spanSynonymStrength(ctx, a, b) {
+    const ah = spanHalo(ctx, a);
+    const bh = spanHalo(ctx, b);
+    if (ah === null || bh === null)
+        return 0;
+    return cosine(ah, bh);
+}
 export async function analogyStrength(ctx, a, b) {
     const ha = ctx.store.halo(a);
     const hb = ctx.store.halo(b);

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

@@ -221,7 +221,18 @@ export async function counterfactualTransfer(ctx, query, pre) {
             ...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`);
+            `content the climb itself never settled on`, {
+            aligned: points.map((p) => ({
+                anchor: p.anchor,
+                vote: p.vote,
+                runs: p.runs.map((r) => ({ ...r })),
+                coveredBytes: p.runs.reduce((n, r) => n + r.qe - r.qs, 0),
+            })),
+            committedRoots: roots.map((r) => ({
+                anchor: r.anchor,
+                vote: r.vote,
+            })),
+        });
         return [];
     }
     const woven = points.some((p) => p.runs.some((r) => !pre.rec.sites.some((s) => r.qs >= s.start && r.qe <= s.end)));

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

@@ -68,7 +68,23 @@ export async function confluenceJoin(ctx, query, pre) {
     // with the query is the CONSTRAINT being re-named (or its scaffolding),
     // never the open seat the question asks for — subtracted by identity,
     // below.
-    const queryWin = pre.queryWindows;
+    // Completed assistant turns are context the engine already produced, not
+    // independent constraints asserted by the asker. Treating their windows as
+    // fresh constraints makes a cumulative dialogue's confluence work grow with
+    // every prior answer and can join the engine's own prose back into a reply.
+    // Recognition and attention still see the full transcript; only this
+    // mechanism's constraint population excludes answered spans.
+    const queryWin = new Map();
+    let answered = 0;
+    for (const [off, id] of pre.queryWindows) {
+        while (answered < ctx.answeredSpans.length &&
+            ctx.answeredSpans[answered][1] <= off)
+            answered++;
+        const span = ctx.answeredSpans[answered];
+        if (span && span[0] <= off && off + W <= span[1])
+            continue;
+        queryWin.set(off, id);
+    }
     const queryIds = new Set(queryWin.values());
     // A constraint must bind a CONSTITUENT, not a shard.  A genuinely shared
     // form weaves a contiguous RUN of shared discriminative windows — its
@@ -84,6 +100,17 @@ export async function confluenceJoin(ctx, query, pre) {
     const bindsAConstituent = (cover) => cover.some(([cs, ce]) => ce - cs >= 2 * W);
     const streams = [];
     const rankedCapped = ranked.length > pre.k ? ranked.slice(0, pre.k) : ranked;
+    // CONJUNCTIVITY EARLY-EXIT: a conjunctive query's top-ranked anchors
+    // (largest vote weight) must already form at least two independent
+    // constraint streams.  When the first W anchors yield fewer than 2, the
+    // query has at most one topic — no join to compute.  The full pre.k scan
+    // would produce the same null result after reading every anchor's bytes
+    // and computing window identities (profiled at 18K–50K leaf lookups per
+    // refusing query), so cutting the scan short here saves 50–70% of
+    // confluence cost on non-conjunctive queries while preserving every
+    // genuinely conjunctive case (whose top anchors ARE its constraints).
+    const earlyExit = Math.min(rankedCapped.length, ctx.space.maxGroup * 2);
+    let exitAfter = earlyExit;
     for (const cand of rankedCapped) {
         if (streams.some((s) => s.anchor === cand.anchor))
             continue;
@@ -111,6 +138,9 @@ export async function confluenceJoin(ctx, query, pre) {
         if (cover.length > 0 && bindsAConstituent(cover)) {
             streams.push({ anchor: cand.anchor, vote: cand.vote, ids, cover, held });
         }
+        // Early-exit: after 2W anchors, a non-conjunctive query is decided.
+        if (--exitAfter <= 0 && streams.length < 2)
+            return null;
     }
     if (streams.length < 2)
         return null;

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

@@ -2,5 +2,5 @@ import type { MindContext } from "../types.js";
 import type { Site } from "../graph-search.js";
 import type { PipelineMechanism } from "../pipeline-mechanism.js";
 export declare function resolveConcepts(ctx: MindContext, sites: Site[]): Promise<Map<number, number>>;
-export declare function resolveConnectors(ctx: MindContext, sites: ReadonlyArray<Site>): Promise<Map<string, Uint8Array>>;
+export declare function resolveConnectors(ctx: MindContext, sites: ReadonlyArray<Site>, query?: Uint8Array): Promise<Map<string, Uint8Array>>;
 export declare const coverMechanism: PipelineMechanism;

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

@@ -9,11 +9,12 @@
 // near-zero-cost incumbent that prunes the other mechanisms through the
 // ordinary admissible-floor check, with no extension special-case anywhere.
 import { read, resolve } from "../primitives.js";
-import { guidedFirst } from "../traverse.js";
+import { guidedFirst, hubBound } from "../traverse.js";
 import { conceptHop } from "../match.js";
 import { bridge } from "../resonance.js";
 import { liftAnswer, segRestatesQuery } from "../types.js";
 import { decodeText, unexplainedLabel } from "../rationale.js";
+import { indexOf } from "../../bytes.js";
 import { rItem, rNode, traceDerivation } from "../trace.js";
 // ── Concept / connector pre-resolution ──────────────────────────────────────
 export async function resolveConcepts(ctx, sites) {
@@ -34,10 +35,29 @@ export async function resolveConcepts(ctx, sites) {
     }
     return target;
 }
-export async function resolveConnectors(ctx, sites) {
+export async function resolveConnectors(ctx, sites, query) {
     const links = new Map();
-    const ordered = [...sites].sort((a, b) => a.start - b.start);
     const answerOf = (n) => guidedFirst(ctx, n) ?? n;
+    // A site's continuation already present elsewhere in the query is stale
+    // transcript evidence: cover still needs the site for structural context,
+    // but liftAnswer will trim that continuation as already answered. Building
+    // pairwise/n-ary bridges for it can only create connectors that are later
+    // discarded, and on cumulative dialogue that dominated the whole search.
+    let answered = 0;
+    const ordered = [...sites]
+        .sort((a, b) => a.start - b.start)
+        .filter((s) => {
+        while (answered < ctx.answeredSpans.length &&
+            ctx.answeredSpans[answered][1] <= s.start)
+            answered++;
+        const span = ctx.answeredSpans[answered];
+        if (span && span[0] <= s.start && s.end <= span[1])
+            return false;
+        if (query === undefined || ctx.answeredSpans.length === 0)
+            return true;
+        const continuations = ctx.store.nextFirst(s.payload, hubBound(ctx));
+        return !continuations.some((answer) => indexOf(query, read(ctx, answer), 0) >= 0);
+    });
     const bridgePair = async (l, r) => {
         if (l === r || links.has(l + "," + r))
             return;
@@ -119,7 +139,9 @@ export const coverMechanism = {
         }
         if (sites.length === 0 && computed.length === 0)
             return [];
-        const connectors = await resolveConnectors(ctx, sites);
+        const connectors = ctx.meter
+            ? await ctx.meter.time("cover.resolveConnectors", () => resolveConnectors(ctx, sites, query))
+            : await resolveConnectors(ctx, sites, query);
         let splits = rec.splits;
         let starts = rec.starts;
         if (computed.length > 0) {
@@ -135,7 +157,9 @@ export const coverMechanism = {
                 starts.add(u.j);
             }
         }
-        const concepts = await resolveConcepts(ctx, sites);
+        const concepts = ctx.meter
+            ? await ctx.meter.time("cover.resolveConcepts", () => resolveConcepts(ctx, sites))
+            : await resolveConcepts(ctx, sites);
         const coverDeps = [
             ctx.trace?.lastIndex("recognise"),
             ctx.trace?.lastIndex("computeExtensions"),

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

@@ -228,48 +228,24 @@ export async function recallByResonance(ctx, query, pre) {
         // refusing on the reach bar).  Approximate scores propose; the bridge's
         // byte-exact alignment and attestation gates decide.
         //
-        // The proposal breadth here is widened PAST `k` — first by requesting
-        // hubBound(ctx) candidates instead of `k` (recall's own tiers above
-        // stay at `k`; this re-resonates only on the refusal path, exactly
-        // where the bridge itself already runs), AND by asking the index to
-        // search EXHAUSTIVELY.  Both matter: the IVF only ever probes
-        // ⌈√clusters⌉ of them (store.ts's efFor) REGARDLESS of k — widening k
-        // alone just returns more hits from the SAME already-probed clusters,
-        // never a hit whose vector lives in an unprobed one.  Measured live:
-        // "What is the chemical symbol for water?" needs "What is the
-        // chemical formula for water?", scoring only 0.58 against the
-        // query's gist (a MIDDLE-of-string word swap perturbs the river-fold
-        // tree hash far more than a same-length TAIL swap like the "carbon"/
-        // "oxygen" neighbours that outrank it at 0.87+) — absent from the
-        // resonance list even at k=5000, present and byte-exact-verified the
-        // moment it's force-fed to the bridge directly.  `exhaustive` is the
-        // natural, tuning-free ceiling (probe every cluster) for a call that
-        // is ALREADY refusal-path-only and must not miss a candidate hiding
-        // behind an unlucky structural distance.
-        //
-        // MEASURED COST, AND WHY IT STAYS (17.9M vectors / 325K contexts):
-        // this one call is ~570 ms and ~45% of all inference time on a refusing
-        // query.  The cost is entirely `exhaustive` (nprobe = every cluster),
-        // NOT the widened k — timed on that store: k=571 exhaustive 632 ms,
-        // k=24 exhaustive 536 ms, k=571 NON-exhaustive 12 ms.  So narrowing k
-        // buys nothing and the 50x is the whole-index scan itself.
-        // It is load-bearing: over an 18-query battery the bridge produced a
-        // winner 4 times, and ALL FOUR winners came from this proposal channel
-        // — the anchor-climb channel won nothing on its own.  Reordering the
-        // channels (climb first, resonate only on failure) would therefore pay
-        // the climb, fail, and pay this anyway.  Do not weaken it without
-        // re-running that measurement.
-        // Handed to the bridge as a THUNK: this exhaustive whole-index probe is
-        // the most expensive single act on the refusal path, and the bridge's
-        // own cheap gates (query length, the O(|query|) stored-window anchor
-        // scan) can refuse without any proposal at all.  See substitutionBridge.
+        // Reuse recall's already-ranked proposals. Never scan every IVF cluster:
+        // exact co-occurrence and bounded anchor ascent are the bridge's structural
+        // proposal channels, while an exhaustive ANN call made every honest
+        // refusal cost hundreds of milliseconds regardless of k.
         const wideIds = async () => {
-            const wide = k >= hubBound(ctx)
-                ? whole
-                : ctx.meter
-                    ? await ctx.meter.time("recall.exhaustiveResonate", () => ctx.store.resonate(queryGist, hubBound(ctx), true))
-                    : await ctx.store.resonate(queryGist, hubBound(ctx), true);
-            return wide.map((h) => h.id);
+            // When the top resonance hit is below the concept threshold, the query
+            // gist has no concept-level match to any stored form — an exhaustive √N
+            // ANN would only score more vectors below the bar (profiled at 38K–40K
+            // annVectorReads per refusing query on a 325K-context store).  The
+            // bridge's structural channels (junction walks, anchor climbs) are the
+            // correct proposal source for a query whose gist has no clean match;
+            // the ANN cannot propose what the gist cannot rank.
+            const marketScale = k * ctx.space.maxGroup;
+            if (corpusN(ctx) <= marketScale ** 3) {
+                const exhaustive = await ctx.store.resonate(queryGist, hubBound(ctx), true);
+                return exhaustive.map((h) => h.id);
+            }
+            return whole.map((h) => h.id);
         };
         const bridged = await substitutionBridge(ctx, query, wideIds);
         if (bridged !== null) {

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

@@ -34,6 +34,10 @@ export interface ConversationState {
      *  is `boundaries[0]`; the second turn starts at that offset, and so
      *  on.  Empty for a single-turn or new conversation. */
     boundaries: number[];
+    /** Byte spans occupied by replies produced by this Mind. Unlike boundary
+     *  parity, this remains exact when a turn receives an empty reply. Optional
+     *  so states saved before the field existed remain restorable. */
+    answeredSpans?: Array<[number, number]>;
 }
 /** An active conversation handle.  Opaque — interact through the Mind's
  *  conversation methods ({@link Mind.beginConversation},
@@ -111,6 +115,7 @@ export declare class Mind implements MindContext {
     lastCost: CostReport | null;
     /** Memo of the consensus climb — content-keyed.  See {@link MindContext.climbMemo}. */
     climbMemo: Map<string, Map<string, AttentionRead>> | null;
+    _structMemoKey: object;
     /** Memo of recognise() — content-keyed.  See {@link MindContext.recogniseMemo}. */
     recogniseMemo: Map<string, Recognition> | null;
     /** Memo of perceive() — content-keyed.  See {@link MindContext.perceiveMemo}. */
@@ -120,6 +125,8 @@ export declare class Mind implements MindContext {
         id: number;
         len: number;
     }> | null;
+    answeredSpans: ReadonlyArray<readonly [number, number]>;
+    currentTurnStart: number;
     /** The perceived gist of the query currently being answered.  Set by `think`
      *  before the graph search runs; `chooseNext` consults it as a gate (a null
      *  guide means no query is in flight, so structural walkers keep plain

package/dist/src/mind/mind.js

@@ -20,7 +20,8 @@ import { GraphSearch, } from "./graph-search.js";
 import { Alu } from "../alu/src/index.js";
 import { decodeText, Rationale, } from "./rationale.js";
 import { gistOf, inputBytes, latin1Key, perceive as perceiveImpl, resolve as resolveImpl, } from "./primitives.js";
-import { chooseNext, edgeAncestors as edgeAncestorsFn } from "./traverse.js";
+import { chooseNext, edgeAncestors as edgeAncestorsFn, invalidateStructuralCaches, } from "./traverse.js";
+import { invalidateJunctionCache } from "./junction.js";
 import { follow } from "./match.js";
 import { recognise, segment } from "./recognition.js";
 import { meaningOf } from "./resonance.js";
@@ -71,12 +72,15 @@ export class Mind {
     lastCost = null;
     /** Memo of the consensus climb — content-keyed.  See {@link MindContext.climbMemo}. */
     climbMemo = null;
+    _structMemoKey = {};
     /** Memo of recognise() — content-keyed.  See {@link MindContext.recogniseMemo}. */
     recogniseMemo = null;
     /** Memo of perceive() — content-keyed.  See {@link MindContext.perceiveMemo}. */
     perceiveMemo = null;
     /** Subtree-resolution cache.  See {@link MindContext._resolvedSubtrees}. */
     _resolvedSubtrees = null;
+    answeredSpans = [];
+    currentTurnStart = 0;
     /** The perceived gist of the query currently being answered.  Set by `think`
      *  before the graph search runs; `chooseNext` consults it as a gate (a null
      *  guide means no query is in flight, so structural walkers keep plain
@@ -212,6 +216,11 @@ export class Mind {
         this.recogniseMemo = conv ? conv.recogniseMemo : new Map();
         this.perceiveMemo = conv ? conv.perceiveMemo : new Map();
         this._resolvedSubtrees = conv ? conv.resolvedSubtrees : null;
+        // Inference is a pure function of cumulative bytes. Conversation
+        // boundaries remain persistence/API metadata and must not select a
+        // different mechanism path than respond() on the identical byte stream.
+        this.answeredSpans = [];
+        this.currentTurnStart = 0;
         this.canon = canon ?? null;
         this.canonMemo = canon ? new Map() : null;
         this._beginMeter();
@@ -259,6 +268,8 @@ export class Mind {
         this.recogniseMemo = null;
         this.perceiveMemo = null;
         this._resolvedSubtrees = null;
+        this.answeredSpans = [];
+        this.currentTurnStart = 0;
         this.canon = null;
         this.canonMemo = null;
         this._edgeGuide = null;
@@ -335,11 +346,17 @@ export class Mind {
         const id = this._nextConvId++;
         const initBytes = state?.context ?? new Uint8Array(0);
         const initBoundaries = state?.boundaries ? [...state.boundaries] : [];
+        const initAnswered = state?.answeredSpans
+            ? state.answeredSpans.map(([start, end]) => [start, end])
+            : initBoundaries.flatMap((start, i, cuts) => i % 2 === 0 && i + 1 < cuts.length
+                ? [[start, cuts[i + 1]]]
+                : []);
         const tree = bytesToTree(this.space, this.alphabet, initBytes, undefined, undefined, initBoundaries.length > 0 ? initBoundaries : undefined);
         this._conversations.set(id, {
             tree,
             bytes: initBytes,
             boundaries: initBoundaries,
+            answeredSpans: initAnswered,
             perceiveMemo: new Map(),
             recogniseMemo: new Map(),
             climbMemo: new Map(),
@@ -361,6 +378,7 @@ export class Mind {
         return {
             context: data.bytes,
             boundaries: [...data.boundaries],
+            answeredSpans: data.answeredSpans.map(([start, end]) => [start, end]),
         };
     }
     /** Append a turn to a conversation's accumulated context WITHOUT
@@ -447,8 +465,11 @@ export class Mind {
             // the cumulative continuous shape multi-turn training deposits, so a
             // later turn can refer to what was ANSWERED ("which of those two…"),
             // not only to what was asked.
-            if (response.bytes.length > 0)
+            if (response.bytes.length > 0) {
+                const start = data.bytes.length;
                 this.addTurn(conv, response.bytes);
+                data.answeredSpans.push([start, data.bytes.length]);
+            }
             return { response, state: this.conversationState(conv) };
         }
         finally {
@@ -487,6 +508,8 @@ export class Mind {
      *  reports each ingested item's deposited root node ids
      *  ({@link DepositReport}); purely observational. */
     async ingest(input, second, onDeposit) {
+        invalidateStructuralCaches(this);
+        invalidateJunctionCache(this);
         return ingest(this, input, second, onDeposit);
     }
     // ── Extension Surface ────────────────────────────────────────────────────

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

@@ -41,8 +41,8 @@ export declare class Precomputed {
      *  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. */
+     *  ({@link sharedReachMemo}): session-scoped between writes and always cold
+     *  under a trace. */
     private _reach?;
     get reachMemo(): Map<number, AncestorReach>;
     /** Charge a lazily-shared analysis to its OWN phase rather than to the

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

@@ -94,8 +94,8 @@ export class Precomputed {
      *  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. */
+     *  ({@link sharedReachMemo}): session-scoped between writes and always cold
+     *  under a trace. */
     _reach;
     get reachMemo() {
         return this._reach ??= sharedReachMemo(this.ctx);
@@ -185,7 +185,9 @@ function computeWeave(ctx, query, pre, climb) {
     // recognising) a corpus-sized deposit: profiled on a 17.7M-node store,
     // uncapped weaves spent 5–8s per query recognising conversation-length
     // anchors that could never form a weave point.
-    const capBytes = query.length * quantum;
+    const askerBytes = query.length -
+        ctx.answeredSpans.reduce((n, [start, end]) => n + end - start, 0);
+    const capBytes = askerBytes * 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
@@ -214,11 +216,92 @@ function computeWeave(ctx, query, pre, climb) {
     // frame reading depend on its rank, and the proposed-run gate below needs the
     // real thing.
     const cands = [];
+    const querySegments = [];
+    let segmentStart = 0;
+    for (const [start, end] of ctx.answeredSpans) {
+        if (segmentStart < start)
+            querySegments.push([segmentStart, start]);
+        segmentStart = Math.max(segmentStart, end);
+    }
+    if (segmentStart < query.length) {
+        querySegments.push([segmentStart, query.length]);
+    }
+    const weaveLength = querySegments.reduce((n, [s, e]) => n + e - s, 0);
+    const weaveQuery = new Uint8Array(weaveLength);
+    const weaveMap = [];
+    let compactStart = 0;
+    for (const [start, end] of querySegments) {
+        weaveQuery.set(query.subarray(start, end), compactStart);
+        weaveMap.push({
+            compactStart,
+            originalStart: start,
+            length: end - start,
+        });
+        compactStart += end - start;
+    }
+    const segmentOf = (start, end) => {
+        let lo = 0;
+        let hi = weaveMap.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            if (weaveMap[mid].originalStart <= start)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        const part = lo > 0 ? weaveMap[lo - 1] : undefined;
+        return part && end <= part.originalStart + part.length ? part : undefined;
+    };
+    const weaveSites = pre.rec.sites.flatMap((s) => {
+        const part = segmentOf(s.start, s.end);
+        return part
+            ? [{
+                    ...s,
+                    start: part.compactStart + s.start - part.originalStart,
+                    end: part.compactStart + s.end - part.originalStart,
+                }]
+            : [];
+    });
     for (const cand of rankedCapped) {
         const ctxBytes = read(ctx, cand.anchor, capBytes + 1);
         if (ctxBytes.length === 0 || ctxBytes.length > capBytes)
             continue;
-        const raw = alignGraded(ctx, query, ctxBytes, pre.rec.sites);
+        // CAST compares structures stated by the asker. Completed assistant turns
+        // remain available to recognition and the climb as conversation context,
+        // but aligning every candidate across their full prose makes weave work
+        // grow with answer length and lets the engine analogise against its own
+        // previous output. The compact asker stream is aligned once (so candidate
+        // windows are not rebuilt per turn), then every run is split back across
+        // the original turn segments so no evidence crosses an omitted boundary.
+        const raw = alignGraded(ctx, weaveQuery, ctxBytes, weaveSites).flatMap((r) => {
+            let lo = 0;
+            let hi = weaveMap.length;
+            while (lo < hi) {
+                const mid = (lo + hi) >>> 1;
+                if (weaveMap[mid].compactStart <= r.qs)
+                    lo = mid + 1;
+                else
+                    hi = mid;
+            }
+            const out = [];
+            for (let pi = Math.max(0, lo - 1); pi < weaveMap.length; pi++) {
+                const part = weaveMap[pi];
+                if (part.compactStart >= r.qe)
+                    break;
+                const partEnd = part.compactStart + part.length;
+                const start = Math.max(r.qs, part.compactStart);
+                const end = Math.min(r.qe, partEnd);
+                if (start >= end)
+                    continue;
+                out.push({
+                    ...r,
+                    qs: part.originalStart + start - part.compactStart,
+                    qe: part.originalStart + end - part.compactStart,
+                    cs: r.cs + start - r.qs,
+                });
+            }
+            return out;
+        });
         if (raw.length === 0)
             continue;
         for (const r of raw) {