pi-tuck 1.0.1 → 1.0.3

package/src/tuck/types.ts

@@ -4,19 +4,6 @@ import type { convertToLlm } from "@earendil-works/pi-coding-agent";
 export type CompilerMessage = Parameters<typeof convertToLlm>[0][number];
 
 
-export interface FileOps {
-  readFiles?: string[];
-  modifiedFiles?: string[];
-  createdFiles?: string[];
-}
-
-export interface ReceiptLink {
-  status: "missing" | "ambiguous" | "error" | "non-error";
-  sourceIndices: number[];
-  /** Every original call/receipt contributing to the derived status. */
-  dependencyIndices: number[];
-}
-
 export interface HistoricalReceipt {
   text: string;
   isError: boolean;
@@ -26,10 +13,11 @@ export interface HistoricalReceipt {
   );
 }
 
-export type NormalizedBlock = { sourceTime?: import("./core/source-time").SourceTime; sourceTimes?: Record<number, import("./core/source-time").SourceTime> } & (
-  | { kind: "user"; text: string; originalText?: string; sourceIndex?: number }
-  | { kind: "assistant"; text: string; originalText?: string; sourceIndex?: number }
-  | { kind: "notice"; text: string; originalText?: string; sourceIndex?: number; sourceEntryId?: string }
-  | { kind: "tool_call"; name: string; args: Record<string, unknown>; callId?: string; receipt?: ReceiptLink; sourceIndex?: number }
-  | { kind: "tool_result"; name: string; text: string; sourceIndex?: number; recallExport?: true; originalReceipt?: HistoricalReceipt }
+/** `startsSource`: the block's original text begins the message's readable text, so an offset into it is a tuck_recall offset into the source. */
+export type NormalizedBlock = { sourceTimes?: Record<number, import("./core/source-time").SourceTime> } & (
+  | { kind: "user"; text: string; originalText?: string; sourceIndex?: number; startsSource?: true }
+  | { kind: "assistant"; text: string; originalText?: string; sourceIndex?: number; startsSource?: true }
+  | { kind: "notice"; text: string; originalText?: string; sourceIndex?: number; sourceEntryId?: string; startsSource?: true }
+  | { kind: "tool_call"; name: string; args: Record<string, unknown>; callId?: string; sourceIndex?: number }
+  | { kind: "tool_result"; name: string; text: string; sourceIndex?: number; recallExport?: true }
   | { kind: "bash"; command: string; output: string; exitCode: number | undefined; cancelled?: boolean; truncated?: boolean; sourceIndex?: number });

package/src/tuck.ts

@@ -2,7 +2,7 @@ import { resolveSourceTime, type SourceTime } from "./tuck/core/source-time";
 import { orderByOriginalSource } from "./tuck/core/source-order";
 import { assertNativeToolRounds, isDiscardedResponse } from "./protocol.js";
 import { parseRecords, serializeTranscript, splitSummary, type TranscriptRecord } from "./tuck/core/transcript";
-import { DIALOGUE_SUFFIX, RANKED_SUFFIX } from "./tuck/core/format";
+import { DIALOGUE_SUFFIX } from "./tuck/core/format";
 import { isTextOnly, textOf } from "./tuck/core/content";
 import { MAX_TASK_CONTRACT_CHARACTERS, actionItems, actionRecords, head, ledgerItems, ledgerRecords } from "./ledger.js";
 import type { Message } from "@earendil-works/pi-ai";
@@ -15,8 +15,8 @@ type AgentMessage = Parameters<typeof convertToLlm>[0][number];
 type Cut = import("./tuck/cut").OwnCutResult;
 /** Counts a projection of the conversation exactly as the triggers, the post-cut checks and the guard do (budget.ts). */
 export type Measure = (messages: AgentMessage[]) => number;
-/** The summary view that produced a draft: the whole pre-cut dialogue, or the ranked fallback. Both carry the file ledger. */
-export type DraftMode = "dialogue" | "ranked";
+/** The summary view that produced a draft: the whole pre-cut dialogue, or the same dialogue shrunk to the allowance. Both carry the file ledger. */
+export type DraftMode = "dialogue" | "shrunk";
 type Draft = { compaction: Pick<Extract<SessionEntry, { type: "compaction" }>, "summary" | "firstKeptEntryId" | "tokensBefore" | "details">; after: number; mode: DraftMode; unavailable?: never; capacityRejected?: never }
     | { compaction?: never; mode?: never; unavailable: string; capacityRejected?: boolean };
 interface SearchHit { index: number; role: string; summary: string }
@@ -29,12 +29,12 @@ export interface Tuck {
 	applyTailBudget(entries: SessionEntry[], cut: Extract<Cut, { ok: true }>, options: { charsPerToken: number; maxTokens?: number; oversizedFactor?: number }): Cut;
 	calibrateCharsPerToken(chars: number, tokens: number): { charsPerToken: number };
 	buildGlobalIndexById(entries: readonly SessionEntry[]): Map<string, number>;
-	compileRanked(input: { messages: AgentMessage[]; sourceIndices: (number | undefined)[]; sourceEntryIds?: readonly string[]; sourceTimes?: readonly SourceTime[];
+	/** The dialogue shrunk to `ranking.maxBriefChars`, oldest assistant text first; "" when not even the least of it fits. */
+	compileShrunkDialogue(input: { messages: AgentMessage[]; sourceIndices: (number | undefined)[]; sourceEntryIds?: readonly string[]; sourceTimes?: readonly SourceTime[];
 		receiptContext?: { messages: AgentMessage[]; sourceIndices: (number | undefined)[] };
-		ranking: { maxBriefChars: number; maxBriefCharsCeiling?: number; briefCharsPerBlock?: number; maxBriefUnits?: number;
-            mandatorySourceIndices?: ReadonlySet<number> } }): string;
-	/** The whole pre-cut dialogue view; "" offers none, and the ranked view is used. */
-	compileDialogue(input: Parameters<Tuck["compileRanked"]>[0]): string;
+		ranking: { maxBriefChars: number; mandatorySourceIndices?: ReadonlySet<number> } }): string;
+	/** The whole pre-cut dialogue view; "" offers none, and the shrunk view is used. */
+	compileDialogue(input: Parameters<Tuck["compileShrunkDialogue"]>[0]): string;
 	prepareKeywordQuery(query: string): PreparedKeywordQuery;
 	searchEntriesDetailed(entries: SearchHit[], messages: Message[], query: string,
 		tuning: { relativeFloor: number; cap: number }): {
@@ -44,20 +44,20 @@ export interface Tuck {
 import { buildOwnCut, applyTailBudget, MAX_TAIL_TOKENS, OVERSIZED_TAIL_FACTOR } from "./tuck/cut";
 import { calibrateCharsPerToken, estimateSourceMessageChars } from "./tuck/core/token-estimate";
 import { buildGlobalIndexById } from "./tuck/core/global-indices";
-import { compileRanked, compileDialogue } from "./tuck/core/summarize";
+import { compileShrunkDialogue, compileDialogue } from "./tuck/core/summarize";
 import { prepareKeywordQuery } from "./tuck/core/keyword-query";
 import { searchEntriesDetailed } from "./tuck/core/search-entries";
-export const tuck: Tuck = { buildOwnCut, applyTailBudget, calibrateCharsPerToken, buildGlobalIndexById, compileRanked, compileDialogue, prepareKeywordQuery, searchEntriesDetailed };
+export const tuck: Tuck = { buildOwnCut, applyTailBudget, calibrateCharsPerToken, buildGlobalIndexById, compileShrunkDialogue, compileDialogue, prepareKeywordQuery, searchEntriesDetailed };
 /** The one historical allowance: at most 25% of remaining estimated room, for both views.
  * The whole dialogue is offered only within it (plus actual preview/headroom guards);
- * otherwise the ranked view fills it. The 4-character conversion matches pinned Pi's
+ * otherwise the same dialogue is shrunk to fit it. The 4-character conversion matches pinned Pi's
  * summary estimator, not a provider-token guarantee. Mandatory sources (current input,
  * initiating prompt, file ledger) are already charged in base. */
 export function historicalAllowance(window: number, reserve: number, base: number, before: number): number {
     const free = Math.max(0, window - reserve - base - 1);
     return Math.max(0, Math.min(Math.floor(free / 4), before - base - 1)) * 4;
 }
-/** Uses pi-tuck's own cut, calibrated maximum tail and ranked compiler; Pi owns persistence and continuation. */
+/** Uses pi-tuck's own cut, calibrated maximum tail and dialogue compiler; Pi owns persistence and continuation. */
 export function tuckDraft(tuck: Tuck, event: SessionBeforeCompactEvent, ctx: ExtensionContext, reserveTokens: number, measure: Measure, policy: RecallPolicy = {}, retainCurrentInput = true, operatorManual = false) {
  return tuckObservedDraft(tuck, { branchEntries: event.branchEntries, tokensBefore: event.preparation.tokensBefore, previousSummary: event.preparation.previousSummary, operatorManual }, ctx, reserveTokens, measure, policy, retainCurrentInput);
 }
@@ -81,9 +81,9 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
 	const chars = (calibration.ok ? calibration.messages.reduce((n, m) => n + estimateSourceMessageChars(m), 0) : 0)
 		+ (input.previousSummary?.length ?? 0);
 	const { charsPerToken } = tuck.calibrateCharsPerToken(chars, input.tokensBefore);
-    // A preferred tail cannot consume more than the current input allowance.
-    // Current/fresh-source floors below may still require an explicit rejection.
-    const inputRoom = Math.max(0, (ctx.model?.contextWindow ?? 0) - reserveTokens - 1);
+    // A preferred tail takes at most half the current input allowance, so a cut leaves room to grow: a tail that fills the room lands the
+    // request just under the band and the next round cuts again. Current/fresh-source floors below may still require an explicit rejection.
+    const inputRoom = Math.floor(Math.max(0, (ctx.model?.contextWindow ?? 0) - reserveTokens - 1) / 2);
     const maxTokens = Math.min(MAX_TAIL_TOKENS, inputRoom);
     // Keep the current user turn native; older conversation competes in the
     // existing exact historical view instead of boosting a minimum native tail.
@@ -183,13 +183,13 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
         if (index === undefined) throw new Error("Missing initiating user source index");
         const quoted = head(text, MAX_TASK_CONTRACT_CHARACTERS), sourceTimes = [{ sourceIndex: index, ...resolveSourceTime(initiating) }];
         if (text.trim()) {
-            mandatory.push({ kind: "excerpt", role: "user", sourceIndex: index, sourceTimes, text: quoted });
-            if (quoted.length < text.length) mandatory.push({ kind: "omission", role: "user", sourceIndex: index, sourceTimes,
-                reason: `Initiating prompt continues: characters ${quoted.length}-${text.length} omitted; read them with tuck_recall {"index":${index},"offset":${quoted.length}}` });
+            mandatory.push({ kind: "excerpt", role: "user", sourceIndex: index, text: quoted, sourceTimes });
+            if (quoted.length < text.length) mandatory.push({ kind: "omission", role: "user", sourceIndex: index,
+                reason: `Initiating prompt continues: characters ${quoted.length}-${text.length} omitted; read them with tuck_recall {"index":${index},"offset":${quoted.length}}`, sourceTimes });
         }
     }
     if (protectedUser?.type === "message" && protectedUser.message.role === "user")
-        mandatory.push({ kind: "excerpt", role: "user", sourceIndex: currentIndex, sourceTimes: [{ sourceIndex: currentIndex!, ...resolveSourceTime(protectedUser) }], text: textOf(protectedUser.message.content) });
+        mandatory.push({ kind: "excerpt", role: "user", sourceIndex: currentIndex, text: textOf(protectedUser.message.content), sourceTimes: [{ sourceIndex: currentIndex!, ...resolveSourceTime(protectedUser) }] });
     // The file ledger and the action trail of the compacted history are mandatory, so they are charged in base like the quotes above.
     // A locator is given only where tuck_recall {index} resolves it: a unique global index of a readable entry.
     const compacted = entries.slice(0, boundary), resolves = (entry: SessionEntry) => readable(entry) !== undefined;
@@ -207,8 +207,7 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
     const model = ctx.model;
     const floorAt = (keep: number) => {
         const ledger = [...actionRecords(actions, keep), ...ledgerRecords(items, keep)];
-        // Charged with the longer (ranked) closing, since the view is chosen later against this base.
-        return { ledger, base: measure(preview(serializeTranscript([...mandatory, ...ledger]) + RANKED_SUFFIX)) };
+        return { ledger, base: measure(preview(serializeTranscript([...mandatory, ...ledger]) + DIALOGUE_SUFFIX)) };
     };
     const fits = (base: number) => Boolean(model) && base + reserveTokens < model!.contextWindow && base < before;
     // When the whole floor cannot fit, the trail and the ledger keep only their headings and counts; only that can refuse the cut.
@@ -221,13 +220,12 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
     const compileInput = { messages, sourceIndices, sourceEntryIds: originalCut.selectedIds, sourceTimes: originalCut.selectedIds.map(id => resolveSourceTime(entryById.get(id)!)), receiptContext,
         ranking: { maxBriefChars, mandatorySourceIndices: new Set(mandatory.flatMap(r => r.sourceIndex === undefined ? [] : [r.sourceIndex])) },
     };
-    // All offers use the same parser, mandatory insertion, native preview and guard.
-    // Each view ends with its own closing section, true for what that view holds.
-    const assemble = (compiled: string, closing: string) => {
+    // Both views use the same parser, mandatory insertion, native preview and guard, and end with the same closing section.
+    const assemble = (compiled: string) => {
         if (typeof compiled !== "string") throw new Error("pi-tuck returned an invalid summary");
-        const split = compiled ? splitSummary(compiled) : { body: "" };
+        const split = compiled ? splitSummary(compiled) : { body: "", version: 2 as const };
         if (!split) throw new Error("pi-tuck returned an invalid summary");
-        const records = parseRecords(split.body);
+        const records = parseRecords(split.body, split.version);
         for (const record of mandatory) {
             const insertion = records.findIndex(row => row.sourceIndex !== undefined && row.sourceIndex > record.sourceIndex!);
             records.splice(insertion < 0 ? records.length : insertion, 0, record);
@@ -235,29 +233,29 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
         orderByOriginalSource(records, sourceIndices, originalCut.selectedIds);
         // The ledger always has its heading, so no summary is empty.
         records.push(...ledger);
-        const summary = serializeTranscript(records) + closing;
+        const summary = serializeTranscript(records) + DIALOGUE_SUFFIX;
         const projection = preview(summary);
         assertNativeToolRounds(projection);
         return { summary, after: measure(projection) };
     };
     const free = Math.max(0, model.contextWindow - reserveTokens - base - 1);
     const headroom = Math.ceil(free / 4);
-    // The whole pre-cut dialogue, when it fits the allowance; otherwise the ranked view fills the same allowance.
+    // The whole pre-cut dialogue, when it fits the allowance; otherwise the same dialogue shrunk to the same allowance.
     // With no allowance only an operator's manual cut can use it.
     const dialogue = maxBriefChars > 0 || input.operatorManual ? tuck.compileDialogue(compileInput) : "";
     const dialogueFits = dialogue.length <= maxBriefChars;
-    const candidate = dialogue && (dialogueFits || input.operatorManual) ? assemble(dialogue, DIALOGUE_SUFFIX) : undefined;
+    const candidate = dialogue && (dialogueFits || input.operatorManual) ? assemble(dialogue) : undefined;
     const offer = candidate && dialogueFits && candidate.after < before && candidate.after + reserveTokens + headroom < model.contextWindow ? candidate : undefined;
     // Manual no-work preserves native originals; final request admission still owns full overhead.
     if (!offer && input.operatorManual && candidate && candidate.after >= before &&
         before + reserveTokens < model.contextWindow)
         return { unavailable: "Manual compaction preserved original dialogue: the complete-dialogue view does not reduce context" };
-    const { summary, after } = offer ?? assemble(tuck.compileRanked(compileInput), RANKED_SUFFIX);
+    const { summary, after } = offer ?? assemble(tuck.compileShrunkDialogue(compileInput));
     // Draft reduction concerns conversation. Final request admission owns the effective system/tools.
     if (after + reserveTokens >= model.contextWindow || after >= before)
         return { unavailable: "pi-tuck's draft does not reduce context within the request budget", capacityRejected: after + reserveTokens >= model.contextWindow };
-    const mode: DraftMode = offer ? "dialogue" : "ranked";
-	return { compaction: { summary, firstKeptEntryId: cut.firstKeptEntryId, tokensBefore: input.tokensBefore, details: { ...details, tokensAfter: after, view: offer ? "complete-dialogue" : "ranked", mode } }, after, mode };
+    const mode: DraftMode = offer ? "dialogue" : "shrunk";
+	return { compaction: { summary, firstKeptEntryId: cut.firstKeptEntryId, tokensBefore: input.tokensBefore, details: { ...details, tokensAfter: after, view: offer ? "complete-dialogue" : "shrunk-dialogue", mode } }, after, mode };
     };
     const preferred = compileAtCut(cut);
     if (preferred.mode === "dialogue") return preferred;

package/dist/src/tuck/core/brief-meter.d.ts

@@ -1,42 +0,0 @@
-import type { NormalizedBlock } from "../types.js";
-import { type ExcerptCache } from "./brief.js";
-/** A set of integers in [0, size) with ordered neighbour queries, in a tree of 32-bit words. */
-export declare class IndexSet {
-    private readonly levels;
-    constructor(size: number);
-    has(i: number): boolean;
-    add(i: number): void;
-    remove(i: number): void;
-    /** The smallest member above `i`, or -1. */
-    next(i: number): number;
-    /** The largest member below `i`, or -1. */
-    prev(i: number): number;
-}
-export interface BriefSize {
-    chars: number;
-    units: number;
-}
-export interface BriefMeter {
-    /** Block `i` joins the selection, or leaves it again. */
-    select(i: number): void;
-    unselect(i: number): void;
-    /** Block `i` is rendered whole instead of as an excerpt, or no longer. */
-    promote(i: number): void;
-    demote(i: number): void;
-    /** The rendered size of the selection, were the unselected blocks `added` selected too, with and without the omission notices. */
-    size(added: readonly number[]): {
-        withNotices: BriefSize;
-        withoutNotices: BriefSize;
-    };
-    /** Settles the omission notices for blocks selected for good. */
-    commit(added: readonly number[]): void;
-}
-/**
- * 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 declare const createBriefMeter: (blocks: NormalizedBlock[], mandatory: ReadonlySet<number> | undefined, cache: ExcerptCache) => BriefMeter;

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[];