pi-tuck 1.0.16 → 1.0.18

package/dist/src/history-tools.js

@@ -0,0 +1,59 @@
+import { getCurrentTools } from "@earendil-works/pi-ai";
+import { convertToLlm } from "@earendil-works/pi-coding-agent";
+const own = (name) => name === "tuck_recall" || name === "tuck_search";
+/** Native Pi compactions do not make pi-tuck history available. No session-wide activation state. */
+export const hasTuckCut = (branch) => branch.some(entry => entry.type === "compaction" && entry.details?.compactor === "pi-tuck");
+/** Preserve the host's loadout and its order; only our registered tools may change. */
+export function historyToolNames(pi, names, enabled) {
+    if (!enabled)
+        return names.filter(name => !own(name));
+    const registered = new Set(pi.getAllTools().map(tool => tool.name));
+    return [...names, ...["tuck_recall", "tuck_search"].filter(name => registered.has(name) && !names.includes(name))];
+}
+export function applyHistoryTools(pi, enabled) {
+    const current = pi.getActiveTools(), next = historyToolNames(pi, current, enabled);
+    if (current.length !== next.length || current.some((name, index) => name !== next[index]))
+        pi.setActiveTools(next);
+}
+/** Match only our part of Pi's saved declaration snapshot, so its loop records no activation/removal message. Legacy sessions can
+ * already declare our tools; new sessions declare them only in the request projection. Executable tools are restored at turn_start. */
+export function stageHistoryTools(pi, messages) {
+    const declared = new Set(getCurrentTools(convertToLlm(messages)).map(tool => tool.name));
+    const current = pi.getActiveTools();
+    const next = historyToolNames(pi, current, true).filter(name => !own(name) || declared.has(name));
+    if (current.length !== next.length || current.some((name, index) => name !== next[index]))
+        pi.setActiveTools(next);
+    return next;
+}
+/** Pi has already declared the request's tools before queued user messages are appended. A prompt cut planned on such a message needs its declarations
+ * in that very request. Change only our declarations, leaving all other system content and tools in their original places. */
+export function historyToolDeclarations(messages, tools, enabled) {
+    let changed = false;
+    const filtered = messages.map(message => {
+        if (message.role !== "system")
+            return message;
+        const added = message.toolsAdded?.filter(tool => !own(tool.name));
+        const removed = message.toolsRemoved?.filter(tool => !own(tool.name));
+        if (added?.length === message.toolsAdded?.length && removed?.length === message.toolsRemoved?.length)
+            return message;
+        changed = true;
+        const { toolsAdded: _, toolsRemoved: __, ...rest } = message;
+        return { ...rest, ...(added?.length ? { toolsAdded: added } : {}), ...(removed?.length ? { toolsRemoved: removed } : {}) };
+    });
+    // Leave an already-correct transcript byte-identical, including the original placement of our declarations.
+    const declared = getCurrentTools(convertToLlm(messages));
+    const wanted = enabled ? tools.filter(tool => own(tool.name)) : [];
+    if (enabled && wanted.every(tool => declared.some(current => own(current.name) && current.name === tool.name)) &&
+        declared.filter(tool => own(tool.name)).length === wanted.length)
+        return messages;
+    if (!enabled || !wanted.length)
+        return changed ? filtered : messages;
+    const at = filtered.findLastIndex(message => message.role === "system");
+    if (at < 0)
+        throw new Error("Missing Pi system message for history tool declarations");
+    const system = filtered[at];
+    if (system.role !== "system")
+        throw new Error("Missing Pi system message");
+    filtered[at] = { ...system, toolsAdded: [...(system.toolsAdded ?? []), ...wanted] };
+    return filtered;
+}

package/dist/src/ledger.d.ts

@@ -1,7 +1,5 @@
 import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 import type { TranscriptRecord } from "./tuck/core/transcript.js";
-/** The initiating prompt is quoted whole up to this many characters; the rest stays readable through tuck_recall. */
-export declare const MAX_TASK_CONTRACT_CHARACTERS = 12000;
 /** Owner default; older distinct paths are counted, not listed. */
 export declare const MAX_LEDGER_LINES = 60;
 export declare const LEDGER_HEADING = "Files touched by read, write and edit before this summary, newest first, with the last operation:";

package/dist/src/ledger.js

@@ -1,8 +1,6 @@
 import { isLookupTool } from "./tuck/core/recall-operation.js";
 import { isDiscardedResponse } from "./protocol.js";
 import { extractPath } from "./tuck/core/tool-args.js";
-/** The initiating prompt is quoted whole up to this many characters; the rest stays readable through tuck_recall. */
-export const MAX_TASK_CONTRACT_CHARACTERS = 12000;
 /** Owner default; older distinct paths are counted, not listed. */
 export const MAX_LEDGER_LINES = 60;
 const LEDGER_TITLE = "Files";

package/dist/src/omissions.d.ts

@@ -3,7 +3,7 @@ import { type RecallPolicy } from './recall.js';
 /** Native branch edits supply exclusion; original global indices supply provenance. */
 export declare function omittedSourceIndices(entries: readonly SessionEntry[], branch: readonly SessionEntry[]): ReadonlySet<number>;
 /** Preserve surviving record bytes/order, and the summary's format (a v1 summary stays v1). No text matching or semantic inference. */
-export declare function filterOmittedSummary(summary: string, omitted: ReadonlySet<number>): string;
+export declare function filterOmittedSummary(summary: string, omitted: ReadonlySet<number>, sources?: readonly SessionEntry[], rangeOmitted?: ReadonlySet<number>): string;
 /** Custom quotes carry native entry identity; no text matching or legacy fallback. */
 export declare function filterCustomQuotes(summary: string, entries: readonly SessionEntry[], branch: readonly SessionEntry[], policy?: RecallPolicy): string;
 type ProjectedMessages = ReturnType<ExtensionContext['sessionManager']['buildSessionProjection']>['messages'];

package/dist/src/omissions.js

@@ -1,9 +1,10 @@
 import { buildGlobalIndexById } from './tuck/core/global-indices.js';
-import { parseRecords, splitSummary, transcriptHeader } from './tuck/core/transcript.js';
+import { parseRecords, serializeRecord, splitSummary, transcriptHeader } from './tuck/core/transcript.js';
+import { textOf } from "./tuck/core/content.js";
+import { isDiscardedResponse } from "./protocol.js";
 import { createRecall } from './recall.js';
 /** Native branch edits supply exclusion; original global indices supply provenance. */
 export function omittedSourceIndices(entries, branch) {
-    const indices = buildGlobalIndexById(entries);
     const edits = new Set();
     for (const entry of branch)
         if (entry.type === 'context_edit') {
@@ -11,10 +12,13 @@ export function omittedSourceIndices(entries, branch) {
                 throw new Error('pi-tuck does not support replacement context edits');
             edits.add(entry.targetId);
         }
+    if (!edits.size)
+        return new Set();
+    const indices = buildGlobalIndexById(entries);
     return new Set([...edits].flatMap(id => indices.has(id) ? [indices.get(id)] : []));
 }
 /** Preserve surviving record bytes/order, and the summary's format (a v1 summary stays v1). No text matching or semantic inference. */
-export function filterOmittedSummary(summary, omitted) {
+export function filterOmittedSummary(summary, omitted, sources, rangeOmitted = omitted) {
     if (!omitted.size)
         return summary;
     const split = splitSummary(summary);
@@ -22,7 +26,71 @@ export function filterOmittedSummary(summary, omitted) {
         throw new Error('Cannot apply native source omission to an unsupported compaction summary');
     const { body, closing, version } = split;
     const records = parseRecords(body, version), lines = body ? body.split('\n') : [];
-    const retained = records.flatMap((record, i) => (record.sourceIndex !== undefined && omitted.has(record.sourceIndex)) || record.sourceIndices?.some(index => omitted.has(index)) ? [] : [lines[i]]);
+    // A broad range does not identify the role of an intervening source. Without
+    // original sources there is no evidence that an edit removes a counted unit.
+    const indices = sources && rangeOmitted.size && records.some(record => record.sourceRange) ? buildGlobalIndexById(sources) : undefined;
+    const sourceUnits = new Map();
+    const shownBySource = new Map();
+    for (const record of records)
+        if (record.kind === 'excerpt' && record.sourceIndex !== undefined && !record.span) {
+            const key = `${record.role}:${record.sourceIndex}`, shown = shownBySource.get(key) ?? [];
+            shown.push(record.text);
+            shownBySource.set(key, shown);
+        }
+    if (indices && sources)
+        for (const entry of sources) {
+            if (entry.type !== 'message')
+                continue;
+            const index = indices.get(entry.id);
+            if (index === undefined)
+                continue;
+            const message = entry.message;
+            const shown = shownBySource.get(`${message.role}:${index}`) ?? [];
+            if (message.role === 'user') {
+                const text = textOf(message.content);
+                sourceUnits.set(index, { role: 'user', missing: Number(Boolean(text.length) && !shown.includes(text)) });
+            }
+            else if (message.role === 'assistant' && !isDiscardedResponse(message)) {
+                const available = [...shown];
+                let missing = 0;
+                for (const part of message.content)
+                    if (part.type === 'text' && part.text.trim()) {
+                        const at = available.indexOf(part.text);
+                        if (at < 0)
+                            missing++;
+                        else
+                            available.splice(at, 1);
+                    }
+                sourceUnits.set(index, { role: 'assistant', missing });
+            }
+            else if (message.role === 'toolResult')
+                sourceUnits.set(index, { role: 'toolResult', missing: 1 });
+        }
+    const retained = records.flatMap((record, at) => {
+        if ((record.sourceIndex !== undefined && omitted.has(record.sourceIndex)) || record.sourceIndices?.some(index => omitted.has(index)))
+            return [];
+        if (!record.sourceRange || !indices || record.count === undefined)
+            return [lines[at]];
+        const range = record.sourceRange;
+        let removed = 0;
+        const remaining = [];
+        for (const [index, unit] of sourceUnits) {
+            if (index < range.start || index > range.end || unit.role !== record.role || !unit.missing)
+                continue;
+            if (rangeOmitted.has(index))
+                removed += unit.missing;
+            else if (!omitted.has(index))
+                remaining.push(index);
+        }
+        if (!removed)
+            return [lines[at]];
+        const count = record.count - removed;
+        if (count <= 0)
+            return [];
+        const sourceRange = remaining.length ? { start: Math.min(...remaining), end: Math.max(...remaining) } : range;
+        const adjusted = { ...record, count, sourceRange };
+        return [version === 1 ? JSON.stringify(adjusted) : serializeRecord(adjusted)];
+    });
     return transcriptHeader(version) + '\n' + retained.join('\n') + closing;
 }
 /** Custom quotes carry native entry identity; no text matching or legacy fallback. */
@@ -31,6 +99,9 @@ export function filterCustomQuotes(summary, entries, branch, policy = {}) {
     if (!split)
         throw new Error('Cannot resolve custom sources in an unsupported compaction summary');
     const { body, closing, version } = split;
+    const records = parseRecords(body, version);
+    if (!records.some(record => record.role === "custom"))
+        return summary;
     const omitted = new Set(branch.flatMap(entry => entry.type === 'context_edit' && entry.replacement === null ? [entry.targetId] : []));
     const eligible = createRecall(policy).isHistorySource, indices = buildGlobalIndexById(entries);
     const globalCounts = new Map(), branchSources = new Map();
@@ -42,7 +113,6 @@ export function filterCustomQuotes(summary, entries, branch, policy = {}) {
         branchSources.set(entry.id, found);
     }
     const lines = body ? body.split('\n') : [];
-    const records = parseRecords(body, version);
     const retained = records.flatMap((record, i) => {
         if (record.role !== 'custom')
             return [lines[i]];
@@ -62,8 +132,20 @@ export function filterCustomQuotes(summary, entries, branch, policy = {}) {
 function projectMessages(messages, ctx, policy, allowForeign) {
     const entries = ctx.sessionManager.getEntries(), branch = ctx.sessionManager.getBranch();
     const omitted = omittedSourceIndices(entries, branch);
+    const lastCut = branch.findLastIndex(entry => entry.type === 'compaction');
+    const cut = branch[lastCut];
+    const afterCut = new Set();
+    if (omitted.size && cut?.type === 'compaction') {
+        const indices = buildGlobalIndexById(entries);
+        for (const entry of branch.slice(lastCut + 1))
+            if (entry.type === 'context_edit' && entry.replacement === null) {
+                const index = indices.get(entry.targetId);
+                if (index !== undefined)
+                    afterCut.add(index);
+            }
+    }
     return messages.map(message => message.role === 'compactionSummary' && (!allowForeign || splitSummary(message.summary) !== undefined)
-        ? { ...message, summary: filterCustomQuotes(filterOmittedSummary(message.summary, omitted), entries, branch, policy) } : message);
+        ? { ...message, summary: filterCustomQuotes(filterOmittedSummary(message.summary, omitted, entries, cut?.type === 'compaction' && cut.summary === message.summary ? afterCut : new Set()), entries, branch, policy) } : message);
 }
 export function projectedMessages(messages, ctx, policy) {
     return projectMessages(messages, ctx, policy, false);

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

@@ -7,13 +7,16 @@ export type DialogueBlock = Extract<NormalizedBlock, {
 export declare const isDialogue: (block: NormalizedBlock) => block is DialogueBlock;
 /** A user or assistant text block the omission notices count when it is unselected: non-empty, and not rendered in the mandatory base. */
 export declare const isOmittable: (block: NormalizedBlock, mandatorySources?: ReadonlySet<number>) => boolean;
-/** `sources` are the distinct locators of the omitted blocks in ascending order; at most the first 9 decide the notice. They are written
- * as "#N" on the record's line. */
-export declare const omissionRecord: (role: "user" | "assistant", count: number, sources: number[], unlocated: boolean) => TranscriptRecord;
+/** Count dropped units inside inclusive original-index bounds. The range may
+ * contain retained units and other roles; only omitted units of this role count. */
+export declare const omissionRecord: (role: "user" | "assistant" | "toolResult", count: number, sources: number[], unlocated: boolean) => TranscriptRecord;
 /** The word budgets of a clipped excerpt: the passages kept from the start of the text, and from its end. */
 export type Clip = readonly [headWords: number, tailWords: number];
 /** The records of one dialogue block alone, before source times are attached: its whole original text, or, with a `clip`, the excerpts
  * that keep their sanitized-block spans around an omission. A mandatory source renders nothing: the adapter quotes it in its base. */
 export declare const blockRecords: (b: DialogueBlock, mandatory: ReadonlySet<number> | undefined, clip?: Clip) => TranscriptRecord[];
+/** Exact user text prefixes are allowed to split a passage. Unlike assistant
+ * passage clips, their explicit continuation points at the unabridged input. */
+export declare const userPrefixRecords: (block: DialogueBlock, mandatory: ReadonlySet<number> | undefined, take: number) => TranscriptRecord[];
 /** A source time for each locator a user record names; only briefs of times-carrying blocks have them. */
 export declare const decorateRecord: (record: TranscriptRecord, times: NormalizedBlock["sourceTimes"]) => TranscriptRecord;

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

@@ -134,18 +134,16 @@ const excerptRecords = (text, { passages, costs }, role, sourceIndex, headLimit,
 };
 export const isDialogue = (block) => block.kind === "user" || block.kind === "assistant" || block.kind === "notice";
 /** A user or assistant text block the omission notices count when it is unselected: non-empty, and not rendered in the mandatory base. */
-export const isOmittable = (block, mandatorySources) => (block.kind === "user" || block.kind === "assistant") && Boolean(block.text.trim()) &&
+export const isOmittable = (block, mandatorySources) => (block.kind === "assistant" || block.kind === "user" && !block.image) && Boolean(block.text.trim()) &&
     (block.sourceIndex === undefined || !mandatorySources?.has(block.sourceIndex));
-/** `sources` are the distinct locators of the omitted blocks in ascending order; at most the first 9 decide the notice. They are written
- * as "#N" on the record's line. */
+/** Count dropped units inside inclusive original-index bounds. The range may
+ * contain retained units and other roles; only omitted units of this role count. */
 export const omissionRecord = (role, count, sources, unlocated) => ({
     kind: "omission", role, count,
-    ...(sources.length ? { sourceIndices: sources.slice(0, 8) } : {}),
-    reason: "Completely unselected historical text blocks; count is text blocks, not messages. " +
-        "The # locators are individual original locators, not a contiguous range. " +
-        (sources.length > 8 ? "Locator list incomplete. " : "") +
-        (unlocated ? "Some text blocks have no source locator. " : "") +
-        "Read originals with tuck_recall; omitted text may qualify retained text. No new authority."
+    ...(sources.length ? { sourceRange: { start: sources.reduce((a, b) => Math.min(a, b)), end: sources.reduce((a, b) => Math.max(a, b)) } } : {}),
+    reason: (role === "toolResult" ? "Historical tool actions and observations omitted. " : "Historical text units omitted. ") +
+        (unlocated ? "Some units have no source locator. " : "") +
+        "Count is omitted units of this role in the index range; read originals with tuck_recall."
 });
 const analyses = new WeakMap();
 /** The records of one dialogue block alone, before source times are attached: its whole original text, or, with a `clip`, the excerpts
@@ -167,11 +165,31 @@ export const blockRecords = (b, mandatory, clip) => {
     const readFrom = (offset) => locator ? `tuck_recall ${JSON.stringify(exact ? { ...locator, offset } : locator)}` : "source has no locator to read it by";
     return excerptRecords(b.text, analysis, role, b.sourceIndex, clip[0], clip[1], readFrom).map(record => ({ ...record, ...notice }));
 };
+/** Exact user text prefixes are allowed to split a passage. Unlike assistant
+ * passage clips, their explicit continuation points at the unabridged input. */
+export const userPrefixRecords = (block, mandatory, take) => {
+    if (block.kind !== "user" || block.sourceIndex !== undefined && mandatory?.has(block.sourceIndex))
+        return [];
+    const text = block.originalText ?? block.text;
+    if (take <= 0 || !text.length)
+        return [];
+    let end = Math.min(text.length, Math.floor(take));
+    // Charge the complete code point in the measured candidate, including the
+    // low surrogate, so a protected 80-character opening never shrinks to 79.
+    if (end < text.length && /[\uD800-\uDBFF]/u.test(text[end - 1]))
+        end++;
+    const locator = block.sourceIndex === undefined ? undefined : { index: block.sourceIndex };
+    return [{ kind: "excerpt", role: "user", sourceIndex: block.sourceIndex, text: text.slice(0, end) },
+        ...(end < text.length ? [{ kind: "omission", role: "user", sourceIndex: block.sourceIndex,
+                reason: locator ? `tuck_recall ${JSON.stringify(block.startsSource ? { ...locator, offset: end } : locator)}` : "Source has no locator" }] : [])];
+};
 /** A source time for each locator a user record names; only briefs of times-carrying blocks have them. */
 export const decorateRecord = (record, times) => {
     // Times mark the user's turns only: on every record they cost a fifth to a third of the summary's tokens.
     if (!times || record.role !== "user")
         return record;
+    if (record.sourceRange)
+        return record;
     const indices = record.sourceIndices ?? (record.sourceIndex === undefined ? [] : [record.sourceIndex]);
     return indices.length ? { ...record, sourceTimes: indices.map(sourceIndex => ({ sourceIndex, ...(times[sourceIndex] ?? { basis: "unknown" }) })) } : record;
 };

package/dist/src/tuck/core/filter-noise.d.ts

@@ -1,3 +1,3 @@
 import type { NormalizedBlock } from "../types.js";
-/** Suppress lookup echoes, retaining recorded export attempts and exactly paired outcomes. */
+/** Suppress lookup call echoes. Every result stays available for counted omissions. */
 export declare const filterNoise: (blocks: NormalizedBlock[]) => NormalizedBlock[];

package/dist/src/tuck/core/filter-noise.js

@@ -1,7 +1,5 @@
 import { isSourceExport, isLookupTool, isRecallTool } from "./recall-operation.js";
 import { isDialogue } from "./brief.js";
-/** Suppress lookup echoes, retaining recorded export attempts and exactly paired outcomes. */
+/** Suppress lookup call echoes. Every result stays available for counted omissions. */
 export const filterNoise = (blocks) => blocks.filter(b => !(b.kind === "tool_call" && isLookupTool(b.name) && !(isRecallTool(b.name) && isSourceExport(b.args))) &&
-    !(b.kind === "tool_result" && isLookupTool(b.name) &&
-        !(isRecallTool(b.name) && b.recallExport)) &&
     !(isDialogue(b) && !b.text.trim()));

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

@@ -7,8 +7,5 @@ import type { CompilerMessage, NormalizedBlock } from "../types.js";
  * legacy positional behavior is preserved (used by callers/tests that have no
  * index space to map into).
  */
-/** Pair against eligible original history, not only the selected prefix. Never infer effects. */
-export declare const normalize: (messages: CompilerMessage[], sourceIndices?: Array<number | undefined>, receiptContext?: {
-    messages: CompilerMessage[];
-    sourceIndices: Array<number | undefined>;
-}, sourceEntryIds?: readonly string[], sourceTimes?: readonly import("./source-time.js").SourceTime[]) => NormalizedBlock[];
+/** Original-source blocks only; every historical result is counted, without pairing or inferred effects. */
+export declare const normalize: (messages: CompilerMessage[], sourceIndices?: Array<number | undefined>, sourceEntryIds?: readonly string[], sourceTimes?: readonly import("./source-time.js").SourceTime[]) => NormalizedBlock[];

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

@@ -1,4 +1,3 @@
-import { isSourceExport } from "./recall-operation.js";
 import { textOf } from "./content.js";
 import { sanitize } from "./sanitize.js";
 const normalizeOne = (msg, msgIndex) => {
@@ -12,7 +11,7 @@ const normalizeOne = (msg, msgIndex) => {
         if (msg.content && typeof msg.content !== "string") {
             for (const part of msg.content) {
                 if (part.type === "image") {
-                    blocks.push({ kind: "user", text: `[image: ${part.mimeType}]`, sourceIndex: msgIndex });
+                    blocks.push({ kind: "user", image: true, text: `[image: ${part.mimeType}]`, sourceIndex: msgIndex });
                 }
             }
         }
@@ -58,45 +57,28 @@ const normalizeOne = (msg, msgIndex) => {
  * legacy positional behavior is preserved (used by callers/tests that have no
  * index space to map into).
  */
-/** Pair against eligible original history, not only the selected prefix. Never infer effects. */
-export const normalize = (messages, sourceIndices, receiptContext, sourceEntryIds, sourceTimes) => {
+/** Original-source blocks only; every historical result is counted, without pairing or inferred effects. */
+export const normalize = (messages, sourceIndices, sourceEntryIds, sourceTimes) => {
     if (sourceEntryIds && sourceEntryIds.length !== messages.length)
         throw new Error("Original entry IDs must align with compiler messages");
     if (sourceTimes && sourceTimes.length !== messages.length)
         throw new Error("Original times must align with compiler messages");
     const timeByIndex = Object.fromEntries((sourceIndices ?? messages.map((_, i) => i)).flatMap((index, i) => index === undefined || !sourceTimes ? [] : [[index, sourceTimes[i]]]));
-    const pairs = new Map();
-    const group = (id) => {
-        if (typeof id !== "string" || !id)
-            throw new Error("Tool history lacks a recorded call identity");
-        let pair = pairs.get(id);
-        if (!pair) {
-            pair = { calls: [], receipts: [] };
-            pairs.set(id, pair);
-        }
-        return pair;
-    };
-    (receiptContext?.messages ?? messages).forEach((msg, order) => {
-        if (msg.role === "assistant" && Array.isArray(msg.content))
-            for (const part of msg.content) {
-                if (part.type === "toolCall")
-                    group(part.id).calls.push({ name: part.name, order, args: part.arguments });
-            }
-        if (msg.role === "toolResult") {
-            if (typeof msg.isError !== "boolean")
+    // Identity/status validation is still useful for malformed source history;
+    // export pairing is not: every result now contributes to counted omissions.
+    for (const message of messages) {
+        if (message.role === "toolResult") {
+            if (typeof message.toolCallId !== "string" || !message.toolCallId)
+                throw new Error("Tool history lacks a recorded call identity");
+            if (typeof message.isError !== "boolean")
                 throw new Error("Tool receipt lacks a recorded error status");
-            group(msg.toolCallId).receipts.push({ name: msg.toolName, order });
         }
-    });
-    // A call paired with exactly one later receipt of the same tool has a recorded outcome. An export through recall keeps its outcome block.
-    const paired = (id) => {
-        const pair = pairs.get(id), call = pair?.calls[0], receipt = pair?.receipts[0];
-        return Boolean(pair && call && receipt && pair.calls.length === 1 && pair.receipts.length === 1 && receipt.name === call.name && receipt.order > call.order);
-    };
+        if (message.role === "assistant" && Array.isArray(message.content))
+            for (const part of message.content)
+                if (part.type === "toolCall" && (typeof part.id !== "string" || !part.id))
+                    throw new Error("Tool history lacks a recorded call identity");
+    }
     return messages.flatMap((msg, i) => normalizeOne(msg, sourceIndices ? sourceIndices[i] : i).map(block => {
-        if (block.kind === "tool_result" && msg.role === "toolResult" && paired(msg.toolCallId) &&
-            isSourceExport(pairs.get(msg.toolCallId)?.calls[0]?.args))
-            block = { ...block, recallExport: true };
         if (sourceTimes)
             block = { ...block, sourceTimes: timeByIndex };
         return block.kind === "notice" && sourceEntryIds?.[i] !== undefined ? { ...block, sourceEntryId: sourceEntryIds[i] } : block;

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

@@ -8,26 +8,18 @@ export interface DialogueInput {
     sourceIndices: readonly (number | undefined)[];
     sourceEntryIds?: readonly string[];
 }
-/** The configurations the ladder tries, in order; "none" is no configuration that fits. */
-export type Step = "whole" | `A${1 | 2 | 3}` | "B" | `C${1 | 2 | 3}` | "D" | "E1" | "E2" | "none";
+/** Whether the ranked view is whole, selected, or cannot fit its omission metadata. */
+export type Step = "whole" | "ranked" | "none";
 export interface Shrunk {
     /** The summary text, or "" when nothing fits. */
     text: string;
     step: Step;
-    /** The length the ladder computed from per-unit lengths before it rendered `text`. */
+    /** The serialized size of the selected view. */
     size: number;
 }
 /** The whole pre-cut dialogue: user, assistant and notice records; tool actions and observations are omitted. "" when it renders nothing. */
 export declare const wholeDialogue: (input: DialogueInput) => string;
-/**
- * The same dialogue shrunk until its summary text is at most `limit` characters, oldest first. The first configuration that fits wins:
- *   A. the newest k assistant units whole, the older ones clipped to tier 1, 2, 3 (the largest k that fits, for each tier in turn);
- *   B. the newest assistant units that fit a third of the limit whole, the older ones at tier 3 with the oldest d dropped;
- *   C. the newest assistant units that fit a third of the limit at tier 3, the rest dropped; then the oldest u user units clipped to tier 1, 2, 3;
- *   D. every user unit at tier 3, the oldest dropped;
- *   E. the oldest notices dropped, then the oldest of the remaining assistant units.
- * Every step is a one-parameter family whose size is read from prefix sums of the per-unit lengths, so a step costs O(units). A notice is clipped
- * to its one tier in every configuration but the whole dialogue. The size is arithmetic over unit lengths; the rendered text has the last say:
- * a configuration whose text is over the limit is passed over.
- */
+/** Lower ranks of the single fill: the existing recent assistant third, then
+ * more user turns newest first, then the remaining dialogue newest first.
+ * Each lane grows only from its recent end; complete passages remain atomic. */
 export declare const shrinkDialogue: (input: DialogueInput, limit: number) => Shrunk;