@bastani/atomic 0.8.26-alpha.1 → 0.8.26-alpha.11

package/dist/core/compaction/context-compaction.js

@@ -0,0 +1,1636 @@
+import { Agent } from "@earendil-works/pi-agent-core";
+import { createAssistantMessageEventStream, getSupportedThinkingLevels, isContextOverflow, streamSimple, StringEnum, } from "@earendil-works/pi-ai";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Type } from "typebox";
+import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "../messages.js";
+import { buildContextDeletionFilteredPath, buildContextDeletionFilters, } from "../session-manager.js";
+import { estimateTokens } from "./compaction.js";
+export const CONTEXT_COMPACTION_PROMPT_VERSION = 1;
+const CONTEXT_COMPACTION_THINKING_LEVEL_ORDER = ["off", "minimal", "low", "medium", "high", "xhigh"];
+const CONTEXT_DELETE_TOOL_NAME = "context_delete";
+const CONTEXT_GREP_DELETE_TOOL_NAME = "context_grep_delete";
+const CONTEXT_SEARCH_TRANSCRIPT_TOOL_NAME = "context_search_transcript";
+const CONTEXT_READ_ENTRY_TOOL_NAME = "context_read_entry";
+export const CONTEXT_COMPACTION_MAX_TURNS = 50;
+const CONTEXT_GREP_DELETE_DEFAULT_MAX_MATCHES = 50;
+const CONTEXT_GREP_DELETE_MAX_REGEX_PATTERN_CHARS = 512;
+const CONTEXT_GREP_DELETE_MAX_REGEX_SCAN_CHARS = 250_000;
+const CONTEXT_MANIFEST_MAX_ENTRIES = 80;
+const CONTEXT_MANIFEST_PREVIEW_CHARS = 240;
+const CONTEXT_CRITICAL_OVERFLOW_RECENT_ENTRY_COUNT = 5;
+const CONTEXT_READ_ENTRY_DEFAULT_MAX_CHARS = 4000;
+const CONTEXT_READ_ENTRY_MAX_CHARS = 12_000;
+const CONTEXT_SEARCH_DEFAULT_MAX_MATCHES = 20;
+const CONTEXT_SEARCH_MAX_MATCHES = 100;
+const CONTEXT_SEARCH_DEFAULT_CONTEXT_CHARS = 160;
+const CONTEXT_SEARCH_MAX_CONTEXT_CHARS = 500;
+const ContextDeleteToolParameters = Type.Object({
+    deletions: Type.Array(Type.Object({
+        kind: StringEnum(["entry", "content_block"], {
+            description: "Delete an entire transcript entry or a single content block within one entry.",
+        }),
+        entryId: Type.String({ minLength: 1, description: "Stable transcript entry id to delete from." }),
+        blockIndex: Type.Optional(Type.Integer({
+            minimum: 0,
+            description: "Required when kind is content_block; omit when kind is entry.",
+        })),
+    }, { additionalProperties: false }), { description: "Deletion targets only. Protected entries and recent active context must not be included." }),
+}, { additionalProperties: false });
+const ContextGrepDeleteToolParameters = Type.Object({
+    pattern: Type.String({ minLength: 1, description: "Literal text or regular expression to match in transcript text." }),
+    regex: Type.Optional(Type.Boolean({ description: "Treat pattern as a JavaScript regular expression. Defaults to false." })),
+    caseSensitive: Type.Optional(Type.Boolean({ description: "Use case-sensitive matching. Defaults to false." })),
+    target: Type.Optional(StringEnum(["entry", "content_block"], {
+        description: "Delete whole matching entries or matching content blocks. Defaults to entry.",
+    })),
+    maxMatches: Type.Optional(Type.Integer({
+        minimum: 1,
+        maximum: 200,
+        description: "Safety cap. If more unprotected, not-yet-deleted candidate targets are found, no deletions are applied. Defaults to 50.",
+    })),
+    expectedMatchCount: Type.Optional(Type.Integer({
+        minimum: 0,
+        description: "Optional safety check. If the match count differs, no deletions are applied.",
+    })),
+}, { additionalProperties: false });
+const ContextSearchTranscriptToolParameters = Type.Object({
+    pattern: Type.String({ minLength: 1, description: "Literal text or regular expression to search for." }),
+    regex: Type.Optional(Type.Boolean({ description: "Treat pattern as a JavaScript regular expression. Defaults to false." })),
+    caseSensitive: Type.Optional(Type.Boolean({ description: "Use case-sensitive matching. Defaults to false." })),
+    target: Type.Optional(StringEnum(["entry", "content_block"], {
+        description: "Search whole entry text or individual content-block text. Defaults to entry.",
+    })),
+    maxMatches: Type.Optional(Type.Integer({ minimum: 1, maximum: CONTEXT_SEARCH_MAX_MATCHES, description: "Maximum matches to return. Defaults to 20." })),
+    contextChars: Type.Optional(Type.Integer({
+        minimum: 0,
+        maximum: CONTEXT_SEARCH_MAX_CONTEXT_CHARS,
+        description: "Characters of context to include before and after each match. Defaults to 160.",
+    })),
+}, { additionalProperties: false });
+const ContextReadEntryToolParameters = Type.Object({
+    entryId: Type.String({ minLength: 1, description: "Stable transcript entry id to read." }),
+    blockIndex: Type.Optional(Type.Integer({ minimum: 0, description: "Optional content block index to read instead of the whole entry text." })),
+    offset: Type.Optional(Type.Integer({ minimum: 0, description: "Character offset to begin reading. Defaults to 0." })),
+    maxChars: Type.Optional(Type.Integer({
+        minimum: 1,
+        maximum: CONTEXT_READ_ENTRY_MAX_CHARS,
+        description: "Maximum characters to return. Defaults to 4000; keep reads small to avoid overflowing context.",
+    })),
+}, { additionalProperties: false });
+const CONTEXT_DELETE_TOOL = {
+    name: CONTEXT_DELETE_TOOL_NAME,
+    description: "Record context compaction deletion targets directly against the transcript.",
+    parameters: ContextDeleteToolParameters,
+};
+const CONTEXT_GREP_DELETE_TOOL = {
+    name: CONTEXT_GREP_DELETE_TOOL_NAME,
+    description: "Bulk-delete transcript entries or content blocks matching a guarded grep/regex query.",
+    parameters: ContextGrepDeleteToolParameters,
+};
+const CONTEXT_SEARCH_TRANSCRIPT_TOOL = {
+    name: CONTEXT_SEARCH_TRANSCRIPT_TOOL_NAME,
+    description: "Search the full transcript working copy and return small snippets without mutating deletion state.",
+    parameters: ContextSearchTranscriptToolParameters,
+};
+const CONTEXT_READ_ENTRY_TOOL = {
+    name: CONTEXT_READ_ENTRY_TOOL_NAME,
+    description: "Read a small slice of one transcript entry or content block from the full transcript working copy.",
+    parameters: ContextReadEntryToolParameters,
+};
+const CONTEXT_COMPACTION_SYSTEM_PROMPT = `You are a context compaction assistant.
+
+Your task is to read relevant parts of a conversation between a user and an AI assistant provided via a transcript file, then run a series of tools to apply deletion-only verbatim compaction using the exact context_delete or context_grep_delete format specified.`;
+const CONTEXT_COMPACTION_FIXED_PROMPT = `Reference the provided transcript file transcript and use your search/read tools for small inspections, then use context_delete or context_grep_delete for deletions.
+
+You MUST NOT summarize.
+You MUST NOT paraphrase.
+You MUST NOT generate replacement context.
+You MUST NOT mutate retained transcript objects or content.
+Deletion tool calls are the compaction action; record only deletion targets by stable ID.
+
+What Gets Deleted:
+- Redundant tool outputs: file reads already acted on, grep/search results already processed, passing test output no longer needed.
+- Exploratory dead ends: irrelevant files read, unhelpful or empty searches.
+- Verbose boilerplate: license headers, import blocks the agent isn't modifying, configuration files read for reference.
+- Superseded information: earlier versions of files that have since been edited, old error messages from bugs already fixed.
+
+What Survives:
+- Active file paths and line numbers: Any reference the agent might need to navigate.
+- Current error messages: Unresolved bugss and their exact text.
+- Reasoning decisions: Why the agent chose approach A over B. An agent's chain of thought (why it chose this file, what pattern it noticed, what fix it decided on) carries more information-per-token than the raw grep output or file content that informed those decisions.
+- Recent tool calls and their results: The last 3-5 operations.
+- User instructions: The original task and any clarifications.
+
+<output_format>
+Call the context_delete tool one or more times with deletion targets in this shape:
+{ "deletions": [{ "kind": "entry", "entryId": "..." }] }
+
+For content-block deletions, use:
+{ "kind": "content_block", "entryId": "...", "blockIndex": 0 }
+
+The tool applies and validates deletion targets immediately. You can continue calling it for additional deletions if useful.
+
+For guarded bulk deletion by text match, call context_grep_delete with a literal pattern or regex. It skips protected context, enforces maxMatches and expectedMatchCount, and validates through the same tool-call/tool-result safety rules.
+
+The full transcript is available as a JSONL file path in the prompt, but do NOT try to load the whole file into context. Use context_search_transcript to find candidate entry IDs and context_read_entry to read only small slices (for example maxChars 1000-4000) before deleting.
+
+When you are done, reply with a brief plain-text completion message. Do not write deletion JSON or deletion target IDs outside tool calls.
+</output_format>`;
+function getMessageFromEntry(entry) {
+    if (entry.type === "message") {
+        return entry.message;
+    }
+    if (entry.type === "custom_message") {
+        return createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp, entry.excludeFromContext);
+    }
+    if (entry.type === "branch_summary") {
+        return createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp);
+    }
+    return undefined;
+}
+function isExcludedFromLlmContext(message) {
+    switch (message.role) {
+        case "bashExecution":
+            return Boolean(message.excludeFromContext);
+        case "custom":
+            return message.excludeFromContext === true;
+        default:
+            return false;
+    }
+}
+function getContextEligibleMessageFromEntry(entry) {
+    const message = getMessageFromEntry(entry);
+    if (!message || isExcludedFromLlmContext(message))
+        return undefined;
+    return message;
+}
+function textFromUnknownContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return JSON.stringify(content);
+    return content.map((block) => textFromContentBlock(block)).join("\n");
+}
+function textFromContentBlock(block) {
+    if (!block || typeof block !== "object")
+        return String(block);
+    const record = block;
+    if (record.type === "text" && typeof record.text === "string")
+        return record.text;
+    if (record.type === "thinking" && typeof record.thinking === "string")
+        return record.thinking;
+    if (record.type === "toolCall") {
+        const name = typeof record.name === "string" ? record.name : "tool";
+        const id = typeof record.id === "string" ? record.id : "unknown";
+        const args = "arguments" in record ? JSON.stringify(record.arguments) : "";
+        return `toolCall ${id} ${name} ${args}`.trim();
+    }
+    if (record.type === "image")
+        return "[image]";
+    return JSON.stringify(record);
+}
+const IMAGE_BLOCK_CHAR_ESTIMATE = 4800;
+const IMAGE_BLOCK_TOKEN_ESTIMATE = Math.ceil(IMAGE_BLOCK_CHAR_ESTIMATE / 4);
+function estimateTextTokens(text) {
+    return Math.max(1, Math.ceil(text.length / 4));
+}
+function estimateContentBlockTokens(block, text) {
+    if (block && typeof block === "object" && block.type === "image") {
+        return IMAGE_BLOCK_TOKEN_ESTIMATE;
+    }
+    return estimateTextTokens(text);
+}
+function getToolCallIdFromBlock(block) {
+    if (!block || typeof block !== "object")
+        return undefined;
+    const record = block;
+    if (record.type !== "toolCall")
+        return undefined;
+    return typeof record.id === "string" ? record.id : undefined;
+}
+function getToolResultCallId(message) {
+    if (message.role !== "toolResult")
+        return undefined;
+    const callId = message.toolCallId;
+    return typeof callId === "string" ? callId : undefined;
+}
+function contentBlocksForEntry(entryId, message, protectedEntry, existingDeletedBlocks) {
+    if (message.role === "compactionSummary") {
+        const text = message.summary;
+        return [
+            {
+                entryId,
+                blockIndex: 0,
+                type: "summary",
+                text,
+                tokenEstimate: estimateTextTokens(text),
+                protected: protectedEntry,
+            },
+        ];
+    }
+    const content = message.content;
+    if (!Array.isArray(content))
+        return [];
+    return content
+        .map((block, blockIndex) => {
+        if (existingDeletedBlocks?.has(blockIndex))
+            return undefined;
+        const text = textFromContentBlock(block);
+        return {
+            entryId,
+            blockIndex,
+            type: block && typeof block === "object" && typeof block.type === "string"
+                ? (block.type)
+                : "unknown",
+            text,
+            tokenEstimate: estimateContentBlockTokens(block, text),
+            protected: protectedEntry,
+            toolCallId: getToolCallIdFromBlock(block),
+        };
+    })
+        .filter((block) => block !== undefined);
+}
+function messageText(message) {
+    switch (message.role) {
+        case "bashExecution":
+            return `Ran ${message.command}\n${message.output}`;
+        case "branchSummary":
+        case "compactionSummary":
+            return message.summary;
+        case "custom":
+        case "toolResult":
+        case "user":
+            return textFromUnknownContent(message.content);
+        case "assistant":
+            return textFromUnknownContent(message.content);
+    }
+}
+function hasAssistantError(message) {
+    return message.role === "assistant" && message.stopReason === "error";
+}
+function hasToolResultError(message) {
+    return message.role === "toolResult" && message.isError === true;
+}
+function hasFailedBashExecution(message) {
+    return message.role === "bashExecution" && typeof message.exitCode === "number" && message.exitCode !== 0;
+}
+function collectLatestSummaryCompactionIndex(pathEntries) {
+    for (let i = pathEntries.length - 1; i >= 0; i--) {
+        if (pathEntries[i].type === "compaction")
+            return i;
+    }
+    return -1;
+}
+function collectActiveEntryIndices(pathEntries, latestCompactionIndex) {
+    if (latestCompactionIndex < 0) {
+        return pathEntries.map((_, index) => index);
+    }
+    const latestCompaction = pathEntries[latestCompactionIndex];
+    if (latestCompaction.type !== "compaction")
+        return pathEntries.map((_, index) => index);
+    const indices = [];
+    let foundFirstKept = false;
+    for (let i = 0; i < latestCompactionIndex; i++) {
+        const entry = pathEntries[i];
+        if (entry.id === latestCompaction.firstKeptEntryId) {
+            foundFirstKept = true;
+        }
+        if (foundFirstKept)
+            indices.push(i);
+    }
+    for (let i = latestCompactionIndex + 1; i < pathEntries.length; i++) {
+        indices.push(i);
+    }
+    return indices;
+}
+function isProtectedEntry(entry, message, recentEntryIds) {
+    if (recentEntryIds.has(entry.id))
+        return true;
+    if (message.role === "user")
+        return true;
+    if (message.role === "custom")
+        return true;
+    if (message.role === "branchSummary" || message.role === "compactionSummary")
+        return true;
+    if (hasAssistantError(message) || hasToolResultError(message))
+        return true;
+    if (hasFailedBashExecution(message))
+        return true;
+    if (entry.type === "branch_summary")
+        return true;
+    return false;
+}
+export function prepareContextCompaction(pathEntries, settings, options = {}) {
+    if (pathEntries.length === 0)
+        return undefined;
+    const latestCompactionIndex = collectLatestSummaryCompactionIndex(pathEntries);
+    const deletionFilters = buildContextDeletionFilters(pathEntries);
+    const filteredPathEntries = buildContextDeletionFilteredPath(pathEntries, deletionFilters);
+    const filteredEntryById = new Map(filteredPathEntries.map((entry) => [entry.id, entry]));
+    const activeEntryIndices = collectActiveEntryIndices(pathEntries, latestCompactionIndex);
+    const messageEntryIds = activeEntryIndices
+        .map((index) => filteredEntryById.get(pathEntries[index].id))
+        .filter((entry) => entry !== undefined && getContextEligibleMessageFromEntry(entry) !== undefined)
+        .map((entry) => entry.id);
+    const recentEntryIds = new Set(messageEntryIds.slice(-CONTEXT_CRITICAL_OVERFLOW_RECENT_ENTRY_COUNT));
+    const protectedEntryIds = new Set();
+    const entries = [];
+    if (latestCompactionIndex >= 0) {
+        const latestCompaction = pathEntries[latestCompactionIndex];
+        if (latestCompaction.type === "compaction") {
+            const message = createCompactionSummaryMessage(latestCompaction.summary, latestCompaction.tokensBefore, latestCompaction.timestamp);
+            const contentBlocks = contentBlocksForEntry(latestCompaction.id, message, true, undefined);
+            protectedEntryIds.add(latestCompaction.id);
+            entries.push({
+                entryId: latestCompaction.id,
+                entryType: latestCompaction.type,
+                role: message.role,
+                text: messageText(message),
+                tokenEstimate: estimateTokens(message),
+                protected: true,
+                contentBlocks,
+                message,
+                toolCallIds: [],
+                toolResultFor: undefined,
+            });
+        }
+    }
+    for (const index of activeEntryIndices) {
+        const rawEntry = pathEntries[index];
+        const entry = filteredEntryById.get(rawEntry.id);
+        if (!entry || entry.type === "context_compaction")
+            continue;
+        const message = getContextEligibleMessageFromEntry(entry);
+        if (!message)
+            continue;
+        const protectedEntry = isProtectedEntry(entry, message, recentEntryIds);
+        if (protectedEntry)
+            protectedEntryIds.add(entry.id);
+        const rawMessage = getContextEligibleMessageFromEntry(rawEntry) ?? message;
+        const contentBlocks = contentBlocksForEntry(entry.id, rawMessage, protectedEntry, deletionFilters.deletedContentBlocks.get(entry.id));
+        const toolCallIds = contentBlocks.map((block) => block.toolCallId).filter((id) => id !== undefined);
+        const text = contentBlocks.length > 0 ? contentBlocks.map((block) => block.text).join("\n") : messageText(message);
+        entries.push({
+            entryId: entry.id,
+            entryType: entry.type,
+            role: message.role,
+            text,
+            tokenEstimate: estimateTokens(message),
+            protected: protectedEntry,
+            contentBlocks,
+            message,
+            toolCallIds,
+            toolResultFor: getToolResultCallId(message),
+        });
+    }
+    if (entries.length < 2)
+        return undefined;
+    return {
+        branchEntries: pathEntries,
+        mode: options.mode ?? "standard",
+        transcript: {
+            entries,
+            protectedEntryIds: [...protectedEntryIds],
+            tokensBefore: entries.reduce((total, entry) => total + entry.tokenEstimate, 0),
+            settings,
+        },
+    };
+}
+function targetKey(target) {
+    return target.kind === "entry" ? `entry:${target.entryId}` : `content_block:${target.entryId}:${target.blockIndex}`;
+}
+function rawTargetKey(target) {
+    return target.kind === "entry" ? `entry:${target.entryId}` : `content_block:${target.entryId}:${target.blockIndex}`;
+}
+function normalizeRawTarget(target) {
+    if (target.kind === "entry")
+        return { kind: "entry", entryId: target.entryId };
+    return { kind: "content_block", entryId: target.entryId, blockIndex: target.blockIndex };
+}
+function rawDeletionFromTarget(target) {
+    if (target.kind === "entry")
+        return { kind: "entry", entryId: target.entryId };
+    return { kind: "content_block", entryId: target.entryId, blockIndex: target.blockIndex };
+}
+function deletionRequestFromTargets(targets) {
+    return { deletions: targets.map(rawDeletionFromTarget) };
+}
+function getDeletedEntryIds(targets) {
+    return new Set(targets.filter((target) => target.kind === "entry").map((target) => target.entryId));
+}
+function getDeletedContentBlocks(targets) {
+    const blocksByEntry = new Map();
+    for (const target of targets) {
+        if (target.kind !== "content_block")
+            continue;
+        const blocks = blocksByEntry.get(target.entryId) ?? new Set();
+        blocks.add(target.blockIndex);
+        blocksByEntry.set(target.entryId, blocks);
+    }
+    return blocksByEntry;
+}
+function isToolCallBlockDeleted(entry, callId, deletedEntryIds, deletedContentBlocks) {
+    if (deletedEntryIds.has(entry.entryId))
+        return true;
+    const deletedBlocks = deletedContentBlocks.get(entry.entryId);
+    if (!deletedBlocks)
+        return false;
+    return entry.contentBlocks.some((block) => block.toolCallId === callId && deletedBlocks.has(block.blockIndex));
+}
+function toolCallBlockIndexes(entry, callId) {
+    return entry.contentBlocks
+        .filter((block) => block.toolCallId === callId)
+        .map((block) => block.blockIndex);
+}
+function addTarget(targets, target) {
+    if (targets.some((existing) => targetKey(existing) === targetKey(target)))
+        return false;
+    targets.push(target);
+    return true;
+}
+function deleteEntryTarget(targets, entryId) {
+    let changed = false;
+    for (let index = targets.length - 1; index >= 0; index--) {
+        const target = targets[index];
+        if (target.kind === "content_block" && target.entryId === entryId) {
+            targets.splice(index, 1);
+            changed = true;
+        }
+    }
+    return addTarget(targets, { kind: "entry", entryId }) || changed;
+}
+function removeEntryDeletion(targets, entryId) {
+    const originalLength = targets.length;
+    for (let index = targets.length - 1; index >= 0; index--) {
+        const target = targets[index];
+        if (target.kind === "entry" && target.entryId === entryId)
+            targets.splice(index, 1);
+    }
+    return targets.length !== originalLength;
+}
+function mergeContextDeletionTargets(baseTargets, additionalTargets) {
+    const targets = [...baseTargets];
+    for (const target of additionalTargets) {
+        if (target.kind === "entry") {
+            deleteEntryTarget(targets, target.entryId);
+            continue;
+        }
+        if (!getDeletedEntryIds(targets).has(target.entryId)) {
+            addTarget(targets, target);
+        }
+    }
+    return targets;
+}
+function canonicalizeEntryTargets(targets, entry) {
+    if (entry.protected || getDeletedEntryIds(targets).has(entry.entryId))
+        return false;
+    const deletedBlocks = getDeletedContentBlocks(targets).get(entry.entryId);
+    if (!deletedBlocks || !entry.contentBlocks.every((block) => deletedBlocks.has(block.blockIndex)))
+        return false;
+    // Only repair/promote when dependency reconciliation reaches this entry. Non-tool entries that
+    // request every block individually stay invalid so the assistant must choose explicit entry deletion.
+    return deleteEntryTarget(targets, entry.entryId);
+}
+function removeToolCallDeletion(targets, entry, callId) {
+    let changed = removeEntryDeletion(targets, entry.entryId);
+    const blockIndexes = new Set(toolCallBlockIndexes(entry, callId));
+    for (let index = targets.length - 1; index >= 0; index--) {
+        const target = targets[index];
+        if (target.kind === "content_block" && target.entryId === entry.entryId && blockIndexes.has(target.blockIndex)) {
+            targets.splice(index, 1);
+            changed = true;
+        }
+    }
+    return changed;
+}
+function addToolCallDeletion(targets, entry, callId) {
+    if (entry.protected)
+        return false;
+    let changed = false;
+    for (const blockIndex of toolCallBlockIndexes(entry, callId)) {
+        if (!getDeletedEntryIds(targets).has(entry.entryId)) {
+            changed = addTarget(targets, { kind: "content_block", entryId: entry.entryId, blockIndex }) || changed;
+        }
+    }
+    return canonicalizeEntryTargets(targets, entry) || changed;
+}
+let warnedReconciliationNonConvergence = false;
+function reconcileToolDependencies(transcript, initialTargets) {
+    const targets = [...initialTargets];
+    const callEntries = new Map();
+    const entriesWithToolCalls = new Set();
+    const resultEntries = new Map();
+    for (const entry of transcript.entries) {
+        for (const callId of entry.toolCallIds) {
+            callEntries.set(callId, entry);
+            entriesWithToolCalls.add(entry);
+        }
+        if (entry.toolResultFor) {
+            const results = resultEntries.get(entry.toolResultFor) ?? [];
+            results.push(entry);
+            resultEntries.set(entry.toolResultFor, results);
+        }
+    }
+    // Bounded fixpoint repair: each pass can add/remove paired call/result targets. In practice this
+    // converges within one or two passes; the cap protects against accidental oscillation.
+    let changed = true;
+    let remainingPasses = Math.max(1, transcript.entries.length * 2);
+    while (changed && remainingPasses > 0) {
+        changed = false;
+        remainingPasses -= 1;
+        let deletedEntryIds = getDeletedEntryIds(targets);
+        let deletedContentBlocks = getDeletedContentBlocks(targets);
+        const recordChange = (nextChanged) => {
+            if (!nextChanged)
+                return;
+            changed = true;
+            deletedEntryIds = getDeletedEntryIds(targets);
+            deletedContentBlocks = getDeletedContentBlocks(targets);
+        };
+        for (const [callId, callEntry] of callEntries) {
+            const callDeleted = isToolCallBlockDeleted(callEntry, callId, deletedEntryIds, deletedContentBlocks);
+            const results = resultEntries.get(callId) ?? [];
+            if (callDeleted) {
+                const retainedProtectedResult = results.find((entry) => entry.protected && !deletedEntryIds.has(entry.entryId));
+                if (retainedProtectedResult) {
+                    recordChange(removeToolCallDeletion(targets, callEntry, callId));
+                }
+                else {
+                    for (const result of results) {
+                        recordChange(deleteEntryTarget(targets, result.entryId));
+                    }
+                }
+            }
+            if (isToolCallBlockDeleted(callEntry, callId, deletedEntryIds, deletedContentBlocks))
+                continue;
+            for (const result of results) {
+                if (!deletedEntryIds.has(result.entryId))
+                    continue;
+                recordChange(deleteEntryTarget(targets, result.entryId));
+                if (callEntry.protected) {
+                    recordChange(removeEntryDeletion(targets, result.entryId));
+                    continue;
+                }
+                recordChange(addToolCallDeletion(targets, callEntry, callId));
+            }
+        }
+        for (const entry of entriesWithToolCalls) {
+            recordChange(canonicalizeEntryTargets(targets, entry));
+        }
+    }
+    if (changed && !warnedReconciliationNonConvergence) {
+        warnedReconciliationNonConvergence = true;
+        console.warn(`Context compaction tool dependency reconciliation did not converge within the bounded pass limit; validation will continue with the last reconciled target set. entries=${transcript.entries.length} callEntries=${callEntries.size} targets=${targets.length}`);
+    }
+    return targets;
+}
+function validateToolDependencies(transcript, targets) {
+    const deletedEntryIds = getDeletedEntryIds(targets);
+    const deletedContentBlocks = getDeletedContentBlocks(targets);
+    const callEntries = new Map();
+    const resultEntries = new Map();
+    for (const entry of transcript.entries) {
+        for (const callId of entry.toolCallIds) {
+            callEntries.set(callId, entry);
+        }
+        if (entry.toolResultFor) {
+            const results = resultEntries.get(entry.toolResultFor) ?? [];
+            results.push(entry);
+            resultEntries.set(entry.toolResultFor, results);
+        }
+    }
+    for (const [callId, callEntry] of callEntries) {
+        const callDeleted = isToolCallBlockDeleted(callEntry, callId, deletedEntryIds, deletedContentBlocks);
+        const results = resultEntries.get(callId) ?? [];
+        if (callDeleted) {
+            const danglingResult = results.find((entry) => !deletedEntryIds.has(entry.entryId));
+            if (danglingResult) {
+                throw new Error(`Deleting tool call ${callId} would leave tool result entry ${danglingResult.entryId} orphaned`);
+            }
+            continue;
+        }
+        const deletedResult = results.find((entry) => deletedEntryIds.has(entry.entryId));
+        if (deletedResult) {
+            throw new Error(`Deleting tool result entry ${deletedResult.entryId} would leave tool call ${callId} dangling`);
+        }
+    }
+}
+function computeContextCompactionStats(transcript, targets) {
+    const entryById = new Map(transcript.entries.map((entry) => [entry.entryId, entry]));
+    const deletedEntryIds = getDeletedEntryIds(targets);
+    let deletedTokens = 0;
+    let objectsDeleted = 0;
+    for (const entryId of deletedEntryIds) {
+        const entry = entryById.get(entryId);
+        if (!entry)
+            continue;
+        deletedTokens += entry.tokenEstimate;
+        objectsDeleted += 1 + entry.contentBlocks.length;
+    }
+    for (const target of targets) {
+        if (target.kind !== "content_block" || deletedEntryIds.has(target.entryId))
+            continue;
+        const entry = entryById.get(target.entryId);
+        if (!entry)
+            continue;
+        const block = entry.contentBlocks.find((item) => item.blockIndex === target.blockIndex);
+        if (!block)
+            continue;
+        deletedTokens += block.tokenEstimate;
+        objectsDeleted += 1;
+    }
+    const objectsBefore = transcript.entries.length + transcript.entries.reduce((total, entry) => total + entry.contentBlocks.length, 0);
+    const tokensBefore = transcript.tokensBefore;
+    const tokensAfter = Math.max(0, tokensBefore - deletedTokens);
+    const percentReduction = tokensBefore > 0 ? Math.round(((tokensBefore - tokensAfter) / tokensBefore) * 1000) / 10 : 0;
+    return {
+        objectsBefore,
+        objectsAfter: Math.max(0, objectsBefore - objectsDeleted),
+        objectsDeleted,
+        tokensBefore,
+        tokensAfter,
+        percentReduction,
+    };
+}
+function isCriticalOverflowProtectedEntryDeletable(entry, transcript) {
+    if (!entry.protected)
+        return true;
+    const entryIndex = transcript.entries.findIndex((candidate) => candidate.entryId === entry.entryId);
+    if (entryIndex < 0)
+        return false;
+    const recentBoundary = Math.max(0, transcript.entries.length - CONTEXT_CRITICAL_OVERFLOW_RECENT_ENTRY_COUNT);
+    if (entryIndex >= recentBoundary)
+        return false;
+    if (hasAssistantError(entry.message) || hasToolResultError(entry.message) || hasFailedBashExecution(entry.message)) {
+        return false;
+    }
+    return (entry.role === "user" ||
+        entry.role === "custom" ||
+        entry.role === "branchSummary" ||
+        entry.role === "compactionSummary" ||
+        entry.entryType === "branch_summary");
+}
+function canDeleteProtectedTargetInMode(transcript, target, mode) {
+    if (mode !== "critical_overflow")
+        return false;
+    const entry = transcript.entries.find((candidate) => candidate.entryId === target.entryId);
+    if (!entry || !isCriticalOverflowProtectedEntryDeletable(entry, transcript))
+        return false;
+    if (target.kind === "entry")
+        return true;
+    const block = entry.contentBlocks.find((candidate) => candidate.blockIndex === target.blockIndex);
+    return block !== undefined;
+}
+export function validateContextDeletionRequest(request, transcript, options = {}) {
+    const mode = options.mode ?? "standard";
+    if (!request || typeof request !== "object" || !Array.isArray(request.deletions)) {
+        throw new Error("Context deletion request must be an object with a deletions array");
+    }
+    const entryById = new Map(transcript.entries.map((entry) => [entry.entryId, entry]));
+    const seen = new Set();
+    const deletedTargets = [];
+    for (const deletion of request.deletions) {
+        if (!deletion || typeof deletion !== "object") {
+            throw new Error("Deletion target must be an object");
+        }
+        if (deletion.kind !== "entry" && deletion.kind !== "content_block") {
+            throw new Error(`Unsupported deletion target kind: ${String(deletion.kind)}`);
+        }
+        if (typeof deletion.entryId !== "string" || deletion.entryId.length === 0) {
+            throw new Error("Deletion target entryId must be a non-empty string");
+        }
+        const entry = entryById.get(deletion.entryId);
+        if (!entry) {
+            throw new Error(`Unknown deletion target entryId: ${deletion.entryId}`);
+        }
+        if (entry.protected && !canDeleteProtectedTargetInMode(transcript, normalizeRawTarget(deletion), mode)) {
+            throw new Error(`Deletion target ${deletion.entryId} is protected`);
+        }
+        if (deletion.kind === "content_block") {
+            if (!Number.isInteger(deletion.blockIndex) || deletion.blockIndex === undefined || deletion.blockIndex < 0) {
+                throw new Error(`Invalid content block index for entry ${deletion.entryId}`);
+            }
+            const block = entry.contentBlocks.find((item) => item.blockIndex === deletion.blockIndex);
+            if (!block) {
+                throw new Error(`Unknown content block ${deletion.blockIndex} for entry ${deletion.entryId}`);
+            }
+            if (block.protected && !canDeleteProtectedTargetInMode(transcript, normalizeRawTarget(deletion), mode)) {
+                throw new Error(`Content block ${deletion.entryId}:${deletion.blockIndex} is protected`);
+            }
+            if (entry.contentBlocks.length <= 1) {
+                throw new Error(`Deleting the only content block of ${deletion.entryId} must be an entry deletion`);
+            }
+        }
+        const key = rawTargetKey(deletion);
+        if (seen.has(key)) {
+            throw new Error(`Duplicate deletion target: ${key}`);
+        }
+        seen.add(key);
+        const normalized = normalizeRawTarget(deletion);
+        deletedTargets.push(normalized);
+    }
+    const reconciledTargets = reconcileToolDependencies(transcript, deletedTargets);
+    const reconciledDeletedEntryIds = getDeletedEntryIds(reconciledTargets);
+    for (const target of reconciledTargets) {
+        if (target.kind === "content_block" && reconciledDeletedEntryIds.has(target.entryId)) {
+            throw new Error(`Deletion target ${targetKey(target)} overlaps with entry deletion`);
+        }
+    }
+    const deletedContentBlocks = getDeletedContentBlocks(reconciledTargets);
+    for (const [entryId, blockIndexes] of deletedContentBlocks) {
+        const entry = entryById.get(entryId);
+        if (entry?.contentBlocks.every((block) => blockIndexes.has(block.blockIndex))) {
+            throw new Error(`Content-block deletions for ${entryId} would remove every content block`);
+        }
+    }
+    validateToolDependencies(transcript, reconciledTargets);
+    const remainingEntries = transcript.entries.filter((entry) => !reconciledDeletedEntryIds.has(entry.entryId));
+    if (remainingEntries.length === 0) {
+        throw new Error("Deletion request would remove all context entries");
+    }
+    const hasTaskBearingContext = remainingEntries.some((entry) => entry.role === "user" || (entry.role === "compactionSummary" && entry.protected));
+    if (!hasTaskBearingContext) {
+        throw new Error("Deletion request would leave no user task in context");
+    }
+    return {
+        deletedTargets: reconciledTargets,
+        protectedEntryIds: [...transcript.protectedEntryIds],
+        stats: computeContextCompactionStats(transcript, reconciledTargets),
+    };
+}
+function stripJsonFence(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("```") || !trimmed.endsWith("```"))
+        return trimmed;
+    const firstLineEnd = trimmed.indexOf("\n");
+    if (firstLineEnd < 0)
+        return trimmed;
+    const fenceInfo = trimmed.slice(3, firstLineEnd).trim().toLowerCase();
+    if (fenceInfo !== "" && fenceInfo !== "json")
+        return trimmed;
+    return trimmed.slice(firstLineEnd + 1, -3).trim();
+}
+function contextDeletionRequestFromObject(value, source) {
+    if (!value || typeof value !== "object" || !Array.isArray(value.deletions)) {
+        throw new Error(`${source} must contain a deletions array`);
+    }
+    return value;
+}
+function escapeRegExpLiteral(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function formatErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function createContextDeletionToolResult(text, details) {
+    return { content: [{ type: "text", text }], details, terminate: false };
+}
+function assertSafeRegexPattern(pattern) {
+    if (pattern.length > CONTEXT_GREP_DELETE_MAX_REGEX_PATTERN_CHARS) {
+        throw new Error(`Regex pattern is too long (${pattern.length} characters); maximum is ${CONTEXT_GREP_DELETE_MAX_REGEX_PATTERN_CHARS}`);
+    }
+    // Heuristic ReDoS guard for common catastrophic-backtracking shapes. JavaScript's RegExp engine
+    // does not expose a timeout, so reject nested quantified groups and backreferences instead of
+    // relying only on transcript scan-size caps.
+    const hasNestedQuantifiedGroup = /\((?:[^()\\]|\\.)*[+*](?:[^()\\]|\\.)*\)\s*(?:[+*]|\{\d)/u.test(pattern);
+    const hasQuantifiedAlternation = /\((?:[^()\\]|\\.)*\|(?:[^()\\]|\\.)*\)\s*(?:[+*]|\{\d)/u.test(pattern);
+    const hasBackreference = /\\[1-9]/u.test(pattern);
+    if (hasNestedQuantifiedGroup || hasQuantifiedAlternation || hasBackreference) {
+        throw new Error("Regex pattern is not allowed because it may cause excessive backtracking; use a literal pattern or exact deletion targets instead.");
+    }
+}
+function createGrepMatcher(pattern, regex, caseSensitive) {
+    if (regex) {
+        assertSafeRegexPattern(pattern);
+    }
+    try {
+        return new RegExp(regex ? pattern : escapeRegExpLiteral(pattern), caseSensitive ? "u" : "iu");
+    }
+    catch (error) {
+        throw new Error(`Invalid grep ${regex ? "regex" : "pattern"}: ${formatErrorMessage(error)}`);
+    }
+}
+function assertSafeRegexScan(scanChars) {
+    if (scanChars <= CONTEXT_GREP_DELETE_MAX_REGEX_SCAN_CHARS)
+        return;
+    throw new Error(`Regex grep would scan ${scanChars} characters; maximum is ${CONTEXT_GREP_DELETE_MAX_REGEX_SCAN_CHARS}. Use a literal pattern or exact deletion targets instead.`);
+}
+function clampInteger(value, defaultValue, minimum, maximum) {
+    if (value === undefined)
+        return defaultValue;
+    return Math.max(minimum, Math.min(maximum, value));
+}
+function textSlice(text, offset, maxChars) {
+    return text.slice(offset, Math.min(text.length, offset + maxChars));
+}
+function findMatchIndex(matcher, text) {
+    const match = matcher.exec(text);
+    matcher.lastIndex = 0;
+    return match?.index ?? -1;
+}
+function snippetForMatch(text, matchIndex, contextChars) {
+    const start = Math.max(0, matchIndex - contextChars);
+    const end = Math.min(text.length, matchIndex + contextChars);
+    const prefix = start > 0 ? "…" : "";
+    const suffix = end < text.length ? "…" : "";
+    return `${prefix}${text.slice(start, end)}${suffix}`;
+}
+function currentTargetDeleted(targets, target) {
+    const deletedEntryIds = getDeletedEntryIds(targets);
+    if (deletedEntryIds.has(target.entryId))
+        return true;
+    if (target.kind === "entry")
+        return false;
+    return getDeletedContentBlocks(targets).get(target.entryId)?.has(target.blockIndex) === true;
+}
+function addGrepCandidate(candidates, matches, seenTargets, candidate, match) {
+    const key = targetKey(candidate);
+    if (seenTargets.has(key))
+        return;
+    seenTargets.add(key);
+    candidates.push(candidate);
+    matches.push(match);
+}
+const moduleRequire = createRequire(import.meta.url);
+function createTransientSqliteDatabase() {
+    // better-sqlite3 is the portable/package dependency for Node-based Atomic installs.
+    // Bun cannot dlopen better-sqlite3 yet, so Bun runtime/tests use the API-compatible builtin.
+    if (process.versions.bun) {
+        const sqlite = moduleRequire("bun:sqlite");
+        return new sqlite.Database(":memory:");
+    }
+    const BetterSqliteDatabase = moduleRequire("better-sqlite3");
+    return new BetterSqliteDatabase(":memory:");
+}
+class SqliteAdapter {
+    constructor(db) {
+        this.db = db;
+    }
+    static createTransient() {
+        return new SqliteAdapter(createTransientSqliteDatabase());
+    }
+    exec(sql) {
+        this.db.exec(sql);
+    }
+    run(sql, ...params) {
+        this.db.prepare(sql).run(...params);
+    }
+    all(sql, ...params) {
+        return this.db.prepare(sql).all(...params);
+    }
+    get(sql, ...params) {
+        return this.db.prepare(sql).get(...params);
+    }
+    transaction(operation) {
+        this.exec("BEGIN IMMEDIATE");
+        try {
+            const result = operation();
+            this.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            try {
+                this.exec("ROLLBACK");
+            }
+            catch { }
+            throw error;
+        }
+    }
+    close() {
+        this.db.close();
+    }
+}
+class ContextDeletionSqliteStore {
+    constructor(sqlite) {
+        this.sqlite = sqlite;
+    }
+    initialize(transcript) {
+        this.sqlite.transaction(() => {
+            this.sqlite.exec(`
+				PRAGMA foreign_keys = ON;
+				CREATE TABLE transcript_entries (
+					position INTEGER PRIMARY KEY,
+					entry_id TEXT NOT NULL UNIQUE,
+					role TEXT NOT NULL,
+					is_protected INTEGER NOT NULL,
+					token_estimate INTEGER NOT NULL,
+					text TEXT NOT NULL,
+					tool_result_for TEXT
+				);
+				CREATE TABLE transcript_content_blocks (
+					entry_id TEXT NOT NULL,
+					block_index INTEGER NOT NULL,
+					type TEXT NOT NULL,
+					is_protected INTEGER NOT NULL,
+					token_estimate INTEGER NOT NULL,
+					text TEXT NOT NULL,
+					tool_call_id TEXT,
+					PRIMARY KEY (entry_id, block_index),
+					FOREIGN KEY (entry_id) REFERENCES transcript_entries(entry_id) ON DELETE CASCADE
+				);
+				CREATE TABLE deletion_targets (
+					position INTEGER PRIMARY KEY AUTOINCREMENT,
+					target_key TEXT NOT NULL UNIQUE,
+					kind TEXT NOT NULL CHECK (kind IN ('entry', 'content_block')),
+					entry_id TEXT NOT NULL,
+					block_index INTEGER
+				);
+				CREATE TABLE context_compaction_state (
+					key TEXT PRIMARY KEY,
+					value TEXT NOT NULL
+				);
+				INSERT INTO context_compaction_state (key, value) VALUES ('call_count', '0');
+			`);
+            for (const [position, entry] of transcript.entries.entries()) {
+                this.sqlite.run("INSERT INTO transcript_entries (position, entry_id, role, is_protected, token_estimate, text, tool_result_for) VALUES (?, ?, ?, ?, ?, ?, ?)", position, entry.entryId, entry.role, entry.protected ? 1 : 0, entry.tokenEstimate, entry.text, entry.toolResultFor ?? null);
+                for (const block of entry.contentBlocks) {
+                    this.sqlite.run("INSERT INTO transcript_content_blocks (entry_id, block_index, type, is_protected, token_estimate, text, tool_call_id) VALUES (?, ?, ?, ?, ?, ?, ?)", block.entryId, block.blockIndex, block.type, block.protected ? 1 : 0, block.tokenEstimate, block.text, block.toolCallId ?? null);
+                }
+            }
+        });
+    }
+    transaction(operation) {
+        return this.sqlite.transaction(operation);
+    }
+    readTargets() {
+        return this.sqlite
+            .all("SELECT kind, entry_id, block_index FROM deletion_targets ORDER BY position")
+            .map((row) => row.kind === "entry"
+            ? { kind: "entry", entryId: row.entry_id }
+            : { kind: "content_block", entryId: row.entry_id, blockIndex: row.block_index });
+    }
+    replaceTargets(targets) {
+        this.sqlite.run("DELETE FROM deletion_targets");
+        for (const target of targets) {
+            this.sqlite.run("INSERT INTO deletion_targets (target_key, kind, entry_id, block_index) VALUES (?, ?, ?, ?)", targetKey(target), target.kind, target.entryId, target.kind === "content_block" ? target.blockIndex : null);
+        }
+    }
+    listEntriesForGrep() {
+        return this.sqlite.all("SELECT entry_id, text, is_protected FROM transcript_entries ORDER BY position");
+    }
+    listContentBlocksForGrep() {
+        return this.sqlite.all(`
+			SELECT
+				blocks.entry_id,
+				blocks.block_index,
+				blocks.text,
+				entries.is_protected AS entry_protected,
+				blocks.is_protected AS block_protected,
+				(
+					SELECT COUNT(*)
+					FROM transcript_content_blocks sibling
+					WHERE sibling.entry_id = blocks.entry_id
+				) AS block_count
+			FROM transcript_content_blocks blocks
+			JOIN transcript_entries entries ON entries.entry_id = blocks.entry_id
+			ORDER BY entries.position, blocks.block_index
+		`);
+    }
+    getEntryForRead(entryId) {
+        return this.sqlite.get("SELECT entry_id, role, is_protected, token_estimate, text FROM transcript_entries WHERE entry_id = ?", entryId);
+    }
+    getContentBlockForRead(entryId, blockIndex) {
+        return this.sqlite.get(`
+				SELECT
+					blocks.entry_id,
+					blocks.block_index,
+					blocks.type,
+					blocks.token_estimate,
+					blocks.text,
+					entries.is_protected AS entry_protected,
+					blocks.is_protected AS block_protected,
+					(
+						SELECT COUNT(*)
+						FROM transcript_content_blocks sibling
+						WHERE sibling.entry_id = blocks.entry_id
+					) AS block_count
+				FROM transcript_content_blocks blocks
+				JOIN transcript_entries entries ON entries.entry_id = blocks.entry_id
+				WHERE blocks.entry_id = ? AND blocks.block_index = ?
+			`, entryId, blockIndex);
+    }
+    getGrepScanTextLength(target) {
+        const table = target === "entry" ? "transcript_entries" : "transcript_content_blocks";
+        const row = this.sqlite.get(`SELECT SUM(LENGTH(text)) AS scan_chars FROM ${table}`);
+        return row?.scan_chars ?? 0;
+    }
+    incrementCallCount() {
+        const next = this.getCallCount() + 1;
+        this.setState("call_count", String(next));
+        return next;
+    }
+    getCallCount() {
+        return Number(this.getState("call_count") ?? "0");
+    }
+    setLastError(message) {
+        this.setState("last_error", message);
+    }
+    clearLastError() {
+        this.sqlite.run("DELETE FROM context_compaction_state WHERE key = ?", "last_error");
+    }
+    getLastError() {
+        return this.getState("last_error");
+    }
+    getState(key) {
+        return this.sqlite.get("SELECT value FROM context_compaction_state WHERE key = ?", key)?.value;
+    }
+    setState(key, value) {
+        this.sqlite.run("INSERT INTO context_compaction_state (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", key, value);
+    }
+    close() {
+        this.sqlite.close();
+    }
+}
+function createContextDeletionSqliteStore(transcript) {
+    const store = new ContextDeletionSqliteStore(SqliteAdapter.createTransient());
+    store.initialize(transcript);
+    return store;
+}
+export function createContextDeletionTool(transcript, options = {}) {
+    const mode = options.mode ?? "standard";
+    const store = createContextDeletionSqliteStore(transcript);
+    let validatedResult;
+    function readTargets() {
+        return store.readTargets();
+    }
+    function applyValidatedTargets(additionalTargets) {
+        const mergedTargets = mergeContextDeletionTargets(readTargets(), additionalTargets);
+        validatedResult = validateContextDeletionRequest(deletionRequestFromTargets(mergedTargets), transcript, { mode });
+        store.replaceTargets(validatedResult.deletedTargets);
+        return validatedResult;
+    }
+    function currentStats() {
+        return validatedResult?.stats ?? computeContextCompactionStats(transcript, readTargets());
+    }
+    function canDeleteProtectedTarget(target) {
+        return canDeleteProtectedTargetInMode(transcript, target, mode);
+    }
+    const tool = {
+        ...CONTEXT_DELETE_TOOL,
+        label: "context deletion request",
+        executionMode: "parallel",
+        async execute(_toolCallId, params) {
+            return store.transaction(() => {
+                const callCount = store.incrementCallCount();
+                try {
+                    const incomingRequest = contextDeletionRequestFromObject(params, `${CONTEXT_DELETE_TOOL_NAME} arguments`);
+                    const incomingValidated = validateContextDeletionRequest(incomingRequest, transcript, { mode });
+                    const applied = applyValidatedTargets(incomingValidated.deletedTargets);
+                    store.clearLastError();
+                    const deletedTargets = readTargets();
+                    const details = {
+                        deletions: deletionRequestFromTargets(deletedTargets).deletions,
+                        deletedTargets,
+                        stats: applied.stats,
+                        callCount,
+                    };
+                    const text = `Recorded ${incomingValidated.deletedTargets.length} deletion target(s); ${deletedTargets.length} total validated deletion target(s) are selected. Continue calling ${CONTEXT_DELETE_TOOL_NAME} or ${CONTEXT_GREP_DELETE_TOOL_NAME} for additional deletions, or respond done when finished.`;
+                    return createContextDeletionToolResult(text, details);
+                }
+                catch (error) {
+                    const message = formatErrorMessage(error);
+                    store.setLastError(message);
+                    const deletedTargets = readTargets();
+                    const details = {
+                        deletions: deletionRequestFromTargets(deletedTargets).deletions,
+                        deletedTargets,
+                        stats: currentStats(),
+                        callCount,
+                        error: message,
+                    };
+                    return createContextDeletionToolResult(`Error recording context deletion targets: ${message}. No new deletion targets were applied; continue with a corrected tool call.`, details);
+                }
+            });
+        },
+    };
+    const grepTool = {
+        ...CONTEXT_GREP_DELETE_TOOL,
+        label: "context grep delete",
+        executionMode: "parallel",
+        async execute(_toolCallId, params) {
+            return store.transaction(() => {
+                const callCount = store.incrementCallCount();
+                const pattern = params.pattern;
+                const regex = params.regex === true;
+                const caseSensitive = params.caseSensitive === true;
+                const target = params.target ?? "entry";
+                const maxMatches = params.maxMatches ?? CONTEXT_GREP_DELETE_DEFAULT_MAX_MATCHES;
+                const candidates = [];
+                const matches = [];
+                const skipped = [];
+                const seenTargets = new Set();
+                try {
+                    if (regex) {
+                        assertSafeRegexScan(store.getGrepScanTextLength(target));
+                    }
+                    const matcher = createGrepMatcher(pattern, regex, caseSensitive);
+                    const currentTargets = readTargets();
+                    if (target === "entry") {
+                        for (const entry of store.listEntriesForGrep()) {
+                            if (!matcher.test(entry.text))
+                                continue;
+                            const candidate = { kind: "entry", entryId: entry.entry_id };
+                            if (entry.is_protected === 1 && !canDeleteProtectedTarget(candidate)) {
+                                skipped.push({ entryId: entry.entry_id, target, reason: "protected_entry", text: entry.text });
+                                continue;
+                            }
+                            if (currentTargetDeleted(currentTargets, candidate)) {
+                                skipped.push({ entryId: entry.entry_id, target, reason: "already_deleted", text: entry.text });
+                                continue;
+                            }
+                            addGrepCandidate(candidates, matches, seenTargets, candidate, {
+                                entryId: entry.entry_id,
+                                target,
+                                text: entry.text,
+                            });
+                        }
+                    }
+                    else {
+                        for (const block of store.listContentBlocksForGrep()) {
+                            if (!matcher.test(block.text))
+                                continue;
+                            const candidate = block.block_count <= 1
+                                ? { kind: "entry", entryId: block.entry_id }
+                                : { kind: "content_block", entryId: block.entry_id, blockIndex: block.block_index };
+                            if (block.entry_protected === 1 && !canDeleteProtectedTarget(candidate)) {
+                                skipped.push({
+                                    entryId: block.entry_id,
+                                    target,
+                                    blockIndex: block.block_index,
+                                    reason: "protected_entry",
+                                    text: block.text,
+                                });
+                                continue;
+                            }
+                            if (block.block_protected === 1 && !canDeleteProtectedTarget(candidate)) {
+                                skipped.push({
+                                    entryId: block.entry_id,
+                                    target,
+                                    blockIndex: block.block_index,
+                                    reason: "protected_block",
+                                    text: block.text,
+                                });
+                                continue;
+                            }
+                            if (currentTargetDeleted(currentTargets, candidate)) {
+                                skipped.push({
+                                    entryId: block.entry_id,
+                                    target: candidate.kind,
+                                    ...(candidate.kind === "content_block" ? { blockIndex: candidate.blockIndex } : {}),
+                                    reason: "already_deleted",
+                                    text: block.text,
+                                });
+                                continue;
+                            }
+                            addGrepCandidate(candidates, matches, seenTargets, candidate, {
+                                entryId: block.entry_id,
+                                target: candidate.kind,
+                                ...(candidate.kind === "content_block" ? { blockIndex: candidate.blockIndex } : {}),
+                                text: block.text,
+                            });
+                        }
+                    }
+                    let applied;
+                    if (params.expectedMatchCount !== undefined && candidates.length !== params.expectedMatchCount) {
+                        skipped.push({ reason: "expected_match_count_mismatch" });
+                    }
+                    else if (candidates.length > maxMatches) {
+                        skipped.push({ reason: "max_matches_exceeded" });
+                    }
+                    else if (candidates.length > 0) {
+                        applied = applyValidatedTargets(candidates);
+                    }
+                    store.clearLastError();
+                    const deletedTargets = readTargets();
+                    const details = {
+                        pattern,
+                        regex,
+                        caseSensitive,
+                        target,
+                        matches,
+                        skipped,
+                        deletedTargets,
+                        stats: applied?.stats ?? currentStats(),
+                        callCount,
+                    };
+                    const text = `Matched ${matches.length} deletion target(s), skipped ${skipped.length}, and ${applied ? "applied" : "did not apply"} grep deletion for pattern ${JSON.stringify(pattern)}. Total validated deletion target(s): ${deletedTargets.length}.`;
+                    return createContextDeletionToolResult(text, details);
+                }
+                catch (error) {
+                    const message = formatErrorMessage(error);
+                    store.setLastError(message);
+                    const deletedTargets = readTargets();
+                    const details = {
+                        pattern,
+                        regex,
+                        caseSensitive,
+                        target,
+                        matches,
+                        skipped,
+                        deletedTargets,
+                        stats: currentStats(),
+                        callCount,
+                        error: message,
+                    };
+                    return createContextDeletionToolResult(`Error applying grep deletion for pattern ${JSON.stringify(pattern)}: ${message}. No new deletion targets were applied; continue with a corrected tool call.`, details);
+                }
+            });
+        },
+    };
+    const searchTool = {
+        ...CONTEXT_SEARCH_TRANSCRIPT_TOOL,
+        label: "context transcript search",
+        executionMode: "parallel",
+        async execute(_toolCallId, params) {
+            return store.transaction(() => {
+                const callCount = store.incrementCallCount();
+                const pattern = params.pattern;
+                const regex = params.regex === true;
+                const caseSensitive = params.caseSensitive === true;
+                const target = params.target ?? "entry";
+                const maxMatches = clampInteger(params.maxMatches, CONTEXT_SEARCH_DEFAULT_MAX_MATCHES, 1, CONTEXT_SEARCH_MAX_MATCHES);
+                const contextChars = clampInteger(params.contextChars, CONTEXT_SEARCH_DEFAULT_CONTEXT_CHARS, 0, CONTEXT_SEARCH_MAX_CONTEXT_CHARS);
+                const matches = [];
+                let truncated = false;
+                try {
+                    if (regex) {
+                        assertSafeRegexScan(store.getGrepScanTextLength(target));
+                    }
+                    const matcher = createGrepMatcher(pattern, regex, caseSensitive);
+                    if (target === "entry") {
+                        for (const entry of store.listEntriesForGrep()) {
+                            const matchIndex = findMatchIndex(matcher, entry.text);
+                            if (matchIndex < 0)
+                                continue;
+                            if (matches.length >= maxMatches) {
+                                truncated = true;
+                                break;
+                            }
+                            matches.push({
+                                entryId: entry.entry_id,
+                                target,
+                                matchIndex,
+                                snippet: snippetForMatch(entry.text, matchIndex, contextChars),
+                                protected: entry.is_protected === 1,
+                            });
+                        }
+                    }
+                    else {
+                        for (const block of store.listContentBlocksForGrep()) {
+                            const matchIndex = findMatchIndex(matcher, block.text);
+                            if (matchIndex < 0)
+                                continue;
+                            if (matches.length >= maxMatches) {
+                                truncated = true;
+                                break;
+                            }
+                            matches.push({
+                                entryId: block.entry_id,
+                                target,
+                                blockIndex: block.block_index,
+                                matchIndex,
+                                snippet: snippetForMatch(block.text, matchIndex, contextChars),
+                                protected: block.entry_protected === 1 || block.block_protected === 1,
+                            });
+                        }
+                    }
+                    store.clearLastError();
+                    const details = {
+                        pattern,
+                        regex,
+                        caseSensitive,
+                        target,
+                        matches,
+                        truncated,
+                        callCount,
+                    };
+                    const text = `Found ${matches.length}${truncated ? "+" : ""} ${target} match(es) for ${JSON.stringify(pattern)}. Use ${CONTEXT_READ_ENTRY_TOOL_NAME} with small maxChars to inspect exact content before deleting.`;
+                    return createContextDeletionToolResult(text, details);
+                }
+                catch (error) {
+                    const message = formatErrorMessage(error);
+                    store.setLastError(message);
+                    const details = {
+                        pattern,
+                        regex,
+                        caseSensitive,
+                        target,
+                        matches,
+                        truncated,
+                        callCount,
+                        error: message,
+                    };
+                    return createContextDeletionToolResult(`Error searching transcript for ${JSON.stringify(pattern)}: ${message}. Try a literal pattern or narrower query.`, details);
+                }
+            });
+        },
+    };
+    const readEntryTool = {
+        ...CONTEXT_READ_ENTRY_TOOL,
+        label: "context read entry",
+        executionMode: "parallel",
+        async execute(_toolCallId, params) {
+            return store.transaction(() => {
+                const callCount = store.incrementCallCount();
+                const offset = clampInteger(params.offset, 0, 0, Number.MAX_SAFE_INTEGER);
+                const maxChars = clampInteger(params.maxChars, CONTEXT_READ_ENTRY_DEFAULT_MAX_CHARS, 1, CONTEXT_READ_ENTRY_MAX_CHARS);
+                try {
+                    const row = params.blockIndex === undefined
+                        ? store.getEntryForRead(params.entryId)
+                        : store.getContentBlockForRead(params.entryId, params.blockIndex);
+                    if (!row) {
+                        throw new Error(params.blockIndex === undefined
+                            ? `Unknown transcript entry: ${params.entryId}`
+                            : `Unknown transcript content block: ${params.entryId}:${params.blockIndex}`);
+                    }
+                    const text = row.text;
+                    const slice = textSlice(text, offset, maxChars);
+                    store.clearLastError();
+                    const details = {
+                        entryId: params.entryId,
+                        ...(params.blockIndex === undefined ? {} : { blockIndex: params.blockIndex }),
+                        offset,
+                        maxChars,
+                        totalChars: text.length,
+                        text: slice,
+                        truncatedBefore: offset > 0,
+                        truncatedAfter: offset + maxChars < text.length,
+                        callCount,
+                    };
+                    const textResult = `Read ${slice.length} of ${text.length} characters from ${params.blockIndex === undefined ? params.entryId : `${params.entryId}:${params.blockIndex}`}. Keep reads small; increase offset for the next slice if needed.`;
+                    return createContextDeletionToolResult(textResult, details);
+                }
+                catch (error) {
+                    const message = formatErrorMessage(error);
+                    store.setLastError(message);
+                    const details = {
+                        entryId: params.entryId,
+                        ...(params.blockIndex === undefined ? {} : { blockIndex: params.blockIndex }),
+                        offset,
+                        maxChars,
+                        totalChars: 0,
+                        text: "",
+                        truncatedBefore: false,
+                        truncatedAfter: false,
+                        callCount,
+                        error: message,
+                    };
+                    return createContextDeletionToolResult(`Error reading transcript entry: ${message}`, details);
+                }
+            });
+        },
+    };
+    return {
+        tool,
+        grepTool,
+        searchTool,
+        readEntryTool,
+        tools: [tool, grepTool, searchTool, readEntryTool],
+        getDeletionRequest: () => deletionRequestFromTargets(readTargets()),
+        getValidatedResult: () => validatedResult,
+        getLastError: () => store.getLastError(),
+        getCallCount: () => store.getCallCount(),
+    };
+}
+export function parseContextDeletionRequest(text) {
+    const stripped = stripJsonFence(text);
+    let parsed;
+    try {
+        parsed = JSON.parse(stripped);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse context deletion request JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return contextDeletionRequestFromObject(parsed, "Context deletion request JSON");
+}
+function isContextDeleteToolCall(content) {
+    return content.type === "toolCall" && content.name === CONTEXT_DELETE_TOOL_NAME;
+}
+function textContentFromResponse(response) {
+    return response.content
+        .filter((content) => content.type === "text")
+        .map((content) => content.text)
+        .join("\n");
+}
+export function parseContextDeletionResponse(response) {
+    const toolCalls = response.content.filter(isContextDeleteToolCall);
+    if (toolCalls.length > 1) {
+        throw new Error(`Context compaction assistant called ${CONTEXT_DELETE_TOOL_NAME} more than once`);
+    }
+    const toolCall = toolCalls[0];
+    if (toolCall) {
+        return contextDeletionRequestFromObject(toolCall.arguments, `${CONTEXT_DELETE_TOOL_NAME} arguments`);
+    }
+    const textContent = textContentFromResponse(response);
+    if (textContent.trim().length === 0) {
+        throw new Error(`Context compaction assistant did not call ${CONTEXT_DELETE_TOOL_NAME}`);
+    }
+    return parseContextDeletionRequest(textContent);
+}
+function truncateForPrompt(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, maxChars)}\n[... ${text.length - maxChars} more characters omitted from context compaction prompt]`;
+}
+function transcriptEntryFilePayload(entry) {
+    return {
+        entryId: entry.entryId,
+        entryType: entry.entryType,
+        role: entry.role,
+        protected: entry.protected,
+        tokenEstimate: entry.tokenEstimate,
+        toolCallIds: entry.toolCallIds,
+        toolResultFor: entry.toolResultFor,
+        text: entry.text,
+        contentBlocks: entry.contentBlocks.map((block) => ({
+            blockIndex: block.blockIndex,
+            type: block.type,
+            protected: block.protected,
+            toolCallId: block.toolCallId,
+            tokenEstimate: block.tokenEstimate,
+            text: block.text,
+        })),
+    };
+}
+function writeContextCompactionTranscriptFile(transcript) {
+    const directory = mkdtempSync(join(tmpdir(), "atomic-context-transcript-"));
+    const path = join(directory, "transcript.jsonl");
+    const lines = transcript.entries
+        .filter((entry) => !isExcludedFromLlmContext(entry.message))
+        .map((entry) => JSON.stringify(transcriptEntryFilePayload(entry)));
+    writeFileSync(path, `${lines.join("\n")}\n`, "utf8");
+    return {
+        path,
+        cleanup: () => rmSync(directory, { recursive: true, force: true }),
+    };
+}
+function contextCompactionTranscriptManifest(transcript, transcriptFilePath) {
+    const eligibleEntries = transcript.entries.filter((entry) => !isExcludedFromLlmContext(entry.message));
+    const selectedEntryIds = new Set();
+    const selectedEntries = [];
+    const addEntry = (entry) => {
+        if (selectedEntryIds.has(entry.entryId) || selectedEntries.length >= CONTEXT_MANIFEST_MAX_ENTRIES)
+            return;
+        selectedEntryIds.add(entry.entryId);
+        selectedEntries.push(entry);
+    };
+    for (const entry of eligibleEntries.filter((entry) => entry.protected)) {
+        addEntry(entry);
+    }
+    for (const entry of [...eligibleEntries]
+        .filter((entry) => !entry.protected)
+        .sort((left, right) => right.tokenEstimate - left.tokenEstimate)) {
+        addEntry(entry);
+    }
+    selectedEntries.sort((left, right) => eligibleEntries.indexOf(left) - eligibleEntries.indexOf(right));
+    return {
+        transcriptFilePath,
+        transcriptFileFormat: "jsonl: one compactable transcript entry per line with full text and contentBlocks text",
+        totalEntries: eligibleEntries.length,
+        manifestEntries: selectedEntries.length,
+        omittedEntries: Math.max(0, eligibleEntries.length - selectedEntries.length),
+        tokensBefore: transcript.tokensBefore,
+        protectedEntryIds: transcript.protectedEntryIds,
+        entries: selectedEntries.map((entry) => ({
+            entryId: entry.entryId,
+            role: entry.role,
+            protected: entry.protected,
+            tokenEstimate: entry.tokenEstimate,
+            toolCallIds: entry.toolCallIds,
+            toolResultFor: entry.toolResultFor,
+            contentBlockCount: entry.contentBlocks.length,
+            contentBlocks: entry.contentBlocks.map((block) => ({
+                blockIndex: block.blockIndex,
+                type: block.type,
+                protected: block.protected,
+                toolCallId: block.toolCallId,
+                tokenEstimate: block.tokenEstimate,
+            })),
+            preview: truncateForPrompt(entry.text, CONTEXT_MANIFEST_PREVIEW_CHARS),
+        })),
+    };
+}
+function contextCompactionModePrompt(mode) {
+    if (mode === "critical_overflow") {
+        return `\n<critical-overflow-mode>\nThe previous model request overflowed its context window. This is a critical LRU-style compaction pass. First delete stale unprotected context. If that is not enough, you may also delete the earliest protected entries or protected content shown in the manifest, especially old user/custom/summary context, while preserving recent entries, unresolved errors, failed commands, and enough task-bearing context for the assistant to continue.\n</critical-overflow-mode>`;
+    }
+    return `\n<standard-mode>\nDo not delete entries or content blocks marked protected. Protected context is only eligible during critical overflow recovery, not during standard compaction.\n</standard-mode>`;
+}
+export function buildContextCompactionPrompt(transcript, transcriptFilePath = "<transcript file will be written during context compaction>", mode = "standard") {
+    return `${CONTEXT_COMPACTION_FIXED_PROMPT}${contextCompactionModePrompt(mode)}\n\n<transcript-file>\n${transcriptFilePath}\n</transcript-file>\n\n<context-manifest>\n${JSON.stringify(contextCompactionTranscriptManifest(transcript, transcriptFilePath), null, 2)}\n</context-manifest>`;
+}
+function createContextCompactionAssistantMessage(model, content, stopReason, errorMessage) {
+    return {
+        role: "assistant",
+        content,
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+        stopReason,
+        ...(errorMessage !== undefined ? { errorMessage } : {}),
+        timestamp: Date.now(),
+    };
+}
+function createContextCompactionStopStream(model, text) {
+    const stream = createAssistantMessageEventStream();
+    queueMicrotask(() => {
+        const message = createContextCompactionAssistantMessage(model, [{ type: "text", text }], "stop");
+        stream.push({ type: "done", reason: "stop", message });
+        stream.end(message);
+    });
+    return stream;
+}
+function isContextCompactionOverflowError(model, errorMessage) {
+    return isContextOverflow(createContextCompactionAssistantMessage(model, [], "error", errorMessage), model.contextWindow);
+}
+export function getLowestContextCompactionThinkingLevel(model) {
+    const supportedLevels = getSupportedThinkingLevels(model);
+    for (const level of CONTEXT_COMPACTION_THINKING_LEVEL_ORDER) {
+        if (supportedLevels.includes(level))
+            return level;
+    }
+    return "off";
+}
+async function runContextDeletionAssistant(transcript, model, apiKey, headers, signal, mode = "standard") {
+    const maxTokens = Math.min(4096, model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY);
+    if (signal?.aborted) {
+        throw new Error("Context compaction failed: Request was aborted");
+    }
+    const transcriptFile = writeContextCompactionTranscriptFile(transcript);
+    const promptMessage = {
+        role: "user",
+        content: [{ type: "text", text: buildContextCompactionPrompt(transcript, transcriptFile.path, mode) }],
+        timestamp: Date.now(),
+    };
+    const deletionTool = createContextDeletionTool(transcript, { mode });
+    const effectiveThinkingLevel = getLowestContextCompactionThinkingLevel(model);
+    let compactionTurnCount = 0;
+    const agent = new Agent({
+        initialState: {
+            systemPrompt: CONTEXT_COMPACTION_SYSTEM_PROMPT,
+            model,
+            thinkingLevel: effectiveThinkingLevel,
+            tools: deletionTool.tools,
+        },
+        toolExecution: "parallel",
+        streamFn: async (requestModel, context, streamOptions) => {
+            compactionTurnCount += 1;
+            if (compactionTurnCount > CONTEXT_COMPACTION_MAX_TURNS) {
+                return createContextCompactionStopStream(requestModel, `Reached the context compaction turn cap (${CONTEXT_COMPACTION_MAX_TURNS}); using the deletions recorded so far.`);
+            }
+            return streamSimple(requestModel, context, {
+                ...streamOptions,
+                maxTokens,
+                apiKey,
+                headers: headers ?? streamOptions?.headers,
+            });
+        },
+    });
+    const abortOnSignal = () => agent.abort();
+    signal?.addEventListener("abort", abortOnSignal, { once: true });
+    try {
+        await agent.prompt(promptMessage);
+    }
+    finally {
+        signal?.removeEventListener("abort", abortOnSignal);
+        transcriptFile.cleanup();
+    }
+    if (signal?.aborted) {
+        throw new Error("Context compaction failed: Request was aborted");
+    }
+    if (agent.state.errorMessage) {
+        if (isContextCompactionOverflowError(model, agent.state.errorMessage)) {
+            return {
+                validatedResult: deletionTool.getValidatedResult(),
+                lastToolError: deletionTool.getLastError(),
+            };
+        }
+        throw new Error(`Context compaction failed: ${agent.state.errorMessage}`);
+    }
+    if (deletionTool.getCallCount() === 0) {
+        throw new Error(`Context compaction did not call any transcript inspection or deletion tools (${CONTEXT_SEARCH_TRANSCRIPT_TOOL_NAME}, ${CONTEXT_READ_ENTRY_TOOL_NAME}, ${CONTEXT_DELETE_TOOL_NAME}, or ${CONTEXT_GREP_DELETE_TOOL_NAME})`);
+    }
+    return {
+        validatedResult: deletionTool.getValidatedResult(),
+        lastToolError: deletionTool.getLastError(),
+    };
+}
+export async function contextCompact(preparation, model, apiKey, headers, signal, _thinkingLevel, mode = preparation.mode ?? "standard") {
+    const { validatedResult, lastToolError } = await runContextDeletionAssistant(preparation.transcript, model, apiKey, headers, signal, mode);
+    if (!validatedResult || validatedResult.deletedTargets.length === 0) {
+        throw new Error(lastToolError ? `No safe context deletions proposed; last deletion tool error: ${lastToolError}` : "No safe context deletions proposed");
+    }
+    return validatedResult;
+}
+//# sourceMappingURL=context-compaction.js.map