@bastani/atomic 0.8.26-alpha.9 → 0.8.27-alpha.1

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

@@ -1,11 +1,31 @@
-import { completeSimple, StringEnum } from "@earendil-works/pi-ai";
+import { Agent } from "@earendil-works/pi-agent-core";
+import { createAssistantMessageEventStream, isContextOverflow, streamSimple, StringEnum, } from "@earendil-works/pi-ai";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+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_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 +37,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 +123,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 +321,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 +333,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 +388,7 @@ export function prepareContextCompaction(pathEntries, settings) {
         return undefined;
     return {
         branchEntries: pathEntries,
+        mode: options.mode ?? "standard",
         transcript: {
             entries,
             protectedEntryIds: [...protectedEntryIds],
@@ -325,6 +408,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 +438,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 +653,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 +704,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 +715,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 +729,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 +771,593 @@ 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);
+}
+function copyDeletionTarget(target) {
+    return target.kind === "entry"
+        ? { kind: "entry", entryId: target.entryId }
+        : { kind: "content_block", entryId: target.entryId, blockIndex: target.blockIndex };
+}
+class ContextDeletionMemoryStore {
+    constructor(transcript) {
+        this.deletionTargets = [];
+        this.callCount = 0;
+        const entryIds = new Set();
+        const blockKeys = new Set();
+        this.entries = transcript.entries.map((entry) => {
+            if (entryIds.has(entry.entryId)) {
+                throw new Error(`Duplicate transcript entry id: ${entry.entryId}`);
+            }
+            entryIds.add(entry.entryId);
+            return {
+                entryId: entry.entryId,
+                role: entry.role,
+                protected: entry.protected,
+                tokenEstimate: entry.tokenEstimate,
+                text: entry.text,
+            };
+        });
+        this.entriesById = new Map(this.entries.map((entry) => [entry.entryId, entry]));
+        this.contentBlocks = transcript.entries.flatMap((entry, entryPosition) => entry.contentBlocks.map((block) => {
+            if (block.entryId !== entry.entryId) {
+                throw new Error(`Transcript content block ${block.entryId}:${block.blockIndex} does not belong to entry ${entry.entryId}`);
+            }
+            const blockKey = `${block.entryId}:${block.blockIndex}`;
+            if (blockKeys.has(blockKey)) {
+                throw new Error(`Duplicate transcript content block: ${blockKey}`);
+            }
+            blockKeys.add(blockKey);
+            return {
+                entryPosition,
+                entryId: block.entryId,
+                blockIndex: block.blockIndex,
+                type: block.type,
+                protected: block.protected,
+                tokenEstimate: block.tokenEstimate,
+                text: block.text,
+            };
+        }));
+        this.contentBlockCountByEntryId = new Map();
+        for (const block of this.contentBlocks) {
+            this.contentBlockCountByEntryId.set(block.entryId, (this.contentBlockCountByEntryId.get(block.entryId) ?? 0) + 1);
+        }
+    }
+    transaction(operation) {
+        const snapshot = this.snapshot();
+        try {
+            return operation();
+        }
+        catch (error) {
+            this.restore(snapshot);
+            throw error;
+        }
+    }
+    readTargets() {
+        return this.deletionTargets.map(copyDeletionTarget);
+    }
+    replaceTargets(targets) {
+        this.deletionTargets = targets.map(copyDeletionTarget);
+    }
+    listEntriesForGrep() {
+        return this.entries.map((entry) => ({
+            entry_id: entry.entryId,
+            text: entry.text,
+            is_protected: entry.protected ? 1 : 0,
+        }));
+    }
+    listContentBlocksForGrep() {
+        return [...this.contentBlocks]
+            .sort((a, b) => a.entryPosition - b.entryPosition || a.blockIndex - b.blockIndex)
+            .map((block) => ({
+            entry_id: block.entryId,
+            block_index: block.blockIndex,
+            text: block.text,
+            entry_protected: this.entriesById.get(block.entryId)?.protected ? 1 : 0,
+            block_protected: block.protected ? 1 : 0,
+            block_count: this.contentBlockCountByEntryId.get(block.entryId) ?? 0,
+        }));
+    }
+    getEntryForRead(entryId) {
+        const entry = this.entriesById.get(entryId);
+        if (!entry)
+            return undefined;
+        return {
+            entry_id: entry.entryId,
+            role: entry.role,
+            is_protected: entry.protected ? 1 : 0,
+            token_estimate: entry.tokenEstimate,
+            text: entry.text,
+        };
+    }
+    getContentBlockForRead(entryId, blockIndex) {
+        const block = this.contentBlocks.find((candidate) => candidate.entryId === entryId && candidate.blockIndex === blockIndex);
+        if (!block)
+            return undefined;
+        return {
+            entry_id: block.entryId,
+            block_index: block.blockIndex,
+            type: block.type,
+            token_estimate: block.tokenEstimate,
+            text: block.text,
+            entry_protected: this.entriesById.get(block.entryId)?.protected ? 1 : 0,
+            block_protected: block.protected ? 1 : 0,
+            block_count: this.contentBlockCountByEntryId.get(block.entryId) ?? 0,
+        };
+    }
+    getGrepScanTextLength(target) {
+        const texts = target === "entry" ? this.entries : this.contentBlocks;
+        return texts.reduce((sum, item) => sum + item.text.length, 0);
+    }
+    incrementCallCount() {
+        this.callCount += 1;
+        return this.callCount;
+    }
+    getCallCount() {
+        return this.callCount;
+    }
+    setLastError(message) {
+        this.lastError = message;
+    }
+    clearLastError() {
+        this.lastError = undefined;
+    }
+    getLastError() {
+        return this.lastError;
+    }
+    snapshot() {
+        return {
+            deletionTargets: this.readTargets(),
+            callCount: this.callCount,
+            ...(this.lastError === undefined ? {} : { lastError: this.lastError }),
+        };
+    }
+    restore(snapshot) {
+        this.deletionTargets = snapshot.deletionTargets.map(copyDeletionTarget);
+        this.callCount = snapshot.callCount;
+        this.lastError = snapshot.lastError;
+    }
+}
+function createContextDeletionStore(transcript) {
+    return new ContextDeletionMemoryStore(transcript);
+}
+export function createContextDeletionTool(transcript, options = {}) {
+    const mode = options.mode ?? "standard";
+    const store = createContextDeletionStore(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 +1365,213 @@ 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),
-    }));
-}
-export function buildContextCompactionPrompt(transcript) {
-    return `${CONTEXT_COMPACTION_FIXED_PROMPT}\n\n<transcript-json>\n${JSON.stringify(plannerTranscriptPayload(transcript), null, 2)}\n</transcript-json>`;
-}
-export async function planContextDeletions(transcript, model, apiKey, headers, signal, thinkingLevel) {
-    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(),
+    };
+}
+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);
+}
+async function runContextDeletionAssistant(transcript, model, apiKey, headers, signal, thinkingLevel = "off", mode = "standard") {
+    const maxTokens = 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 });
+    let compactionTurnCount = 0;
+    const agent = new Agent({
+        initialState: {
+            systemPrompt: CONTEXT_COMPACTION_SYSTEM_PROMPT,
+            model,
+            thinkingLevel,
+            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 = "off", mode = preparation.mode ?? "standard") {
+    const { validatedResult, lastToolError } = await runContextDeletionAssistant(preparation.transcript, model, apiKey, headers, signal, thinkingLevel, 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