@hviana/sema 0.4.2 → 0.4.3

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

@@ -0,0 +1,172 @@
+import type { AncestorReach, MindContext, Recognition } from "./types.js";
+import type { AttentionRead } from "./types.js";
+import type { ComputedSpan } from "../extension.js";
+import type { Vec } from "../vec.js";
+import { type GradedRun } from "./match.js";
+export declare class Precomputed {
+    readonly ctx: MindContext;
+    readonly query: Uint8Array;
+    /** Recognition result (structural + canonical). */
+    readonly rec: Recognition;
+    /** Computed spans from mechanisms that implement `parse()` (e.g. ALU). */
+    readonly computed: ComputedSpan[];
+    /** The query's gist — the response-wide disambiguation guide. */
+    readonly guide: Vec;
+    /** The response's evidence-breadth constant: how many ranked candidates the
+     *  resonance probes, the weave alignment, and the climb all consider.
+     *  Derived once from config; every consumer reads it here. */
+    readonly k: number;
+    constructor(ctx: MindContext, query: Uint8Array, 
+    /** Recognition result (structural + canonical). */
+    rec: Recognition, 
+    /** Computed spans from mechanisms that implement `parse()` (e.g. ALU). */
+    computed: ComputedSpan[], 
+    /** The query's gist — the response-wide disambiguation guide. */
+    guide: Vec);
+    private _windows?;
+    /** Content-addressed W-window identities for every position in the query
+     *  (offset → node id).  O(|query|) probes. */
+    get queryWindows(): Map<number, number>;
+    private _resolved?;
+    /** The node id of the query itself, or null when it is not a stored form.
+     *  O(|query|) probes. */
+    get queryResolved(): number | null;
+    private _anchorWindows;
+    /** Content-addressed W-window identities of one anchor's own bytes
+     *  (offset → node id), memoised per anchor.  Confluence intersects these;
+     *  any future identity-based mechanism reads the same cache. */
+    windowsOf(anchor: number): Map<number, number>;
+    /** Shared memo for {@link reachOf} (structural-IDF reads): a window's
+     *  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}): 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
+     *  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. */
+    private shared;
+    private _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(): Promise<AttentionRead>;
+    private _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(): Promise<WeaveInfo>;
+    /** Span-shaped classification of one ranked anchor, memoised per anchor id
+     *  so repeated calls (extraction's own early-exit scan, any future
+     *  template-based mechanism) never redo the work.  Deliberately NOT an
+     *  eager all-anchors map: `skillExemplar` is the expensive part of
+     *  extraction (capped fan-out reads plus an O(|ctx|) scan), and most
+     *  queries are answered by the FIRST ranked anchor that qualifies — paying
+     *  for every ranked anchor regardless of where the scan stops would turn
+     *  an early-exit lookup into full O(k) work on every query. */
+    private _spanShaped;
+    spanShapedOf(anchor: number): Promise<SkillInfo | null>;
+    /** Every ranked anchor's classification at once, sharing the same
+     *  per-anchor cache as {@link spanShapedOf} — for a mechanism that
+     *  genuinely needs the full picture (not an early-exit scan).  Mixing
+     *  access patterns across mechanisms never duplicates work: whichever
+     *  anchors an early-exit consumer already asked for are reused here, and
+     *  whichever this computes first are reused by a later early-exit scan. */
+    spanShapedAll(): Promise<Map<number, SkillInfo | null>>;
+}
+/** The weave-local structural alignment, computed once and consumed by CAST
+ *  (and any future mechanism doing analogical transfer). */
+export interface WeaveInfo {
+    /** Per-anchor alignment: context bytes, vote weight, and graded runs. */
+    points: Array<{
+        anchor: number;
+        vote: number;
+        ctx: Uint8Array;
+        runs: GradedRun[];
+    }>;
+    /** Weighted depth at each query byte — sum of alignment weights.
+     *  `depth[i]` is the total evidence that byte i is shared among the
+     *  aligned structures. */
+    depth: Float64Array;
+}
+/** Span-shaped classification of one anchor — the structural information
+ *  extraction uses to decide whether a learned fact can serve as a template
+ *  for reading an analogous span out of the query. */
+export interface SkillInfo {
+    contextBytes: Uint8Array;
+    answerBytes: Uint8Array;
+}
+/** Raw result from a mechanism's `run()`.  The pipeline computes the weight
+ *  from `moves` + `PASS * unaccounted(accounted)` — the mechanism does not
+ *  know about the cost ladder.
+ *
+ *  When `weight` is present, the pipeline uses it directly instead of
+ *  computing `weigh(accounted, moves)`.  This is for mechanisms whose cost
+ *  is derived externally (e.g. cover: the A*LD derivation's g-value). */
+export interface MechanismResult {
+    bytes: Uint8Array;
+    accounted: Array<[number, number]>;
+    moves: number;
+    used?: ReadonlySet<number>;
+    unexplained: string;
+    /** Explicit weight override.  When absent, weight = moves + PASS·unaccounted. */
+    weight?: number;
+    /** Override the mechanism's default provenance for this result.
+     *  When absent, the pipeline uses `mech.provenance`. */
+    provenance?: string;
+    /** This grounding is a COMPLETE trained answer — post-grounding must not
+     *  extend it.  Declared by the mechanism about its own result, exactly like
+     *  `accounted`/`used`/`unexplained`; the decider honours the property and
+     *  never asks which mechanism set it, so the market stays uniform.
+     *
+     *  Set it only when the answer is a stored form's OWN continuation reached
+     *  through an identity claim about the query — i.e. the query IS some
+     *  trained context, so its continuation is the whole read-out and a further
+     *  multi-hop pivot would chain PAST the fact that produced the answer.
+     *  That is the same reasoning `reason`'s echo guard already applies to a
+     *  query that resolves exactly (see reasoning.ts); this carries the claim
+     *  for the mechanisms that establish the identity by another route.
+     *
+     *  Observed without it: the correct "What is the process of
+     *  photosynthesis?" grounding was pivoted forward four times, out of the
+     *  fact that answered it and into an unrelated "Hello! How can I assist you
+     *  today?" conversational turn. */
+    complete?: boolean;
+}
+export interface PipelineMechanism {
+    /** Stable identifier for trace/debug. */
+    readonly name: string;
+    /** Which provenance tag the pipeline attaches to this mechanism's answers. */
+    readonly provenance: string;
+    /** Parse authoritative spans BEFORE the grounding loop.
+     *  Only needed by computational mechanisms (e.g. ALU).  Results from ALL
+     *  mechanisms that implement this are collected into `Precomputed.computed`
+     *  before any `floor()` or `run()` is called. */
+    parse?(query: Uint8Array): Promise<ComputedSpan[]>;
+    /** Admissible lower bound on this mechanism's weight.
+     *  Returns `null` when the mechanism structurally cannot fire.
+     *
+     *  `worthRunning(cheapFloor)` reports whether the CURRENT incumbent
+     *  (established by mechanisms that already ran this response, cover being
+     *  first — see `defaultMechanisms`) could still be beaten by a floor no
+     *  tighter than `cheapFloor`.  THE INVESTMENT DISCIPLINE: before
+     *  first-touching an expensive shared analysis (`pre.attention()`,
+     *  `pre.weave()`, …), check `worthRunning(bound)` with this mechanism's
+     *  cheapest possible bound — and when it fails, RETURN THE BOUND rather
+     *  than null.  The bound is still admissible (it never overstates cost),
+     *  the pipeline's own check then prunes `run()` and records the truthful
+     *  "cannot beat incumbent" trace note, and no analysis was computed just
+     *  to be discarded.  This is uniform: no mechanism asks what produced the
+     *  incumbent — a computed extension result and an ordinary cheap cover
+     *  prune the same way. */
+    floor(ctx: MindContext, query: Uint8Array, pre: Precomputed, worthRunning: (floor: number) => boolean): Promise<number | null>;
+    /** Produce candidate answers. */
+    run(ctx: MindContext, query: Uint8Array, pre: Precomputed): Promise<MechanismResult[]>;
+}

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

@@ -0,0 +1,465 @@
+// pipeline-mechanism.ts — the uniform grounding-mechanism interface.
+//
+// Every grounding mechanism (CAST, confluence, cover, extraction, recall, ALU,
+// user extensions) implements this ONE interface.  The pipeline (think()) sees
+// a list of PipelineMechanism objects — it never imports a mechanism-specific
+// type and never has a special-case branch for any mechanism.
+//
+// The four constraints of the free-will architecture (§14.5):
+//   1. DECOUPLING — mechanisms import nothing from each other or from pipeline.
+//   2. DECLARED COMPETENCE — floor() returns null when impossible, a number when
+//      possible.  Binary, auditable, no learned scores.
+//   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, skillExemplar } from "./match.js";
+import { climbAttentionAll } from "./attention.js";
+import { sharedReachMemo } from "./traverse.js";
+// ── Precomputed ──────────────────────────────────────────────────────────────
+//
+// Precomputed is a LAZY container for structural analyses of the query — the
+// ONE place a response's shared evidence lives, for inter-mechanism exchange
+// and for analyses future mechanisms will want.  Eager fields (rec, computed,
+// guide) are populated by the pipeline before the mechanism loop; everything
+// expensive is a lazily-cached method that computes on first access.  A
+// mechanism that never asks for an analysis pays nothing for it; two
+// mechanisms asking for the same analysis pay once.
+//
+// This design serves THREE purposes:
+//   1. SHARING — when two mechanisms need the same analysis, it's computed once
+//      (even under trace, where the ctx-level memos are deliberately bypassed).
+//   2. EXTENSIBILITY — a new analysis is one method in one file.
+//   3. DECLARATIVE COST — a mechanism's floor() checks its cheap gates and the
+//      pipeline's `worthRunning` predicate BEFORE first-touching an expensive
+//      analysis, so lazy analyses are only ever computed for a mechanism that
+//      could still win.
+export class Precomputed {
+    ctx;
+    query;
+    rec;
+    computed;
+    guide;
+    /** The response's evidence-breadth constant: how many ranked candidates the
+     *  resonance probes, the weave alignment, and the climb all consider.
+     *  Derived once from config; every consumer reads it here. */
+    k;
+    constructor(ctx, query, 
+    /** Recognition result (structural + canonical). */
+    rec, 
+    /** Computed spans from mechanisms that implement `parse()` (e.g. ALU). */
+    computed, 
+    /** The query's gist — the response-wide disambiguation guide. */
+    guide) {
+        this.ctx = ctx;
+        this.query = query;
+        this.rec = rec;
+        this.computed = computed;
+        this.guide = guide;
+        this.k = ctx.cfg.recallQueryK * 2;
+    }
+    // ── Cheap lazy analyses ───────────────────────────────────────────────
+    _windows;
+    /** Content-addressed W-window identities for every position in the query
+     *  (offset → node id).  O(|query|) probes. */
+    get queryWindows() {
+        return this._windows ??= windowIds(this.ctx, this.query);
+    }
+    _resolved;
+    /** The node id of the query itself, or null when it is not a stored form.
+     *  O(|query|) probes. */
+    get queryResolved() {
+        if (this._resolved === undefined) {
+            this._resolved = resolve(this.ctx, this.query);
+        }
+        return this._resolved;
+    }
+    _anchorWindows = new Map();
+    /** Content-addressed W-window identities of one anchor's own bytes
+     *  (offset → node id), memoised per anchor.  Confluence intersects these;
+     *  any future identity-based mechanism reads the same cache. */
+    windowsOf(anchor) {
+        let w = this._anchorWindows.get(anchor);
+        if (w === undefined) {
+            w = windowIds(this.ctx, read(this.ctx, anchor));
+            this._anchorWindows.set(anchor, w);
+        }
+        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 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}): session-scoped between writes and 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 ??= 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) => 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
+     *  template-based mechanism) never redo the work.  Deliberately NOT an
+     *  eager all-anchors map: `skillExemplar` is the expensive part of
+     *  extraction (capped fan-out reads plus an O(|ctx|) scan), and most
+     *  queries are answered by the FIRST ranked anchor that qualifies — paying
+     *  for every ranked anchor regardless of where the scan stops would turn
+     *  an early-exit lookup into full O(k) work on every query. */
+    _spanShaped = new Map();
+    spanShapedOf(anchor) {
+        let p = this._spanShaped.get(anchor);
+        if (p === undefined) {
+            p = this.shared("spanShaped", () => skillExemplar(this.ctx, anchor, this.guide));
+            this._spanShaped.set(anchor, p);
+        }
+        return p;
+    }
+    /** Every ranked anchor's classification at once, sharing the same
+     *  per-anchor cache as {@link spanShapedOf} — for a mechanism that
+     *  genuinely needs the full picture (not an early-exit scan).  Mixing
+     *  access patterns across mechanisms never duplicates work: whichever
+     *  anchors an early-exit consumer already asked for are reused here, and
+     *  whichever this computes first are reused by a later early-exit scan. */
+    async spanShapedAll() {
+        const { ranked } = await this.attention();
+        const out = new Map();
+        for (const cand of ranked) {
+            if (out.has(cand.anchor))
+                continue;
+            out.set(cand.anchor, await this.spanShapedOf(cand.anchor));
+        }
+        return out;
+    }
+}
+function computeWeave(ctx, query, pre, climb) {
+    const quantum = ctx.space.maxGroup;
+    const { ranked } = 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
+    // most quote a fragment of it, and fragment-level evidence is exactly what
+    // recognition and the cover already handle); CAST's own comparison gate
+    // demands `ctx.length ≤ query.length` before it fires, and its
+    // substitution seats sit within a quantum of a context's start.  W is the
+    // perceptual quantum — the same scale multiplier the bridge's phrase-scale
+    // contract uses.  The prefix-capped read makes an oversized anchor cost a
+    // bounded read instead of reconstructing (and then canonically
+    // 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 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
+    // 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 = [];
+    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;
+        // 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) {
+            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;
+            for (const p of points) {
+                for (const o of p.runs) {
+                    if (qs >= qe)
+                        break;
+                    if (o.qe <= qs || o.qs >= qe)
+                        continue;
+                    const left = Math.max(0, o.qs - qs);
+                    const right = Math.max(0, qe - o.qe);
+                    if (left >= right)
+                        qe = qs + left;
+                    else {
+                        cs += qe - right - qs;
+                        qs = qe - right;
+                    }
+                }
+            }
+            if (qe - qs >= Math.min(quantum, ctxBytes.length)) {
+                free.push({ qs, qe, cs, weight });
+            }
+        }
+        if (free.length > 0) {
+            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 };
+}