@bastani/atomic 0.8.26-alpha.9 → 0.8.26

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

@@ -1,11 +1,33 @@
-import { completeSimple, StringEnum } from "@earendil-works/pi-ai";
+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_DELETION_PLAN_TOOL_NAME = "context_deletion_plan";
-const ContextDeletionPlanToolParameters = Type.Object({
+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.",
@@ -17,21 +39,77 @@ const ContextDeletionPlanToolParameters = Type.Object({
         })),
     }, { additionalProperties: false }), { description: "Deletion targets only. Protected entries and recent active context must not be included." }),
 }, { additionalProperties: false });
-const CONTEXT_DELETION_PLAN_TOOL = {
-    name: CONTEXT_DELETION_PLAN_TOOL_NAME,
-    description: "Emit the final context compaction deletion plan as structured data.",
-    parameters: ContextDeletionPlanToolParameters,
+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 planner for an AI coding assistant transcript. Call the context_deletion_plan tool with deletion targets only.";
-const CONTEXT_COMPACTION_FIXED_PROMPT = `You are a context compaction planner for an AI coding assistant transcript.
+const CONTEXT_COMPACTION_SYSTEM_PROMPT = `You are a context compaction assistant.
 
-Your task is deletion-only verbatim compaction.
+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.
-Another step will apply deletions locally. Return only deletion targets by stable ID.
+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.
@@ -47,13 +125,19 @@ What Survives:
 - User instructions: The original task and any clarifications.
 
 <output_format>
-Call the context_deletion_plan tool exactly once with deletion targets in this shape:
+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 }
 
-Do not write JSON or prose in a text response. The tool call is the final answer.
+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") {
@@ -239,7 +323,7 @@ function isProtectedEntry(entry, message, recentEntryIds) {
         return true;
     return false;
 }
-export function prepareContextCompaction(pathEntries, settings) {
+export function prepareContextCompaction(pathEntries, settings, options = {}) {
     if (pathEntries.length === 0)
         return undefined;
     const latestCompactionIndex = collectLatestSummaryCompactionIndex(pathEntries);
@@ -251,7 +335,7 @@ export function prepareContextCompaction(pathEntries, settings) {
         .map((index) => filteredEntryById.get(pathEntries[index].id))
         .filter((entry) => entry !== undefined && getContextEligibleMessageFromEntry(entry) !== undefined)
         .map((entry) => entry.id);
-    const recentEntryIds = new Set(messageEntryIds.slice(-5));
+    const recentEntryIds = new Set(messageEntryIds.slice(-CONTEXT_CRITICAL_OVERFLOW_RECENT_ENTRY_COUNT));
     const protectedEntryIds = new Set();
     const entries = [];
     if (latestCompactionIndex >= 0) {
@@ -306,6 +390,7 @@ export function prepareContextCompaction(pathEntries, settings) {
         return undefined;
     return {
         branchEntries: pathEntries,
+        mode: options.mode ?? "standard",
         transcript: {
             entries,
             protectedEntryIds: [...protectedEntryIds],
@@ -325,6 +410,14 @@ function normalizeRawTarget(target) {
         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));
 }
@@ -347,6 +440,153 @@ function isToolCallBlockDeleted(entry, callId, deletedEntryIds, deletedContentBl
         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);
@@ -415,15 +655,44 @@ function computeContextCompactionStats(transcript, targets) {
         percentReduction,
     };
 }
-export function validateContextDeletionPlan(plan, transcript) {
-    if (!plan || typeof plan !== "object" || !Array.isArray(plan.deletions)) {
-        throw new Error("Context deletion plan must be an object with a deletions array");
+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 deletedEntryIds = new Set();
     const deletedTargets = [];
-    for (const deletion of plan.deletions) {
+    for (const deletion of request.deletions) {
         if (!deletion || typeof deletion !== "object") {
             throw new Error("Deletion target must be an object");
         }
@@ -437,7 +706,7 @@ export function validateContextDeletionPlan(plan, transcript) {
         if (!entry) {
             throw new Error(`Unknown deletion target entryId: ${deletion.entryId}`);
         }
-        if (entry.protected) {
+        if (entry.protected && !canDeleteProtectedTargetInMode(transcript, normalizeRawTarget(deletion), mode)) {
             throw new Error(`Deletion target ${deletion.entryId} is protected`);
         }
         if (deletion.kind === "content_block") {
@@ -448,7 +717,7 @@ export function validateContextDeletionPlan(plan, transcript) {
             if (!block) {
                 throw new Error(`Unknown content block ${deletion.blockIndex} for entry ${deletion.entryId}`);
             }
-            if (block.protected) {
+            if (block.protected && !canDeleteProtectedTargetInMode(transcript, normalizeRawTarget(deletion), mode)) {
                 throw new Error(`Content block ${deletion.entryId}:${deletion.blockIndex} is protected`);
             }
             if (entry.contentBlocks.length <= 1) {
@@ -462,34 +731,34 @@ export function validateContextDeletionPlan(plan, transcript) {
         seen.add(key);
         const normalized = normalizeRawTarget(deletion);
         deletedTargets.push(normalized);
-        if (normalized.kind === "entry")
-            deletedEntryIds.add(normalized.entryId);
     }
-    for (const target of deletedTargets) {
-        if (target.kind === "content_block" && deletedEntryIds.has(target.entryId)) {
+    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(deletedTargets);
+    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, deletedTargets);
-    const remainingEntries = transcript.entries.filter((entry) => !deletedEntryIds.has(entry.entryId));
+    validateToolDependencies(transcript, reconciledTargets);
+    const remainingEntries = transcript.entries.filter((entry) => !reconciledDeletedEntryIds.has(entry.entryId));
     if (remainingEntries.length === 0) {
-        throw new Error("Deletion plan would remove all context entries");
+        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 plan would leave no user task in context");
+        throw new Error("Deletion request would leave no user task in context");
     }
     return {
-        deletedTargets,
+        deletedTargets: reconciledTargets,
         protectedEntryIds: [...transcript.protectedEntryIds],
-        stats: computeContextCompactionStats(transcript, deletedTargets),
+        stats: computeContextCompactionStats(transcript, reconciledTargets),
     };
 }
 function stripJsonFence(text) {
@@ -504,25 +773,641 @@ function stripJsonFence(text) {
         return trimmed;
     return trimmed.slice(firstLineEnd + 1, -3).trim();
 }
-function rawContextDeletionPlanFromObject(value, source) {
+function contextDeletionRequestFromObject(value, source) {
     if (!value || typeof value !== "object" || !Array.isArray(value.deletions)) {
         throw new Error(`${source} must contain a deletions array`);
     }
     return value;
 }
-export function parseContextDeletionPlan(text) {
+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 plan JSON: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Failed to parse context deletion request JSON: ${error instanceof Error ? error.message : String(error)}`);
     }
-    return rawContextDeletionPlanFromObject(parsed, "Context deletion plan JSON");
+    return contextDeletionRequestFromObject(parsed, "Context deletion request JSON");
 }
-function isContextDeletionPlanToolCall(content) {
-    return content.type === "toolCall" && content.name === CONTEXT_DELETION_PLAN_TOOL_NAME;
+function isContextDeleteToolCall(content) {
+    return content.type === "toolCall" && content.name === CONTEXT_DELETE_TOOL_NAME;
 }
 function textContentFromResponse(response) {
     return response.content
@@ -530,73 +1415,222 @@ function textContentFromResponse(response) {
         .map((content) => content.text)
         .join("\n");
 }
-export function parseContextDeletionPlanResponse(response) {
-    const toolCalls = response.content.filter(isContextDeletionPlanToolCall);
+export function parseContextDeletionResponse(response) {
+    const toolCalls = response.content.filter(isContextDeleteToolCall);
     if (toolCalls.length > 1) {
-        throw new Error(`Context compaction planner called ${CONTEXT_DELETION_PLAN_TOOL_NAME} more than once`);
+        throw new Error(`Context compaction assistant called ${CONTEXT_DELETE_TOOL_NAME} more than once`);
     }
     const toolCall = toolCalls[0];
     if (toolCall) {
-        return rawContextDeletionPlanFromObject(toolCall.arguments, `${CONTEXT_DELETION_PLAN_TOOL_NAME} arguments`);
+        return contextDeletionRequestFromObject(toolCall.arguments, `${CONTEXT_DELETE_TOOL_NAME} arguments`);
     }
     const textContent = textContentFromResponse(response);
     if (textContent.trim().length === 0) {
-        throw new Error(`Context compaction planner did not call ${CONTEXT_DELETION_PLAN_TOOL_NAME}`);
+        throw new Error(`Context compaction assistant did not call ${CONTEXT_DELETE_TOOL_NAME}`);
     }
-    return parseContextDeletionPlan(textContent);
+    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 planner prompt]`;
+    return `${text.slice(0, maxChars)}\n[... ${text.length - maxChars} more characters omitted from context compaction prompt]`;
 }
-function plannerTranscriptPayload(transcript) {
-    return transcript.entries
-        .filter((entry) => !isExcludedFromLlmContext(entry.message))
-        .map((entry) => ({
+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,
-            text: truncateForPrompt(block.text, 2000),
+            tokenEstimate: block.tokenEstimate,
+            text: block.text,
         })),
-        text: truncateForPrompt(entry.text, 4000),
-    }));
+    };
+}
+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>`;
 }
-export function buildContextCompactionPrompt(transcript) {
-    return `${CONTEXT_COMPACTION_FIXED_PROMPT}\n\n<transcript-json>\n${JSON.stringify(plannerTranscriptPayload(transcript), null, 2)}\n</transcript-json>`;
+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";
 }
-export async function planContextDeletions(transcript, model, apiKey, headers, signal, thinkingLevel) {
+async function runContextDeletionAssistant(transcript, model, apiKey, headers, signal, mode = "standard") {
     const maxTokens = Math.min(4096, model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY);
-    const messages = [
-        {
-            role: "user",
-            content: [{ type: "text", text: buildContextCompactionPrompt(transcript) }],
-            timestamp: Date.now(),
+    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 options = model.reasoning && thinkingLevel && thinkingLevel !== "off"
-        ? { maxTokens, signal, apiKey, headers, reasoning: thinkingLevel }
-        : { maxTokens, signal, apiKey, headers };
-    const response = await completeSimple(model, { systemPrompt: CONTEXT_COMPACTION_SYSTEM_PROMPT, messages, tools: [CONTEXT_DELETION_PLAN_TOOL] }, options);
-    if (response.stopReason === "error") {
-        throw new Error(`Context compaction planning failed: ${response.errorMessage || "Unknown error"}`);
-    }
-    return parseContextDeletionPlanResponse(response);
-}
-export async function contextCompact(preparation, model, apiKey, headers, signal, thinkingLevel) {
-    const plan = await planContextDeletions(preparation.transcript, model, apiKey, headers, signal, thinkingLevel);
-    const validated = validateContextDeletionPlan(plan, preparation.transcript);
-    if (validated.deletedTargets.length === 0) {
-        throw new Error("No safe context deletions proposed");
-    }
-    return validated;
+    });
+    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