pi-tuck 1.0.1 → 1.0.4

package/dist/src/tuck/core/brief-meter.js

@@ -1,273 +0,0 @@
-import { absorbCall, blockRecords, coveredCallKey, decorateRecord, isOmittable, noticeTimes, omissionRecord, receiptKey, repeatsCall, segmentClosing } from "./brief.js";
-import { TRANSCRIPT_HEADER, lineUnits } from "./transcript.js";
-/** A set of integers in [0, size) with ordered neighbour queries, in a tree of 32-bit words. */
-export class IndexSet {
-    levels = [];
-    constructor(size) {
-        let words = Math.max(1, size);
-        do {
-            words = Math.ceil(words / 32);
-            this.levels.push(new Uint32Array(words));
-        } while (words > 1);
-    }
-    has(i) { return (this.levels[0][i >>> 5] & (1 << (i & 31))) !== 0; }
-    add(i) {
-        for (const level of this.levels) {
-            const word = i >>> 5, was = level[word];
-            level[word] = was | (1 << (i & 31));
-            if (was !== 0)
-                return;
-            i = word;
-        }
-    }
-    remove(i) {
-        for (const level of this.levels) {
-            const word = i >>> 5;
-            level[word] = level[word] & ~(1 << (i & 31));
-            if (level[word] !== 0)
-                return;
-            i = word;
-        }
-    }
-    /** The smallest member above `i`, or -1. */
-    next(i) {
-        for (let l = 0; l < this.levels.length; l++) {
-            const word = i >>> 5, bit = i & 31;
-            const rest = bit === 31 ? 0 : this.levels[l][word] & (-1 << (bit + 1));
-            if (rest === 0) {
-                i = word;
-                continue;
-            }
-            let at = (word << 5) | (31 - Math.clz32(rest & -rest));
-            for (let k = l - 1; k >= 0; k--) {
-                const w = this.levels[k][at];
-                at = (at << 5) | (31 - Math.clz32(w & -w));
-            }
-            return at;
-        }
-        return -1;
-    }
-    /** The largest member below `i`, or -1. */
-    prev(i) {
-        for (let l = 0; l < this.levels.length; l++) {
-            const word = i >>> 5, bit = i & 31;
-            const rest = this.levels[l][word] & ~(-1 << bit);
-            if (rest === 0) {
-                i = word;
-                continue;
-            }
-            let at = (word << 5) | (31 - Math.clz32(rest));
-            for (let k = l - 1; k >= 0; k--)
-                at = (at << 5) | (31 - Math.clz32(this.levels[k][at]));
-            return at;
-        }
-        return -1;
-    }
-}
-/**
- * The size of `TRANSCRIPT_HEADER + "\n" + compileBrief(selected)` as blocks join, kept up to date by recomputing only the records a change
- * can affect, which are those of the block, its neighbours and the identical calls merged with them. This is the admission loop's yardstick,
- * so it must equal what the full render measures; the final render in `selectRankedBriefBlocks` remains the authority.
- *
- * It relies on what `normalize` guarantees for the blocks of one brief: they are distinct objects; all carry the same `sourceTimes` or none
- * does; and notices that share a `sourceEntryId` share a `sourceTime`.
- */
-export const createBriefMeter = (blocks, mandatory, cache) => {
-    const n = blocks.length;
-    const closing = segmentClosing(blocks);
-    const times = blocks[0]?.sourceTimes;
-    const entryTimes = noticeTimes(blocks);
-    const lengths = new WeakMap();
-    const lengthOf = (record) => {
-        let length = lengths.get(record);
-        if (length === undefined)
-            lengths.set(record, length = JSON.stringify(decorateRecord(record, times, entryTimes)).length);
-        return length;
-    };
-    // The state of each block: selected, rendered whole, and the records it renders alone while it has any (`active`).
-    const selected = new Uint8Array(n), whole = new Uint8Array(n);
-    const records = new Array(n);
-    const rendered = [new Array(n), new Array(n)];
-    const active = new IndexSet(n);
-    // Blocks whose first record is a repeat of the record before it fold into it; the rest of the output follows from these relations.
-    const merged = new Uint8Array(n);
-    const contributedChars = new Int32Array(n), contributedUnits = new Int32Array(n), contributedRecords = new Int32Array(n);
-    let chars = 0, units = 0, count = 0;
-    // A selected receipt makes the overview of the call it quotes redundant.
-    const callKeys = new Array(n);
-    const receiptKeys = new Array(n);
-    const callsOf = new Map(), receipts = new Map();
-    blocks.forEach((block, i) => {
-        const call = coveredCallKey(block);
-        if (call !== undefined) {
-            callKeys[i] = call;
-            const calls = callsOf.get(call);
-            if (calls)
-                calls.push(i);
-            else
-                callsOf.set(call, [i]);
-        }
-        receiptKeys[i] = receiptKey(block);
-    });
-    const own = (i) => {
-        const block = blocks[i], key = callKeys[i];
-        if (key !== undefined && receipts.get(key))
-            return undefined;
-        const slot = rendered[whole[i]];
-        const result = slot[i] ??= blockRecords(block, { full: whole[i] === 1, closing: closing.has(block), mandatory, bounded: true, covered: false }, cache);
-        return result.length ? result : undefined;
-    };
-    const repeats = (a, b) => {
-        const next = records[b];
-        return next.length === 1 && repeatsCall(records[a].at(-1), next[0]);
-    };
-    const first = (from) => active.has(from) ? from : active.next(from);
-    const setRecords = (j, next) => {
-        if (records[j] === next)
-            return;
-        // Every group of repeats that the change can reach: from the head of the group before `j` to the end of the group after it.
-        const before = active.prev(j), after = active.next(j);
-        let low = j, high = j;
-        if (before !== -1)
-            for (low = before; merged[low]; low = active.prev(low))
-                ;
-        if (after !== -1)
-            for (high = after;;) {
-                const further = active.next(high);
-                if (further === -1 || !merged[further])
-                    break;
-                high = further;
-            }
-        for (let b = first(low); b !== -1 && b <= high; b = active.next(b)) {
-            chars -= contributedChars[b];
-            units -= contributedUnits[b];
-            count -= contributedRecords[b];
-            contributedChars[b] = contributedUnits[b] = contributedRecords[b] = 0;
-        }
-        records[j] = next;
-        if (next)
-            active.add(j);
-        else
-            active.remove(j);
-        let group = [];
-        const settle = () => {
-            if (!group.length)
-                return;
-            const head = records[group[0]];
-            const shown = group.length === 1 ? head :
-                [group.slice(1).reduce((all, b) => absorbCall(all, records[b][0]), head[0])];
-            for (const record of shown) {
-                const length = lengthOf(record);
-                contributedChars[group[0]] += length;
-                contributedUnits[group[0]] += lineUnits(length);
-                contributedRecords[group[0]]++;
-            }
-            chars += contributedChars[group[0]];
-            units += contributedUnits[group[0]];
-            count += contributedRecords[group[0]];
-        };
-        for (let b = first(low); b !== -1 && b <= high; b = active.next(b)) {
-            const previous = active.prev(b);
-            merged[b] = previous !== -1 && repeats(previous, b) ? 1 : 0;
-            if (!merged[b]) {
-                settle();
-                group = [];
-            }
-            group.push(b);
-        }
-        settle();
-    };
-    const refresh = (i) => setRecords(i, selected[i] ? own(i) : undefined);
-    const quoted = (i, delta) => {
-        const key = receiptKeys[i];
-        if (key === undefined)
-            return;
-        const now = (receipts.get(key) ?? 0) + delta;
-        receipts.set(key, now);
-        if (now === (delta === 1 ? 1 : 0))
-            for (const call of callsOf.get(key) ?? [])
-                if (selected[call])
-                    refresh(call);
-    };
-    // The omission notices say how many unselected user and assistant text blocks there are and where the first of them were read.
-    const roles = ["user", "assistant"].map(role => {
-        const perSource = new Map();
-        let total = 0, unlocated = 0;
-        for (const block of blocks)
-            if (block.kind === role && isOmittable(block, mandatory)) {
-                total++;
-                if (block.sourceIndex === undefined)
-                    unlocated++;
-                else
-                    perSource.set(block.sourceIndex, (perSource.get(block.sourceIndex) ?? 0) + 1);
-            }
-        const sources = [...perSource.keys()].sort((a, b) => a - b);
-        const ids = new Map(sources.map((source, id) => [source, id]));
-        const alive = new IndexSet(sources.length);
-        sources.forEach((_, id) => alive.add(id));
-        return { role, total, unlocated, perSource, sources, ids, alive };
-    });
-    const omittedBy = (added, role) => {
-        let removed = 0, unlocated = 0;
-        const taken = new Map();
-        for (const i of added) {
-            const block = blocks[i];
-            if (block.kind !== role.role || !isOmittable(block, mandatory))
-                continue;
-            removed++;
-            if (block.sourceIndex === undefined)
-                unlocated++;
-            else
-                taken.set(block.sourceIndex, (taken.get(block.sourceIndex) ?? 0) + 1);
-        }
-        return { removed, unlocated, taken };
-    };
-    const notice = (added, role) => {
-        const { removed, unlocated, taken } = omittedBy(added, role);
-        if (role.total === removed)
-            return undefined;
-        const gone = new Set();
-        for (const [source, k] of taken)
-            if (role.perSource.get(source) === k)
-                gone.add(source);
-        const sources = [];
-        for (let id = role.alive.has(0) ? 0 : role.alive.next(0); id !== -1 && sources.length < 9; id = role.alive.next(id))
-            if (!gone.has(role.sources[id]))
-                sources.push(role.sources[id]);
-        return omissionRecord(role.role, role.total - removed, sources, role.unlocated > unlocated);
-    };
-    const header = TRANSCRIPT_HEADER.length + 1;
-    const rendering = (c, u, k) => k === 0 ? { chars: header, units: 2 } : { chars: header + c + k - 1, units: 1 + u };
-    return {
-        select(i) { selected[i] = 1; quoted(i, 1); refresh(i); },
-        unselect(i) { selected[i] = 0; refresh(i); quoted(i, -1); },
-        promote(i) { whole[i] = 1; refresh(i); },
-        demote(i) { whole[i] = 0; refresh(i); },
-        size(added) {
-            let c = 0, u = 0, k = 0;
-            for (const role of roles) {
-                const record = notice(added, role);
-                if (!record)
-                    continue;
-                const length = lengthOf(record);
-                c += length;
-                u += lineUnits(length);
-                k++;
-            }
-            return { withNotices: rendering(chars + c, units + u, count + k), withoutNotices: rendering(chars, units, count) };
-        },
-        commit(added) {
-            for (const role of roles) {
-                const { removed, unlocated, taken } = omittedBy(added, role);
-                role.total -= removed;
-                role.unlocated -= unlocated;
-                for (const [source, k] of taken) {
-                    const left = role.perSource.get(source) - k;
-                    role.perSource.set(source, left);
-                    if (left === 0)
-                        role.alive.remove(role.ids.get(source));
-                }
-            }
-        },
-    };
-};

package/dist/src/tuck/core/rank.d.ts

@@ -1,42 +0,0 @@
-import type { NormalizedBlock, FileOps } from "../types.js";
-export interface BriefRankingOptions {
-    /** Maximum normalized blocks used to build the brief transcript. */
-    maxBlocks?: number;
-    /** Optional complete serialized historical-view allowance. */
-    maxBriefUnits?: number;
-    /** Full sources rendered separately by the caller; retain their structural relationships. */
-    mandatorySourceIndices?: ReadonlySet<number>;
-    /** Always keep this many latest blocks to preserve local continuity. */
-    preserveRecentBlocks?: number;
-    /** Hook-provided file activity, used as structural signal instead of prose guessing. */
-    fileOps?: FileOps;
-    /**
-     * Optional size budget (in characters of rendered brief) for the selected
-     * blocks. When set, this is the PRIMARY limit: blocks are added by score
-     * until the budget is reached, and lower-value blocks are skipped rather
-     * than truncating the tail. maxBlocks still applies as a safety upper bound.
-     * Callers derive this from a token budget via charsPerToken.
-     * When maxBriefCharsCeiling + briefCharsPerBlock are also set, this acts as
-     * the FLOOR of a size-relative budget (see below).
-     */
-    maxBriefChars?: number;
-    /**
-     * Optional upper bound for a size-relative char budget. When set together
-     * with maxBriefChars (floor) and briefCharsPerBlock (slope), the effective
-     * budget becomes clamp(briefCharsPerBlock * blockCount, maxBriefChars,
-     * maxBriefCharsCeiling): larger transcripts (which carry more high-value
-     * long-tail -- edits, commands, tests) get more brief budget, while small
-     * sessions stay at the floor and this hard ceiling prevents unbounded growth.
-     */
-    maxBriefCharsCeiling?: number;
-    /** Per-block slope (chars) for the size-relative budget. Requires the ceiling. */
-    briefCharsPerBlock?: number;
-}
-export interface RankedBlock {
-    block: NormalizedBlock;
-    index: number;
-    score: number;
-    reasons: string[];
-}
-export declare const rankBriefBlocks: (blocks: NormalizedBlock[], options?: BriefRankingOptions) => RankedBlock[];
-export declare const selectRankedBriefBlocks: (blocks: NormalizedBlock[], options?: BriefRankingOptions) => NormalizedBlock[];

package/dist/src/tuck/core/rank.js

@@ -1,292 +0,0 @@
-import { extractPath } from "./tool-args.js";
-import { compileBrief, planBrief, heredocCloseIndex, isSegmentClosingAssistant } from "./brief.js";
-import { createBriefMeter } from "./brief-meter.js";
-import { TRANSCRIPT_HEADER, transcriptUnits, MAX_RECEIPT_CHARACTERS } from "./transcript.js";
-const DEFAULT_MAX_BLOCKS = 80;
-const DEFAULT_RECENT_BLOCKS = 16;
-const EDIT_TOOL_RE = /^(edit|write|multiedit|quick_edit|target_edit|apply_patch)$/i;
-const READ_TOOL_RE = /^(read|glob|grep|ls|find|semantic_query|semantic_grep|semantic_show)$/i;
-const TEST_COMMAND_RE = /\b(?:bun|npm|pnpm|yarn|node|pytest|cargo|go|mvn|gradle)\b[^\n]*(?:test|spec|check|lint|build|tsc)/i;
-// Durable workflow facts: which PR/issue was acted on, and git state changes.
-// Structural (command shape), not prose — same spirit as TEST_COMMAND_RE.
-const WORKFLOW_COMMAND_RE = /(?:^|\s)(?:gh\s+(?:pr|issue)\s+[a-z-]+|git\s+(?:commit|push|merge|rebase|revert|cherry-pick|tag|reset|checkout|branch)\b)/i;
-const MIN_SEGMENT_CLOSING_ASSISTANT_CHARS = 120;
-// A bash block whose every meaningful line is pure scaffolding (set -e, cd,
-// export, ls, echo, sleep, pwd, comments, heredoc bodies) carries no durable
-// fact. Such blocks get a score penalty so the size-relative budget never
-// pulls them in ahead of real edits/commands when spare chars appear.
-const TRIVIAL_BASH_LINE_RE = /^(?:set\s+[-+]|cd(?:\s+\S+)?$|export\s+\w+=|(?:source|\.)\s+\S+|pwd$|true$|:$|#|ls(?:\s|$)|echo\b|clear$|sleep\b)/;
-const TRIVIAL_BASH_PENALTY = 16;
-const isTrivialOnlyBash = (raw) => {
-    const lines = raw.split("\n");
-    const kept = [];
-    for (let i = 0; i < lines.length; i++) {
-        kept.push(lines[i]);
-        // Skip heredoc bodies (they are content, not scaffolding) using the same
-        // hardened detection as brief.ts: only skip when the terminator exists
-        // downstream, so a stray `<<` never swallows a later real command.
-        const close = heredocCloseIndex(lines, i);
-        if (close !== -1)
-            i = close;
-    }
-    const meaningful = kept.map((l) => l.trim()).filter(Boolean).filter((l) => !TRIVIAL_BASH_LINE_RE.test(l));
-    return meaningful.length === 0;
-};
-const asPathSet = (paths) => new Set((paths ?? []).filter(Boolean));
-const bashCommandFromBlock = (block) => {
-    if (block.kind === "bash")
-        return block.command;
-    if (block.kind === "tool_call" && /^bash$/i.test(block.name) && typeof block.args.command === "string") {
-        return block.args.command;
-    }
-    return undefined;
-};
-const pathFromBlock = (block) => {
-    if (block.kind === "tool_call")
-        return extractPath(block.args) ?? undefined;
-    if (block.kind === "bash") {
-        const match = block.command.match(/(?:^|\s)([\w./-]+\.[\w-]+)(?:\s|$)/);
-        return match?.[1];
-    }
-    return undefined;
-};
-const add = (ranked, points, reason) => {
-    ranked.score += points;
-    ranked.reasons.push(reason);
-};
-const scoreBlock = (block, index, total, modifiedFiles, readFiles) => {
-    const ranked = { block, index, score: 0, reasons: [] };
-    const recency = total <= 1 ? 0 : Math.round((index / (total - 1)) * 12);
-    add(ranked, recency, "recency");
-    if (block.kind === "user")
-        add(ranked, 18, "user-turn");
-    if (block.kind === "assistant")
-        add(ranked, 10, "assistant-context");
-    if (block.kind === "notice")
-        add(ranked, 10, "framework-notice");
-    if (block.kind === "tool_result")
-        add(ranked, 1, "tool-result-low-value");
-    if (block.kind === "tool_call") {
-        const command = bashCommandFromBlock(block);
-        if (EDIT_TOOL_RE.test(block.name))
-            add(ranked, 34, "edit-tool");
-        else if (command && TEST_COMMAND_RE.test(command))
-            add(ranked, 26, "test-command");
-        else if (READ_TOOL_RE.test(block.name))
-            add(ranked, 6, "read-tool");
-        else
-            add(ranked, 12, "tool-call");
-        if (command && WORKFLOW_COMMAND_RE.test(command))
-            add(ranked, 14, "workflow-command");
-        if (command && isTrivialOnlyBash(command))
-            add(ranked, -TRIVIAL_BASH_PENALTY, "trivial-bash");
-    }
-    if (block.kind === "bash") {
-        add(ranked, 8, "bash");
-        if (block.exitCode != null && block.exitCode !== 0)
-            add(ranked, 24, "nonzero-exit");
-        if (TEST_COMMAND_RE.test(block.command))
-            add(ranked, 22, "test-command");
-        if (WORKFLOW_COMMAND_RE.test(block.command))
-            add(ranked, 14, "workflow-command");
-        // Penalize scaffolding-only commands, but not ones that failed (a failed
-        // `ls`/`cd` still records a real state fact via nonzero-exit).
-        if (isTrivialOnlyBash(block.command) && !(block.exitCode != null && block.exitCode !== 0)) {
-            add(ranked, -TRIVIAL_BASH_PENALTY, "trivial-bash");
-        }
-    }
-    const path = pathFromBlock(block);
-    if (path) {
-        if (modifiedFiles.has(path))
-            add(ranked, 18, "hook-modified-file");
-        if (readFiles.has(path))
-            add(ranked, 6, "hook-read-file");
-    }
-    if (block.kind === "tool_result" && block.text.length > 1000)
-        add(ranked, -8, "long-tool-result");
-    return ranked;
-};
-const boostAdjacency = (ranked) => {
-    const important = ranked
-        .filter((r) => r.score >= 34 || r.reasons.includes("edit-tool") || r.reasons.includes("test-command") || r.reasons.includes("nonzero-exit"))
-        .map((r) => r.index);
-    for (const idx of important) {
-        for (let i = idx - 1; i >= Math.max(0, idx - 8); i--) {
-            if (ranked[i].block.kind === "user") {
-                add(ranked[i], 10, "near-important-event");
-                break;
-            }
-        }
-        for (let i = idx - 1; i >= Math.max(0, idx - 4); i--) {
-            if (ranked[i].block.kind === "assistant") {
-                add(ranked[i], 7, "near-important-event");
-                break;
-            }
-        }
-        for (let i = idx + 1; i <= Math.min(ranked.length - 1, idx + 4); i++) {
-            if (ranked[i].block.kind === "assistant" || ranked[i].block.kind === "bash") {
-                add(ranked[i], 5, "after-important-event");
-                break;
-            }
-        }
-    }
-};
-const boostSegmentClosingAssistants = (ranked, blocks) => {
-    for (const current of ranked) {
-        if (current.block.kind !== "assistant")
-            continue;
-        if (current.block.text.trim().length < MIN_SEGMENT_CLOSING_ASSISTANT_CHARS)
-            continue;
-        if (isSegmentClosingAssistant(blocks, current.index))
-            add(current, 14, "segment-closing-assistant");
-    }
-};
-export const rankBriefBlocks = (blocks, options = {}) => {
-    const modifiedFiles = asPathSet(options.fileOps?.modifiedFiles);
-    const readFiles = asPathSet(options.fileOps?.readFiles);
-    const ranked = blocks.map((block, index) => scoreBlock(block, index, blocks.length, modifiedFiles, readFiles));
-    boostAdjacency(ranked);
-    boostSegmentClosingAssistants(ranked, blocks);
-    return ranked;
-};
-export const selectRankedBriefBlocks = (blocks, options = {}) => {
-    // A rendered allowance owns capacity. An independent count must not discard
-    // fitting original dialogue; all blocks were already normalized in memory.
-    const maxBlocks = options.maxBlocks ?? (options.maxBriefChars != null ? blocks.length : DEFAULT_MAX_BLOCKS);
-    // Size-relative budget: when a ceiling + slope are provided, the effective
-    // char budget scales with transcript length (block count) between the floor
-    // (maxBriefChars) and the ceiling. Larger transcripts carry more high-value
-    // long-tail, so they earn more brief budget; small sessions stay at the floor.
-    const maxBriefChars = options.maxBriefChars != null && options.maxBriefCharsCeiling != null && options.briefCharsPerBlock != null
-        ? Math.round(Math.min(options.maxBriefCharsCeiling, Math.max(options.maxBriefChars, options.briefCharsPerBlock * blocks.length)))
-        : options.maxBriefChars;
-    // Fast path: nothing to trim by count and no char budget to enforce.
-    if (blocks.length <= maxBlocks && maxBriefChars == null && options.maxBriefUnits == null)
-        return blocks;
-    const preserveRecentBlocks = Math.min(options.preserveRecentBlocks ?? DEFAULT_RECENT_BLOCKS, maxBlocks);
-    const ranked = rankBriefBlocks(blocks, options);
-    const selected = new Set();
-    // Charge the actual candidate serialization. Adjacent-block truncation and
-    // tool omission notices can change its size; isolated-block estimates cannot certify it.
-    // The meter keeps that size current as blocks join; the final render below remains the authority.
-    const excerpts = new WeakMap();
-    const full = new Set();
-    const meter = createBriefMeter(blocks, options.mandatorySourceIndices, excerpts);
-    const within = (size) => (maxBriefChars == null || size.chars <= maxBriefChars) &&
-        (options.maxBriefUnits == null || size.units <= options.maxBriefUnits);
-    const admit = (indices, preferFull = false) => {
-        const added = indices.filter(i => !selected.has(i));
-        if (!added.length && !preferFull)
-            return true;
-        if (selected.size + added.length > maxBlocks)
-            return false;
-        const promoted = preferFull ? indices.filter(i => ["user", "assistant", "bash"].includes(blocks[i].kind) && !full.has(blocks[i])) : [];
-        // Notices are best effort: never overflow or displace otherwise fitting text.
-        const fits = () => { const { withNotices, withoutNotices } = meter.size(added); return within(withNotices) || within(withoutNotices); };
-        for (const i of added)
-            meter.select(i);
-        for (const i of promoted)
-            meter.promote(i);
-        if (!fits()) {
-            for (const i of promoted.splice(0))
-                meter.demote(i);
-            // A whole shell proposal that does not fit is withdrawn, not retried as an excerpt.
-            if ((preferFull && indices.some(i => blocks[i].kind === "bash")) || !fits()) {
-                for (const i of added)
-                    meter.unselect(i);
-                return false;
-            }
-        }
-        for (const i of added)
-            selected.add(i);
-        meter.commit(added);
-        for (const i of promoted)
-            full.add(blocks[i]);
-        return true;
-    };
-    // Keep the latest blocks to preserve local continuity, iterating NEWEST first
-    // so the most recent context is guaranteed. When a char budget is active these
-    // are charged against it too and over-budget blocks are skipped -- otherwise a
-    // run of large recent blocks could blow past maxBriefChars (the old bug on very
-    // long transcripts, where preserve-recent alone exceeded the budget).
-    for (let i = blocks.length - 1; i >= Math.max(0, blocks.length - preserveRecentBlocks); i--) {
-        // Historical action overviews compete after the conversational base. Fresh
-        // native rounds are protected by the adapter, outside this old-prefix view.
-        if (["tool_result", "tool_call", "bash"].includes(blocks[i].kind))
-            continue;
-        if (selected.has(i))
-            continue;
-        if (!admit([i]))
-            continue;
-    }
-    // Structural exchanges are derived from the original chronology. A user
-    // carries prose from the preceding assistant message, including prose before
-    // that message's trailing calls. Only explicit source identity crosses calls.
-    const groups = ranked.filter(r => r.block.kind === "user").map(item => {
-        let preceding = item.index - 1;
-        while (preceding >= 0 && blocks[preceding].kind === "tool_result")
-            preceding--;
-        const previous = blocks[preceding];
-        const prose = [];
-        if (previous?.kind === "assistant" || previous?.kind === "tool_call") {
-            const source = previous.sourceIndex;
-            for (let i = preceding; i >= 0; i--) {
-                if (source === undefined ? i !== preceding : blocks[i].sourceIndex !== source)
-                    break;
-                if (blocks[i].kind === "assistant")
-                    prose.unshift(i);
-            }
-        }
-        return [...prose, item.index];
-    }).reverse();
-    // Admit the conversational base before spending room on any full proposal.
-    // Otherwise a newly fitting recent assistant can crowd out an older user.
-    for (const group of groups) {
-        if (!admit(group)) {
-            // Bounded atomicity: an oversized pair must not exclude a useful user turn.
-            admit([group.at(-1)]);
-        }
-    }
-    const ordered = [...ranked].sort((a, b) => b.score - a.score || b.index - a.index);
-    for (const item of ordered) {
-        if (selected.size >= maxBlocks)
-            break;
-        if (selected.has(item.index))
-            continue;
-        if (item.block.kind === "tool_result")
-            continue;
-        if (!admit([item.index]))
-            continue;
-    }
-    // Complete the existing coverage pass before expanding already represented
-    // user wording. Whole proposals/choices are still eligible in spare room.
-    for (const i of [...selected].sort((a, b) => b - a))
-        if (blocks[i].kind === "user")
-            admit([i], true);
-    // Expand selected assistant prose only into spare capacity. A large recent
-    // message must not consume the budget before user exchanges are considered.
-    for (const i of [...selected].sort((a, b) => b - a))
-        if (blocks[i].kind === "assistant")
-            admit([i], true);
-    // Cheap exact observations use only spare allowance after dialogue. Size
-    // and recency are signals, not proof of usefulness, freshness or success.
-    for (let i = blocks.length - 1; i >= 0; i--) {
-        const block = blocks[i];
-        if (block.kind === "tool_result" && block.originalReceipt)
-            admit([i]);
-    }
-    // Enrich already retained shell events only after the unchanged base. Whole
-    // stored output may be truncated; it is historical evidence, not verification.
-    for (const i of [...selected].sort((a, b) => b - a)) {
-        const block = blocks[i];
-        if (block.kind === "bash" && block.sourceIndex !== undefined && block.output.length <= MAX_RECEIPT_CHARACTERS)
-            admit([i], true);
-    }
-    const result = [...selected].sort((a, b) => a - b).map((i) => blocks[i]);
-    planBrief(result, full, blocks, options.mandatorySourceIndices);
-    const rendered = TRANSCRIPT_HEADER + "\n" + compileBrief(result, excerpts);
-    if ((maxBriefChars != null && rendered.length > maxBriefChars) ||
-        (options.maxBriefUnits != null && transcriptUnits(rendered) > options.maxBriefUnits))
-        planBrief(result, full, blocks, options.mandatorySourceIndices, false);
-    return result;
-};