@bastani/atomic 0.8.29 → 0.8.30-alpha.2

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

@@ -1,24 +1,28 @@
 import { Agent } from "@earendil-works/pi-agent-core";
-import { createAssistantMessageEventStream, isContextOverflow, streamSimple, StringEnum, } from "@earendil-works/pi-ai";
+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, createCustomMessage } from "../messages.js";
-import { buildContextDeletionFilteredPath, buildContextDeletionFilters, } from "../session-manager.js";
+import { isAssistantThinkingBlockType, messageHasAssistantThinkingContentBlock, } from "../thinking-blocks.js";
+import { buildContextDeletionFilteredPath, buildEffectiveContextDeletionFilters, } from "../session-manager.js";
 import { estimateTokens } from "./compaction.js";
 export const CONTEXT_COMPACTION_PROMPT_VERSION = 1;
 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_COMPACTION_BUDGET_TOOL_NAME = "context_compaction_budget";
+export const CONTEXT_COMPACTION_DEFAULT_COMPRESSION_RATIO = 0.5;
+export const CONTEXT_COMPACTION_TARGET_REDUCTION_PERCENT = 50;
+export const CONTEXT_COMPACTION_DEFAULT_PRESERVE_RECENT = 2;
+export const CONTEXT_COMPACTION_AUTO_QUERY = "auto-detected";
 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;
@@ -35,7 +39,9 @@ const ContextDeleteToolParameters = Type.Object({
             minimum: 0,
             description: "Required when kind is content_block; omit when kind is entry.",
         })),
-    }, { additionalProperties: false }), { description: "Deletion targets only. Protected entries and recent active context must not be included." }),
+    }, { additionalProperties: false }), {
+        description: "ID-only deletion targets. Include only kind, entryId, and blockIndex when needed; do not include transcript text, block contents, summaries, or replacement content. Invalid targets are rejected by the tool with correction guidance.",
+    }),
 }, { additionalProperties: false });
 const ContextGrepDeleteToolParameters = Type.Object({
     pattern: Type.String({ minLength: 1, description: "Literal text or regular expression to match in transcript text." }),
@@ -47,7 +53,7 @@ const ContextGrepDeleteToolParameters = Type.Object({
     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.",
+        description: "Per-call safety cap. If more not-yet-deleted candidate targets are found in this tool call, no deletions are applied. Defaults to 50. This is not a cumulative compaction cap; call the tool again for additional batches.",
     })),
     expectedMatchCount: Type.Optional(Type.Integer({
         minimum: 0,
@@ -78,6 +84,7 @@ const ContextReadEntryToolParameters = Type.Object({
         description: "Maximum characters to return. Defaults to 4000; keep reads small to avoid overflowing context.",
     })),
 }, { additionalProperties: false });
+const ContextCompactionBudgetToolParameters = Type.Object({}, { additionalProperties: false });
 const CONTEXT_DELETE_TOOL = {
     name: CONTEXT_DELETE_TOOL_NAME,
     description: "Record context compaction deletion targets directly against the transcript.",
@@ -98,16 +105,36 @@ const CONTEXT_READ_ENTRY_TOOL = {
     description: "Read a small slice of one transcript entry or content block from the full transcript working copy.",
     parameters: ContextReadEntryToolParameters,
 };
+const CONTEXT_COMPACTION_BUDGET_TOOL = {
+    name: CONTEXT_COMPACTION_BUDGET_TOOL_NAME,
+    description: "Report current context-window fullness and reduction progress for the selected deletion targets without mutating deletion state.",
+    parameters: ContextCompactionBudgetToolParameters,
+};
 const CONTEXT_COMPACTION_SYSTEM_PROMPT = `You are a context compaction assistant.
 
 Your task is to read relevant parts of a conversation between a user and an AI assistant provided via a transcript file, then run a series of tools to apply deletion-only verbatim compaction using the exact context_delete or context_grep_delete format specified.`;
-const CONTEXT_COMPACTION_FIXED_PROMPT = `Reference the provided transcript file transcript and use your search/read tools for small inspections, then use context_delete or context_grep_delete for deletions.
+function contextCompactionFixedPrompt(parameters) {
+    const targetLabel = contextCompactionTargetLabel(parameters);
+    return `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.
+
+Compaction records deletion targets, not replacement content.
+For context_delete, use id-only targets: stable entryId values and optional blockIndex values only.
+For context_grep_delete, use a concise literal or regex pattern to select matching entries or blocks; do not paste full transcript entries or content-block bodies.
+Do not summarize, paraphrase, or generate replacement context; those are not accepted compaction outputs.
+Do not mutate retained transcript objects or content.
+Deletion tool calls are the compaction action.
 
-You MUST NOT summarize.
-You MUST NOT paraphrase.
-You MUST NOT generate replacement context.
-You MUST NOT mutate retained transcript objects or content.
-Deletion tool calls are the compaction action; record only deletion targets by stable ID.
+Strategy:
+- Start by calling context_compaction_budget to see how much of the context window is full and how much reduction is needed.
+- Spend a few turns exploring with search/read tools to gain high confidence of candidate blocks to remove.
+- Prefer high-confidence exploit actions after that: delete obvious low-value entries via context_grep_delete or context_delete.
+- Use grep deletion for repeated low-value patterns.
+- Use exact id deletion for inspected one-off stale entries.
+- Check context_compaction_budget after deletion batches to track progress.
+- Strict requirement: reduce current context by at least ${targetLabel} before finishing. This is a hard completion gate, not a loose goal.
+- Do not send a final plain-text completion message until context_compaction_budget reports at least ${targetLabel} currentReductionPercent.
+- If the strict ${targetLabel} reduction is not met yet, continue removing low-value message entries or content blocks with context_delete/context_grep_delete.
+- Use the focus query to preserve relevant context: ${JSON.stringify(parameters.query)}.
 
 What Gets Deleted:
 - Redundant tool outputs: file reads already acted on, grep/search results already processed, passing test output no longer needed.
@@ -117,11 +144,14 @@ What Gets Deleted:
 
 What Survives:
 - Active file paths and line numbers: Any reference the agent might need to navigate.
-- Current error messages: Unresolved bugss and their exact text.
+- Current error messages: Unresolved bugs and their exact text.
 - Reasoning decisions: Why the agent chose approach A over B. An agent's chain of thought (why it chose this file, what pattern it noticed, what fix it decided on) carries more information-per-token than the raw grep output or file content that informed those decisions.
 - Recent tool calls and their results: The last 3-5 operations.
 - User instructions: The original task and any clarifications.
 
+Conditionally Deleted:
+- Old Reasoning decisions: If there is nothing else to remove and the target reduction is not met, you can remove reasoning steps, EXCEPT do not delete any content block from the latest assistant message when that message contains thinking or redacted_thinking blocks.
+
 <output_format>
 Call the context_delete tool one or more times with deletion targets in this shape:
 { "deletions": [{ "kind": "entry", "entryId": "..." }] }
@@ -131,12 +161,13 @@ For content-block deletions, use:
 
 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.
+For guarded bulk deletion by text match, call context_grep_delete with a literal pattern or regex. It removes valid matching context, silently ignores candidates that validation does not allow so they are not counted as removals, enforces a per-call maxMatches safety cap and optional expectedMatchCount, and validates through the same tool-call/tool-result safety rules. maxMatches only limits one tool call; there is no cumulative cap across corrected or repeated deletion calls.
 
 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.
+When the strict ${targetLabel} reduction requirement is met, reply with a brief plain-text completion message. Do not include deletion target IDs outside tool calls.
 </output_format>`;
+}
 function getMessageFromEntry(entry) {
     if (entry.type === "message") {
         return entry.message;
@@ -190,6 +221,11 @@ function textFromContentBlock(block) {
         return "[image]";
     return JSON.stringify(record);
 }
+function assistantEntryHasThinkingContentBlock(entry) {
+    return (entry.role === "assistant" &&
+        (entry.contentBlocks.some((block) => isAssistantThinkingBlockType(block.type)) ||
+            messageHasAssistantThinkingContentBlock(entry.message)));
+}
 const IMAGE_BLOCK_CHAR_ESTIMATE = 4800;
 const IMAGE_BLOCK_TOKEN_ESTIMATE = Math.ceil(IMAGE_BLOCK_CHAR_ESTIMATE / 4);
 function estimateTextTokens(text) {
@@ -221,15 +257,17 @@ function contentBlocksForEntry(entryId, message, protectedEntry, existingDeleted
         return [];
     return content
         .map((block, blockIndex) => {
-        if (existingDeletedBlocks?.has(blockIndex))
+        if (existingDeletedBlocks?.has(blockIndex)) {
             return undefined;
+        }
+        const type = block && typeof block === "object" && typeof block.type === "string"
+            ? (block.type)
+            : "unknown";
         const text = textFromContentBlock(block);
         return {
             entryId,
             blockIndex,
-            type: block && typeof block === "object" && typeof block.type === "string"
-                ? (block.type)
-                : "unknown",
+            type,
             text,
             tokenEstimate: estimateContentBlockTokens(block, text),
             protected: protectedEntry,
@@ -272,6 +310,51 @@ function hasToolResultError(message) {
 function hasFailedBashExecution(message) {
     return message.role === "bashExecution" && typeof message.exitCode === "number" && message.exitCode !== 0;
 }
+const CONTEXT_COMPACTION_QUERY_MAX_CHARS = 1000;
+function normalizeCompressionRatio(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 && value < 1
+        ? value
+        : CONTEXT_COMPACTION_DEFAULT_COMPRESSION_RATIO;
+}
+function normalizePreserveRecent(value) {
+    return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : CONTEXT_COMPACTION_DEFAULT_PRESERVE_RECENT;
+}
+function normalizeQuery(value, fallbackQuery) {
+    const query = value?.trim() || fallbackQuery.trim() || CONTEXT_COMPACTION_AUTO_QUERY;
+    return query.length > CONTEXT_COMPACTION_QUERY_MAX_CHARS
+        ? `${query.slice(0, CONTEXT_COMPACTION_QUERY_MAX_CHARS)}\n[... ${query.length - CONTEXT_COMPACTION_QUERY_MAX_CHARS} more characters omitted from compaction query]`
+        : query;
+}
+export function autoDetectContextCompactionQuery(pathEntries) {
+    for (let index = pathEntries.length - 1; index >= 0; index--) {
+        const entry = pathEntries[index];
+        if (entry.type === "context_compaction")
+            continue;
+        const message = getContextEligibleMessageFromEntry(entry);
+        if (!message || message.role !== "user")
+            continue;
+        const text = messageText(message).trim();
+        if (text.length > 0)
+            return normalizeQuery(text, CONTEXT_COMPACTION_AUTO_QUERY);
+    }
+    return CONTEXT_COMPACTION_AUTO_QUERY;
+}
+export function normalizeContextCompactionParameters(input = {}, fallbackQuery = CONTEXT_COMPACTION_AUTO_QUERY) {
+    return {
+        compression_ratio: normalizeCompressionRatio(input.compression_ratio),
+        preserve_recent: normalizePreserveRecent(input.preserve_recent),
+        query: normalizeQuery(input.query, fallbackQuery),
+    };
+}
+function getTranscriptCompactionParameters(transcript) {
+    return normalizeContextCompactionParameters(transcript.parameters ?? transcript.settings, transcript.parameters?.query ?? transcript.settings.query ?? CONTEXT_COMPACTION_AUTO_QUERY);
+}
+function contextCompactionTargetReductionPercent(parameters) {
+    return roundPercent((1 - parameters.compression_ratio) * 100);
+}
+function contextCompactionTargetLabel(parameters) {
+    return `${contextCompactionTargetReductionPercent(parameters)}%`;
+}
 function isProtectedEntry(entry, message, recentEntryIds) {
     if (recentEntryIds.has(entry.id))
         return true;
@@ -292,13 +375,14 @@ function isProtectedEntry(entry, message, recentEntryIds) {
 export function prepareContextCompaction(pathEntries, settings, options = {}) {
     if (pathEntries.length === 0)
         return undefined;
-    const deletionFilters = buildContextDeletionFilters(pathEntries);
-    const filteredPathEntries = buildContextDeletionFilteredPath(pathEntries, deletionFilters);
+    const effectiveDeletionFilters = buildEffectiveContextDeletionFilters(pathEntries);
+    const filteredPathEntries = buildContextDeletionFilteredPath(pathEntries, effectiveDeletionFilters);
+    const parameters = normalizeContextCompactionParameters({ ...settings, ...options }, autoDetectContextCompactionQuery(filteredPathEntries));
     const rawEntryById = new Map(pathEntries.map((entry) => [entry.id, entry]));
     const messageEntryIds = filteredPathEntries
         .filter((entry) => entry.type !== "context_compaction" && getContextEligibleMessageFromEntry(entry) !== undefined)
         .map((entry) => entry.id);
-    const recentEntryIds = new Set(messageEntryIds.slice(-CONTEXT_CRITICAL_OVERFLOW_RECENT_ENTRY_COUNT));
+    const recentEntryIds = new Set(parameters.preserve_recent > 0 ? messageEntryIds.slice(-parameters.preserve_recent) : []);
     const protectedEntryIds = new Set();
     const entries = [];
     for (const entry of filteredPathEntries) {
@@ -312,7 +396,7 @@ export function prepareContextCompaction(pathEntries, settings, options = {}) {
         if (protectedEntry)
             protectedEntryIds.add(entry.id);
         const rawMessage = getContextEligibleMessageFromEntry(rawEntry) ?? message;
-        const contentBlocks = contentBlocksForEntry(entry.id, rawMessage, protectedEntry, deletionFilters.deletedContentBlocks.get(entry.id));
+        const contentBlocks = contentBlocksForEntry(entry.id, rawMessage, protectedEntry, effectiveDeletionFilters.deletedContentBlocks.get(entry.id));
         const toolCallIds = contentBlocks.map((block) => block.toolCallId).filter((id) => id !== undefined);
         const text = contentBlocks.length > 0 ? contentBlocks.map((block) => block.text).join("\n") : messageText(message);
         entries.push({
@@ -332,12 +416,13 @@ export function prepareContextCompaction(pathEntries, settings, options = {}) {
         return undefined;
     return {
         branchEntries: pathEntries,
-        mode: options.mode ?? "standard",
+        parameters,
         transcript: {
             entries,
             protectedEntryIds: [...protectedEntryIds],
             tokensBefore: entries.reduce((total, entry) => total + entry.tokenEstimate, 0),
             settings,
+            parameters,
         },
     };
 }
@@ -352,6 +437,14 @@ function normalizeRawTarget(target) {
         return { kind: "entry", entryId: target.entryId };
     return { kind: "content_block", entryId: target.entryId, blockIndex: target.blockIndex };
 }
+function assertIdOnlyDeletionTarget(target) {
+    const allowedKeys = target.kind === "content_block" ? new Set(["kind", "entryId", "blockIndex"]) : new Set(["kind", "entryId"]);
+    for (const key of Object.keys(target)) {
+        if (!allowedKeys.has(key)) {
+            throw new Error(`Deletion target includes unsupported property ${JSON.stringify(key)}; context deletion targets are id-only and must contain only kind, entryId${target.kind === "content_block" ? ", and blockIndex" : ""}`);
+        }
+    }
+}
 function rawDeletionFromTarget(target) {
     if (target.kind === "entry")
         return { kind: "entry", entryId: target.entryId };
@@ -374,6 +467,113 @@ function getDeletedContentBlocks(targets) {
     }
     return blocksByEntry;
 }
+function recentContextEntryBoundary(transcript) {
+    const { preserve_recent } = getTranscriptCompactionParameters(transcript);
+    return preserve_recent > 0 ? Math.max(0, transcript.entries.length - preserve_recent) : transcript.entries.length;
+}
+function getRecentContextEntryIds(transcript) {
+    const { preserve_recent } = getTranscriptCompactionParameters(transcript);
+    if (preserve_recent <= 0)
+        return new Set();
+    return new Set(transcript.entries.slice(recentContextEntryBoundary(transcript)).map((entry) => entry.entryId));
+}
+function isRecentContextEntry(entry, transcript) {
+    const { preserve_recent } = getTranscriptCompactionParameters(transcript);
+    if (preserve_recent <= 0)
+        return false;
+    const entryIndex = transcript.entries.findIndex((candidate) => candidate.entryId === entry.entryId);
+    return entryIndex >= 0 && entryIndex >= recentContextEntryBoundary(transcript);
+}
+function formatRecentContextDeletionError(transcript, target) {
+    const { preserve_recent } = getTranscriptCompactionParameters(transcript);
+    const recentWindow = `last ${preserve_recent} context ${preserve_recent === 1 ? "entry" : "entries"}`;
+    if (target.kind === "entry") {
+        return `Cannot delete recent context entry ${target.entryId} because the ${recentWindow} must remain available for active continuity. Choose an older entry.`;
+    }
+    return `Cannot delete content block ${target.entryId}:${target.blockIndex} because entry ${target.entryId} is one of the ${recentWindow} that must remain available for active continuity. Choose an older entry or content block.`;
+}
+function deletionGuidance() {
+    return "Choose another deletion candidate.";
+}
+function findTranscriptEntry(transcript, entryId) {
+    return transcript.entries.find((entry) => entry.entryId === entryId);
+}
+function findTranscriptContentBlock(transcript, target) {
+    if (target.kind !== "content_block")
+        return undefined;
+    return findTranscriptEntry(transcript, target.entryId)?.contentBlocks.find((block) => block.blockIndex === target.blockIndex);
+}
+function firstToolCallBlockTarget(entry, callId) {
+    const blockIndex = toolCallBlockIndexes(entry, callId)[0];
+    return blockIndex === undefined ? undefined : { kind: "content_block", entryId: entry.entryId, blockIndex };
+}
+function formatProtectedDeletionError(transcript, target) {
+    const entry = findTranscriptEntry(transcript, target.entryId);
+    if (target.kind === "entry") {
+        const toolResultSuffix = entry?.toolResultFor ? ` for tool call ${entry.toolResultFor}` : "";
+        const toolCallSuffix = entry && entry.toolCallIds.length > 0 ? ` containing tool call ${entry.toolCallIds.join(", ")}` : "";
+        return `Deletion target ${target.entryId}${toolResultSuffix}${toolCallSuffix} is protected. ${deletionGuidance()}`;
+    }
+    const block = findTranscriptContentBlock(transcript, target);
+    const toolBlockSuffix = block?.toolCallId ? ` It is a protected tool block for tool call ${block.toolCallId}.` : "";
+    return `Content block ${target.entryId}:${target.blockIndex} is protected.${toolBlockSuffix} ${deletionGuidance()}`;
+}
+function formatProtectedToolDependencyError(transcript, blockedTarget, context) {
+    const protectedMessage = formatProtectedDeletionError(transcript, blockedTarget);
+    return `${context} ${protectedMessage}`;
+}
+function isProtectedContextDeletionErrorMessage(message) {
+    return (/\bprotected\b/i.test(message) ||
+        /Cannot delete (?:recent context entry|content block .* because entry .* is one of the last)/u.test(message) ||
+        /latest assistant message|thinking\/redacted_thinking block in the latest assistant message/u.test(message));
+}
+function assertNoRecentContextDeletionTargets(transcript, targets) {
+    const recentEntryIds = getRecentContextEntryIds(transcript);
+    for (const target of targets) {
+        if (recentEntryIds.has(target.entryId)) {
+            throw new Error(formatRecentContextDeletionError(transcript, target));
+        }
+    }
+}
+function latestAssistantEntry(transcript, deletedEntryIds = new Set()) {
+    for (let index = transcript.entries.length - 1; index >= 0; index--) {
+        const entry = transcript.entries[index];
+        if (entry.role === "assistant" && !deletedEntryIds.has(entry.entryId))
+            return entry;
+    }
+    return undefined;
+}
+function findLatestAssistantThinkingDeletionViolation(transcript, targets) {
+    const deletedEntryIds = getDeletedEntryIds(targets);
+    const latestRetainedAssistant = latestAssistantEntry(transcript, deletedEntryIds);
+    for (const target of targets) {
+        if (target.kind === "entry") {
+            const entry = findTranscriptEntry(transcript, target.entryId);
+            if (!entry || !assistantEntryHasThinkingContentBlock(entry))
+                continue;
+            const deletedEntryIdsIfTargetWereKept = new Set(deletedEntryIds);
+            deletedEntryIdsIfTargetWereKept.delete(target.entryId);
+            if (latestAssistantEntry(transcript, deletedEntryIdsIfTargetWereKept)?.entryId === target.entryId) {
+                return target;
+            }
+            continue;
+        }
+        if (latestRetainedAssistant?.entryId === target.entryId &&
+            assistantEntryHasThinkingContentBlock(latestRetainedAssistant)) {
+            return target;
+        }
+    }
+    return undefined;
+}
+function assertNoLatestAssistantThinkingDeletionTargets(transcript, targets) {
+    const violation = findLatestAssistantThinkingDeletionViolation(transcript, targets);
+    if (!violation)
+        return;
+    if (violation.kind === "entry") {
+        throw new Error(`Cannot delete assistant entry ${violation.entryId} because it is the latest assistant message retained after other deletions and contains thinking/redacted_thinking content blocks`);
+    }
+    throw new Error(`Cannot delete content block ${violation.entryId}:${violation.blockIndex} because a thinking/redacted_thinking block in the latest assistant message must remain unmodified; the latest retained assistant message contains thinking/redacted_thinking content blocks`);
+}
 function isToolCallBlockDeleted(entry, callId, deletedEntryIds, deletedContentBlocks) {
     if (deletedEntryIds.has(entry.entryId))
         return true;
@@ -404,15 +604,6 @@ function deleteEntryTarget(targets, entryId) {
     }
     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) {
@@ -426,8 +617,10 @@ function mergeContextDeletionTargets(baseTargets, additionalTargets) {
     }
     return targets;
 }
-function canonicalizeEntryTargets(targets, entry) {
-    if (entry.protected || getDeletedEntryIds(targets).has(entry.entryId))
+function canonicalizeEntryTargets(transcript, targets, entry) {
+    if (!canDeleteTarget(transcript, { kind: "entry", entryId: entry.entryId }))
+        return false;
+    if (getDeletedEntryIds(targets).has(entry.entryId))
         return false;
     const deletedBlocks = getDeletedContentBlocks(targets).get(entry.entryId);
     if (!deletedBlocks || !entry.contentBlocks.every((block) => deletedBlocks.has(block.blockIndex)))
@@ -436,28 +629,17 @@ function canonicalizeEntryTargets(targets, entry) {
     // 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;
+function addToolCallDeletion(transcript, targets, entry, callId) {
     let changed = false;
     for (const blockIndex of toolCallBlockIndexes(entry, callId)) {
+        const target = { kind: "content_block", entryId: entry.entryId, blockIndex };
+        if (!canDeleteTarget(transcript, target))
+            continue;
         if (!getDeletedEntryIds(targets).has(entry.entryId)) {
-            changed = addTarget(targets, { kind: "content_block", entryId: entry.entryId, blockIndex }) || changed;
+            changed = addTarget(targets, target) || changed;
         }
     }
-    return canonicalizeEntryTargets(targets, entry) || changed;
+    return canonicalizeEntryTargets(transcript, targets, entry) || changed;
 }
 let warnedReconciliationNonConvergence = false;
 function reconcileToolDependencies(transcript, initialTargets) {
@@ -496,9 +678,14 @@ function reconcileToolDependencies(transcript, initialTargets) {
             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));
+                const retainedProtectedResult = results.find((entry) => !deletedEntryIds.has(entry.entryId) &&
+                    !canDeleteTarget(transcript, { kind: "entry", entryId: entry.entryId }));
                 if (retainedProtectedResult) {
-                    recordChange(removeToolCallDeletion(targets, callEntry, callId));
+                    const retainedResultTarget = { kind: "entry", entryId: retainedProtectedResult.entryId };
+                    if (isRecentTarget(transcript, retainedResultTarget)) {
+                        throw new Error(formatRecentContextDeletionError(transcript, retainedResultTarget));
+                    }
+                    throw new Error(formatProtectedToolDependencyError(transcript, retainedResultTarget, `Cannot delete tool call ${callId} because its paired tool result entry ${retainedProtectedResult.entryId} is protected.`));
                 }
                 else {
                     for (const result of results) {
@@ -512,15 +699,19 @@ function reconcileToolDependencies(transcript, initialTargets) {
                 if (!deletedEntryIds.has(result.entryId))
                     continue;
                 recordChange(deleteEntryTarget(targets, result.entryId));
-                if (callEntry.protected) {
-                    recordChange(removeEntryDeletion(targets, result.entryId));
-                    continue;
+                const callEntryTarget = { kind: "entry", entryId: callEntry.entryId };
+                const callBlockTarget = firstToolCallBlockTarget(callEntry, callId) ?? callEntryTarget;
+                if (!canDeleteTarget(transcript, callBlockTarget)) {
+                    if (isRecentTarget(transcript, callBlockTarget)) {
+                        throw new Error(formatRecentContextDeletionError(transcript, callBlockTarget));
+                    }
+                    throw new Error(formatProtectedToolDependencyError(transcript, callBlockTarget, `Cannot delete tool result entry ${result.entryId} because that would require deleting protected tool block for tool call ${callId}.`));
                 }
-                recordChange(addToolCallDeletion(targets, callEntry, callId));
+                recordChange(addToolCallDeletion(transcript, targets, callEntry, callId));
             }
         }
         for (const entry of entriesWithToolCalls) {
-            recordChange(canonicalizeEntryTargets(targets, entry));
+            recordChange(canonicalizeEntryTargets(transcript, targets, entry));
         }
     }
     if (changed && !warnedReconciliationNonConvergence) {
@@ -602,11 +793,7 @@ function computeContextCompactionStats(transcript, targets) {
  * message, an extension-injected `custom` message, or a branch summary (`branchSummary` role /
  * `branch_summary` entry type) that recaps an earlier branch's task.
  *
- * Verbatim compaction must always leave at least one task-bearing entry in context. The same set
- * also defines which protected entries `critical_overflow` may delete, because the intent each one
- * carries is recoverable from any other surviving task-bearing entry. As a deliberate consequence,
- * `critical_overflow` MAY delete every literal `user` message as long as a branch summary or custom
- * entry survives — branch summaries intentionally carry the task forward.
+ * Verbatim compaction must always leave at least one task-bearing entry in context.
  */
 function isTaskBearingEntry(entry) {
     return (entry.role === "user" ||
@@ -614,37 +801,31 @@ function isTaskBearingEntry(entry) {
         entry.role === "branchSummary" ||
         entry.entryType === "branch_summary");
 }
-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 isTaskBearingEntry(entry);
+function isRecentTarget(transcript, target) {
+    const entry = transcript.entries.find((candidate) => candidate.entryId === target.entryId);
+    return entry !== undefined && isRecentContextEntry(entry, transcript);
 }
-function canDeleteProtectedTargetInMode(transcript, target, mode) {
-    if (mode !== "critical_overflow")
-        return false;
+function canDeleteTarget(transcript, target) {
     const entry = transcript.entries.find((candidate) => candidate.entryId === target.entryId);
-    if (!entry || !isCriticalOverflowProtectedEntryDeletable(entry, transcript))
+    if (!entry)
+        return false;
+    if (isRecentTarget(transcript, target))
+        return false;
+    if (entry.protected)
         return false;
     if (target.kind === "entry")
         return true;
     const block = entry.contentBlocks.find((candidate) => candidate.blockIndex === target.blockIndex);
-    return block !== undefined;
+    if (!block)
+        return false;
+    return !block.protected;
 }
-export function validateContextDeletionRequest(request, transcript, options = {}) {
-    const mode = options.mode ?? "standard";
+export function validateContextDeletionRequest(request, transcript) {
     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 recentEntryIds = getRecentContextEntryIds(transcript);
     const seen = new Set();
     const deletedTargets = [];
     for (const deletion of request.deletions) {
@@ -654,6 +835,7 @@ export function validateContextDeletionRequest(request, transcript, options = {}
         if (deletion.kind !== "entry" && deletion.kind !== "content_block") {
             throw new Error(`Unsupported deletion target kind: ${String(deletion.kind)}`);
         }
+        assertIdOnlyDeletionTarget(deletion);
         if (typeof deletion.entryId !== "string" || deletion.entryId.length === 0) {
             throw new Error("Deletion target entryId must be a non-empty string");
         }
@@ -661,19 +843,31 @@ export function validateContextDeletionRequest(request, transcript, options = {}
         if (!entry) {
             throw new Error(`Unknown deletion target entryId: ${deletion.entryId}`);
         }
-        if (entry.protected && !canDeleteProtectedTargetInMode(transcript, normalizeRawTarget(deletion), mode)) {
-            throw new Error(`Deletion target ${deletion.entryId} is protected`);
+        const normalized = normalizeRawTarget(deletion);
+        if (deletion.kind === "entry") {
+            if (recentEntryIds.has(deletion.entryId)) {
+                throw new Error(formatRecentContextDeletionError(transcript, normalized));
+            }
+            if (entry.protected) {
+                throw new Error(formatProtectedDeletionError(transcript, normalized));
+            }
         }
         if (deletion.kind === "content_block") {
-            if (!Number.isInteger(deletion.blockIndex) || deletion.blockIndex === undefined || deletion.blockIndex < 0) {
+            if (typeof deletion.blockIndex !== "number" || !Number.isInteger(deletion.blockIndex) || deletion.blockIndex < 0) {
                 throw new Error(`Invalid content block index for entry ${deletion.entryId}`);
             }
+            if (recentEntryIds.has(deletion.entryId)) {
+                throw new Error(formatRecentContextDeletionError(transcript, normalized));
+            }
+            if (entry.protected) {
+                throw new Error(formatProtectedDeletionError(transcript, normalized));
+            }
             const block = entry.contentBlocks.find((item) => item.blockIndex === deletion.blockIndex);
             if (!block) {
                 throw new Error(`Unknown content block ${deletion.blockIndex} for entry ${deletion.entryId}`);
             }
-            if (block.protected && !canDeleteProtectedTargetInMode(transcript, normalizeRawTarget(deletion), mode)) {
-                throw new Error(`Content block ${deletion.entryId}:${deletion.blockIndex} is protected`);
+            if (block.protected) {
+                throw new Error(formatProtectedDeletionError(transcript, normalized));
             }
             if (entry.contentBlocks.length <= 1) {
                 throw new Error(`Deleting the only content block of ${deletion.entryId} must be an entry deletion`);
@@ -684,10 +878,13 @@ export function validateContextDeletionRequest(request, transcript, options = {}
             throw new Error(`Duplicate deletion target: ${key}`);
         }
         seen.add(key);
-        const normalized = normalizeRawTarget(deletion);
         deletedTargets.push(normalized);
     }
     const reconciledTargets = reconcileToolDependencies(transcript, deletedTargets);
+    // Tool reconciliation can add targets after the per-request checks above, so
+    // these post-reconcile assertions remain authoritative.
+    assertNoRecentContextDeletionTargets(transcript, reconciledTargets);
+    assertNoLatestAssistantThinkingDeletionTargets(transcript, reconciledTargets);
     const reconciledDeletedEntryIds = getDeletedEntryIds(reconciledTargets);
     for (const target of reconciledTargets) {
         if (target.kind === "content_block" && reconciledDeletedEntryIds.has(target.entryId)) {
@@ -716,18 +913,6 @@ export function validateContextDeletionRequest(request, transcript, options = {}
         stats: computeContextCompactionStats(transcript, reconciledTargets),
     };
 }
-function stripJsonFence(text) {
-    const trimmed = text.trim();
-    if (!trimmed.startsWith("```") || !trimmed.endsWith("```"))
-        return trimmed;
-    const firstLineEnd = trimmed.indexOf("\n");
-    if (firstLineEnd < 0)
-        return trimmed;
-    const fenceInfo = trimmed.slice(3, firstLineEnd).trim().toLowerCase();
-    if (fenceInfo !== "" && fenceInfo !== "json")
-        return trimmed;
-    return trimmed.slice(firstLineEnd + 1, -3).trim();
-}
 function contextDeletionRequestFromObject(value, source) {
     if (!value || typeof value !== "object" || !Array.isArray(value.deletions)) {
         throw new Error(`${source} must contain a deletions array`);
@@ -743,6 +928,69 @@ function formatErrorMessage(error) {
 function createContextDeletionToolResult(text, details) {
     return { content: [{ type: "text", text }], details, terminate: false };
 }
+function roundPercent(value) {
+    return Math.round(value * 10) / 10;
+}
+function percentOf(part, total) {
+    return total > 0 ? roundPercent((part / total) * 100) : 0;
+}
+function finitePositiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function createContextCompactionBudgetDetails(stats, callCount, contextWindow, parameters) {
+    const targetTokensAfter = Math.max(0, Math.floor(stats.tokensBefore * parameters.compression_ratio));
+    const targetReductionPercent = contextCompactionTargetReductionPercent(parameters);
+    const details = {
+        ...(contextWindow !== undefined ? { contextWindow } : {}),
+        compression_ratio: parameters.compression_ratio,
+        tokensBefore: stats.tokensBefore,
+        currentTokensAfter: stats.tokensAfter,
+        deletedTokens: Math.max(0, stats.tokensBefore - stats.tokensAfter),
+        currentReductionPercent: stats.percentReduction,
+        targetReductionPercent,
+        targetTokensAfter,
+        tokensToDeleteForTarget: Math.max(0, stats.tokensAfter - targetTokensAfter),
+        ...(contextWindow !== undefined
+            ? {
+                contextWindowBeforePercent: percentOf(stats.tokensBefore, contextWindow),
+                contextWindowAfterPercent: percentOf(stats.tokensAfter, contextWindow),
+            }
+            : {}),
+        callCount,
+    };
+    return details;
+}
+function contextCompactionTargetMet(result, parameters) {
+    return (result !== undefined &&
+        result.deletedTargets.length > 0 &&
+        result.stats.percentReduction >= contextCompactionTargetReductionPercent(parameters));
+}
+function contextCompactionProgressKey(result) {
+    if (!result)
+        return "none:0";
+    return `${result.deletedTargets.length}:${result.stats.percentReduction}:${result.stats.tokensAfter}`;
+}
+function contextCompactionProgressPercent(result) {
+    return result?.stats.percentReduction ?? 0;
+}
+function createContextCompactionTargetNudgeMessage(result, parameters) {
+    const currentReductionPercent = contextCompactionProgressPercent(result);
+    const targetLabel = contextCompactionTargetLabel(parameters);
+    const tokensToDelete = result
+        ? createContextCompactionBudgetDetails(result.stats, 0, undefined, parameters).tokensToDeleteForTarget
+        : undefined;
+    const remainingText = tokensToDelete !== undefined ? ` Delete about ${tokensToDelete} more token(s) if safe candidates exist.` : "";
+    return {
+        role: "user",
+        content: [
+            {
+                type: "text",
+                text: `The strict ${targetLabel} context-reduction requirement is not met yet; current validated reduction is ${currentReductionPercent}%.${remainingText} Continue removing low-value message entries or message content blocks using ${CONTEXT_DELETE_TOOL_NAME} or ${CONTEXT_GREP_DELETE_TOOL_NAME}. Use the focus query ${JSON.stringify(parameters.query)} to preserve relevant context. Call ${CONTEXT_COMPACTION_BUDGET_TOOL_NAME} to verify progress, and do not provide a final answer until the validated reduction is at least ${targetLabel}.`,
+            },
+        ],
+        timestamp: Date.now(),
+    };
+}
 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}`);
@@ -809,6 +1057,69 @@ function addGrepCandidate(candidates, matches, seenTargets, candidate, match) {
     candidates.push(candidate);
     matches.push(match);
 }
+function pushProtectedGrepSkip(skipped, match) {
+    skipped.push({
+        entryId: match.entryId,
+        target: match.target,
+        ...(match.blockIndex === undefined ? {} : { blockIndex: match.blockIndex }),
+        reason: match.target === "content_block" ? "protected_block" : "protected_entry",
+        text: match.text,
+    });
+}
+function filterProtectedGrepCandidates(candidates, matches, currentTargets, transcript, skipped) {
+    const eligibleCandidates = [];
+    const eligibleMatches = [];
+    for (let index = 0; index < candidates.length; index++) {
+        const candidate = candidates[index];
+        const match = matches[index];
+        if (!candidate || !match)
+            continue;
+        try {
+            const mergedTargets = mergeContextDeletionTargets(currentTargets, [candidate]);
+            validateContextDeletionRequest(deletionRequestFromTargets(mergedTargets), transcript);
+            eligibleCandidates.push(candidate);
+            eligibleMatches.push(match);
+        }
+        catch (error) {
+            const message = formatErrorMessage(error);
+            if (isProtectedContextDeletionErrorMessage(message)) {
+                pushProtectedGrepSkip(skipped, match);
+                continue;
+            }
+            eligibleCandidates.push(candidate);
+            eligibleMatches.push(match);
+        }
+    }
+    // Some latest-assistant thinking violations only become visible after a grep batch also
+    // deletes newer assistant entries. Classify the newly-unsafe grep candidates as
+    // protected/skipped before maxMatches, expectedMatchCount, stats, or removals are computed.
+    let changed = true;
+    while (changed) {
+        changed = false;
+        const mergedTargets = mergeContextDeletionTargets(currentTargets, eligibleCandidates);
+        const violation = findLatestAssistantThinkingDeletionViolation(transcript, mergedTargets);
+        if (!violation)
+            continue;
+        const violationKey = targetKey(violation);
+        let violationIndex = eligibleCandidates.findIndex((candidate) => targetKey(candidate) === violationKey);
+        if (violationIndex < 0) {
+            violationIndex = eligibleCandidates.findIndex((_candidate, candidateIndex) => {
+                const remainingCandidates = eligibleCandidates.filter((_candidateToKeep, index) => index !== candidateIndex);
+                const remainingTargets = mergeContextDeletionTargets(currentTargets, remainingCandidates);
+                const remainingViolation = findLatestAssistantThinkingDeletionViolation(transcript, remainingTargets);
+                return !remainingViolation || targetKey(remainingViolation) !== violationKey;
+            });
+        }
+        if (violationIndex < 0)
+            continue;
+        const [skippedMatch] = eligibleMatches.splice(violationIndex, 1);
+        eligibleCandidates.splice(violationIndex, 1);
+        if (skippedMatch)
+            pushProtectedGrepSkip(skipped, skippedMatch);
+        changed = true;
+    }
+    return { candidates: eligibleCandidates, matches: eligibleMatches };
+}
 function copyDeletionTarget(target) {
     return target.kind === "entry"
         ? { kind: "entry", entryId: target.entryId }
@@ -829,30 +1140,36 @@ class ContextDeletionMemoryStore {
                 entryId: entry.entryId,
                 role: entry.role,
                 protected: entry.protected,
+                hasAssistantThinkingBlocks: assistantEntryHasThinkingContentBlock(entry),
                 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.contentBlocks = transcript.entries.flatMap((entry, entryPosition) => {
+            const hasAssistantThinkingBlocks = assistantEntryHasThinkingContentBlock(entry);
+            return 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,
+                    role: entry.role,
+                    type: block.type,
+                    protected: block.protected,
+                    hasAssistantThinkingBlocks,
+                    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);
@@ -879,6 +1196,7 @@ class ContextDeletionMemoryStore {
             entry_id: entry.entryId,
             text: entry.text,
             is_protected: entry.protected ? 1 : 0,
+            has_assistant_thinking_blocks: entry.hasAssistantThinkingBlocks ? 1 : 0,
         }));
     }
     listContentBlocksForGrep() {
@@ -887,10 +1205,13 @@ class ContextDeletionMemoryStore {
             .map((block) => ({
             entry_id: block.entryId,
             block_index: block.blockIndex,
+            role: block.role,
+            type: block.type,
             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,
+            has_assistant_thinking_blocks: block.hasAssistantThinkingBlocks ? 1 : 0,
         }));
     }
     getEntryForRead(entryId) {
@@ -901,6 +1222,7 @@ class ContextDeletionMemoryStore {
             entry_id: entry.entryId,
             role: entry.role,
             is_protected: entry.protected ? 1 : 0,
+            has_assistant_thinking_blocks: entry.hasAssistantThinkingBlocks ? 1 : 0,
             token_estimate: entry.tokenEstimate,
             text: entry.text,
         };
@@ -912,12 +1234,14 @@ class ContextDeletionMemoryStore {
         return {
             entry_id: block.entryId,
             block_index: block.blockIndex,
+            role: block.role,
             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,
+            has_assistant_thinking_blocks: block.hasAssistantThinkingBlocks ? 1 : 0,
         };
     }
     getGrepScanTextLength(target) {
@@ -956,8 +1280,10 @@ class ContextDeletionMemoryStore {
 function createContextDeletionStore(transcript) {
     return new ContextDeletionMemoryStore(transcript);
 }
-export function createContextDeletionTool(transcript, options = {}) {
-    const mode = options.mode ?? "standard";
+export function createContextDeletionTool(inputTranscript, options = {}) {
+    const contextWindow = finitePositiveNumber(options.contextWindow);
+    const parameters = normalizeContextCompactionParameters({ ...getTranscriptCompactionParameters(inputTranscript), ...options }, inputTranscript.parameters?.query ?? CONTEXT_COMPACTION_AUTO_QUERY);
+    const transcript = { ...inputTranscript, parameters };
     const store = createContextDeletionStore(transcript);
     let validatedResult;
     function readTargets() {
@@ -965,7 +1291,7 @@ export function createContextDeletionTool(transcript, options = {}) {
     }
     function applyValidatedTargets(additionalTargets) {
         const mergedTargets = mergeContextDeletionTargets(readTargets(), additionalTargets);
-        validatedResult = validateContextDeletionRequest(deletionRequestFromTargets(mergedTargets), transcript, { mode });
+        validatedResult = validateContextDeletionRequest(deletionRequestFromTargets(mergedTargets), transcript);
         store.replaceTargets(validatedResult.deletedTargets);
         return validatedResult;
     }
@@ -973,7 +1299,7 @@ export function createContextDeletionTool(transcript, options = {}) {
         return validatedResult?.stats ?? computeContextCompactionStats(transcript, readTargets());
     }
     function canDeleteProtectedTarget(target) {
-        return canDeleteProtectedTargetInMode(transcript, target, mode);
+        return canDeleteTarget(transcript, target);
     }
     const tool = {
         ...CONTEXT_DELETE_TOOL,
@@ -984,7 +1310,7 @@ export function createContextDeletionTool(transcript, options = {}) {
                 const callCount = store.incrementCallCount();
                 try {
                     const incomingRequest = contextDeletionRequestFromObject(params, `${CONTEXT_DELETE_TOOL_NAME} arguments`);
-                    const incomingValidated = validateContextDeletionRequest(incomingRequest, transcript, { mode });
+                    const incomingValidated = validateContextDeletionRequest(incomingRequest, transcript);
                     const applied = applyValidatedTargets(incomingValidated.deletedTargets);
                     store.clearLastError();
                     const deletedTargets = readTargets();
@@ -1027,6 +1353,7 @@ export function createContextDeletionTool(transcript, options = {}) {
                 const maxMatches = params.maxMatches ?? CONTEXT_GREP_DELETE_DEFAULT_MAX_MATCHES;
                 const candidates = [];
                 const matches = [];
+                let reportedMatches = matches;
                 const skipped = [];
                 const seenTargets = new Set();
                 try {
@@ -1035,11 +1362,16 @@ export function createContextDeletionTool(transcript, options = {}) {
                     }
                     const matcher = createGrepMatcher(pattern, regex, caseSensitive);
                     const currentTargets = readTargets();
+                    const recentEntryIds = getRecentContextEntryIds(transcript);
                     if (target === "entry") {
                         for (const entry of store.listEntriesForGrep()) {
                             if (!matcher.test(entry.text))
                                 continue;
                             const candidate = { kind: "entry", entryId: entry.entry_id };
+                            if (recentEntryIds.has(candidate.entryId)) {
+                                skipped.push({ entryId: entry.entry_id, target, reason: "protected_entry", text: entry.text });
+                                continue;
+                            }
                             if (entry.is_protected === 1 && !canDeleteProtectedTarget(candidate)) {
                                 skipped.push({ entryId: entry.entry_id, target, reason: "protected_entry", text: entry.text });
                                 continue;
@@ -1062,6 +1394,16 @@ export function createContextDeletionTool(transcript, options = {}) {
                             const candidate = block.block_count <= 1
                                 ? { kind: "entry", entryId: block.entry_id }
                                 : { kind: "content_block", entryId: block.entry_id, blockIndex: block.block_index };
+                            if (recentEntryIds.has(candidate.entryId)) {
+                                skipped.push({
+                                    entryId: block.entry_id,
+                                    target: candidate.kind,
+                                    ...(candidate.kind === "content_block" ? { blockIndex: candidate.blockIndex } : {}),
+                                    reason: "protected_entry",
+                                    text: block.text,
+                                });
+                                continue;
+                            }
                             if (block.entry_protected === 1 && !canDeleteProtectedTarget(candidate)) {
                                 skipped.push({
                                     entryId: block.entry_id,
@@ -1100,15 +1442,17 @@ export function createContextDeletionTool(transcript, options = {}) {
                             });
                         }
                     }
+                    const eligible = filterProtectedGrepCandidates(candidates, matches, currentTargets, transcript, skipped);
+                    reportedMatches = eligible.matches;
                     let applied;
-                    if (params.expectedMatchCount !== undefined && candidates.length !== params.expectedMatchCount) {
+                    if (params.expectedMatchCount !== undefined && eligible.candidates.length !== params.expectedMatchCount) {
                         skipped.push({ reason: "expected_match_count_mismatch" });
                     }
-                    else if (candidates.length > maxMatches) {
+                    else if (eligible.candidates.length > maxMatches) {
                         skipped.push({ reason: "max_matches_exceeded" });
                     }
-                    else if (candidates.length > 0) {
-                        applied = applyValidatedTargets(candidates);
+                    else if (eligible.candidates.length > 0) {
+                        applied = applyValidatedTargets(eligible.candidates);
                     }
                     store.clearLastError();
                     const deletedTargets = readTargets();
@@ -1117,13 +1461,13 @@ export function createContextDeletionTool(transcript, options = {}) {
                         regex,
                         caseSensitive,
                         target,
-                        matches,
+                        matches: eligible.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}.`;
+                    const text = `Matched ${eligible.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) {
@@ -1135,7 +1479,7 @@ export function createContextDeletionTool(transcript, options = {}) {
                         regex,
                         caseSensitive,
                         target,
-                        matches,
+                        matches: reportedMatches,
                         skipped,
                         deletedTargets,
                         stats: currentStats(),
@@ -1290,53 +1634,38 @@ export function createContextDeletionTool(transcript, options = {}) {
             });
         },
     };
+    const budgetTool = {
+        ...CONTEXT_COMPACTION_BUDGET_TOOL,
+        label: "context compaction budget",
+        executionMode: "parallel",
+        async execute(_toolCallId) {
+            return store.transaction(() => {
+                const callCount = store.incrementCallCount();
+                store.clearLastError();
+                const details = createContextCompactionBudgetDetails(currentStats(), callCount, contextWindow, parameters);
+                const windowText = details.contextWindowBeforePercent !== undefined
+                    ? ` Context window fullness: ${details.contextWindowBeforePercent}% before selected deletions, ${details.contextWindowAfterPercent}% after selected deletions.`
+                    : " Context window size is unknown for this model, so fullness percentages are unavailable.";
+                const targetText = details.tokensToDeleteForTarget > 0
+                    ? ` Delete about ${details.tokensToDeleteForTarget} more token(s) to reach the ${details.targetReductionPercent}% reduction target.`
+                    : ` The selected deletions meet or exceed the ${details.targetReductionPercent}% reduction target.`;
+                return createContextDeletionToolResult(`Current selected deletions reduce context by ${details.currentReductionPercent}% (${details.deletedTokens} token(s)); tokens after selected deletions: ${details.currentTokensAfter}/${details.tokensBefore}.${windowText}${targetText} Keep maximizing useful retained context while aggressively removing low-value blocks.`, details);
+            });
+        },
+    };
     return {
         tool,
         grepTool,
         searchTool,
         readEntryTool,
-        tools: [tool, grepTool, searchTool, readEntryTool],
+        budgetTool,
+        tools: [tool, grepTool, searchTool, readEntryTool, budgetTool],
         getDeletionRequest: () => deletionRequestFromTargets(readTargets()),
         getValidatedResult: () => validatedResult,
         getLastError: () => store.getLastError(),
         getCallCount: () => store.getCallCount(),
     };
 }
-export function parseContextDeletionRequest(text) {
-    const stripped = stripJsonFence(text);
-    let parsed;
-    try {
-        parsed = JSON.parse(stripped);
-    }
-    catch (error) {
-        throw new Error(`Failed to parse context deletion request JSON: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return contextDeletionRequestFromObject(parsed, "Context deletion request JSON");
-}
-function isContextDeleteToolCall(content) {
-    return content.type === "toolCall" && content.name === CONTEXT_DELETE_TOOL_NAME;
-}
-function textContentFromResponse(response) {
-    return response.content
-        .filter((content) => content.type === "text")
-        .map((content) => content.text)
-        .join("\n");
-}
-export function parseContextDeletionResponse(response) {
-    const toolCalls = response.content.filter(isContextDeleteToolCall);
-    if (toolCalls.length > 1) {
-        throw new Error(`Context compaction assistant called ${CONTEXT_DELETE_TOOL_NAME} more than once`);
-    }
-    const toolCall = toolCalls[0];
-    if (toolCall) {
-        return contextDeletionRequestFromObject(toolCall.arguments, `${CONTEXT_DELETE_TOOL_NAME} arguments`);
-    }
-    const textContent = textContentFromResponse(response);
-    if (textContent.trim().length === 0) {
-        throw new Error(`Context compaction assistant did not call ${CONTEXT_DELETE_TOOL_NAME}`);
-    }
-    return parseContextDeletionRequest(textContent);
-}
 function truncateForPrompt(text, maxChars) {
     if (text.length <= maxChars)
         return text;
@@ -1420,14 +1749,16 @@ function contextCompactionTranscriptManifest(transcript, transcriptFilePath) {
         })),
     };
 }
-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. Evict in priority order: remove old reasoning traces first, then 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>`;
+function contextCompactionParametersPrompt(parameters) {
+    return `\n<compaction-parameters>\n${JSON.stringify({
+        compression_ratio: parameters.compression_ratio,
+        preserve_recent: parameters.preserve_recent,
+        query: parameters.query,
+        target_reduction_percent: contextCompactionTargetReductionPercent(parameters),
+    }, null, 2)}\n</compaction-parameters>`;
 }
-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, transcriptFilePath = "<transcript file will be written during context compaction>", parameters = getTranscriptCompactionParameters(transcript)) {
+    return `${contextCompactionFixedPrompt(parameters)}${contextCompactionParametersPrompt(parameters)}\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 {
@@ -1461,7 +1792,8 @@ function createContextCompactionStopStream(model, text) {
 function isContextCompactionOverflowError(model, errorMessage) {
     return isContextOverflow(createContextCompactionAssistantMessage(model, [], "error", errorMessage), model.contextWindow);
 }
-async function runContextDeletionAssistant(transcript, model, apiKey, headers, signal, thinkingLevel = "off", mode = "standard") {
+async function runContextDeletionAssistant(inputTranscript, model, apiKey, headers, signal, thinkingLevel = "off", parameters = getTranscriptCompactionParameters(inputTranscript)) {
+    const transcript = { ...inputTranscript, parameters };
     const maxTokens = model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY;
     if (signal?.aborted) {
         throw new Error("Context compaction failed: Request was aborted");
@@ -1469,11 +1801,10 @@ async function runContextDeletionAssistant(transcript, model, apiKey, headers, s
     const transcriptFile = writeContextCompactionTranscriptFile(transcript);
     const promptMessage = {
         role: "user",
-        content: [{ type: "text", text: buildContextCompactionPrompt(transcript, transcriptFile.path, mode) }],
+        content: [{ type: "text", text: buildContextCompactionPrompt(transcript, transcriptFile.path, parameters) }],
         timestamp: Date.now(),
     };
-    const deletionTool = createContextDeletionTool(transcript, { mode });
-    let compactionTurnCount = 0;
+    const deletionTool = createContextDeletionTool(transcript, { contextWindow: model.contextWindow, ...parameters });
     const agent = new Agent({
         initialState: {
             systemPrompt: CONTEXT_COMPACTION_SYSTEM_PROMPT,
@@ -1483,9 +1814,9 @@ async function runContextDeletionAssistant(transcript, model, apiKey, headers, s
         },
         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.`);
+            const currentResult = deletionTool.getValidatedResult();
+            if (contextCompactionTargetMet(currentResult, parameters)) {
+                return createContextCompactionStopStream(requestModel, `Reached the strict ${contextCompactionTargetLabel(parameters)} context-reduction requirement (${currentResult.stats.percentReduction}%); using the validated deletions recorded so far.`);
             }
             return streamSimple(requestModel, context, {
                 ...streamOptions,
@@ -1495,6 +1826,25 @@ async function runContextDeletionAssistant(transcript, model, apiKey, headers, s
             });
         },
     });
+    let lastNudgedProgressKey;
+    const unsubscribeNudge = agent.subscribe((event, eventSignal) => {
+        if (event.type !== "turn_end" || signal?.aborted || eventSignal.aborted)
+            return;
+        if (event.message.role !== "assistant")
+            return;
+        if (event.message.stopReason === "error" || event.message.stopReason === "aborted")
+            return;
+        if (event.message.content.some((content) => content.type === "toolCall"))
+            return;
+        const currentResult = deletionTool.getValidatedResult();
+        if (contextCompactionTargetMet(currentResult, parameters))
+            return;
+        const progressKey = contextCompactionProgressKey(currentResult);
+        if (progressKey === lastNudgedProgressKey)
+            return;
+        lastNudgedProgressKey = progressKey;
+        agent.followUp(createContextCompactionTargetNudgeMessage(currentResult, parameters));
+    });
     const abortOnSignal = () => agent.abort();
     signal?.addEventListener("abort", abortOnSignal, { once: true });
     try {
@@ -1502,6 +1852,7 @@ async function runContextDeletionAssistant(transcript, model, apiKey, headers, s
     }
     finally {
         signal?.removeEventListener("abort", abortOnSignal);
+        unsubscribeNudge();
         transcriptFile.cleanup();
     }
     if (signal?.aborted) {
@@ -1517,18 +1868,39 @@ async function runContextDeletionAssistant(transcript, model, apiKey, headers, s
         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})`);
+        throw new Error(`Context compaction did not call any transcript inspection, budget, or deletion tools (${CONTEXT_SEARCH_TRANSCRIPT_TOOL_NAME}, ${CONTEXT_READ_ENTRY_TOOL_NAME}, ${CONTEXT_COMPACTION_BUDGET_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");
+function hasMetContextCompactionTarget(run, parameters) {
+    return contextCompactionTargetMet(run.validatedResult, parameters);
+}
+function formatContextCompactionTargetFailureMessage(attempts, parameters) {
+    const targetLabel = contextCompactionTargetLabel(parameters);
+    if (attempts.length === 0) {
+        return `Context compaction did not meet the strict ${targetLabel} reduction requirement`;
     }
-    return validatedResult;
+    const attemptDetails = attempts
+        .map((attempt) => {
+        const reduction = contextCompactionProgressPercent(attempt.validatedResult);
+        const deletionCount = attempt.validatedResult?.deletedTargets.length ?? 0;
+        const errorText = attempt.lastToolError ? `; last deletion tool error: ${attempt.lastToolError}` : "";
+        return `attempt reached ${reduction}% with ${deletionCount} validated deletion target(s)${errorText}`;
+    })
+        .join("; ");
+    return `Context compaction did not meet the strict ${targetLabel} reduction requirement; ${attemptDetails}`;
+}
+export async function contextCompact(preparation, model, apiKey, headers, signal, thinkingLevel = "off") {
+    const parameters = normalizeContextCompactionParameters(preparation.parameters ?? preparation.transcript.parameters, preparation.parameters?.query ?? preparation.transcript.parameters?.query ?? CONTEXT_COMPACTION_AUTO_QUERY);
+    const transcript = { ...preparation.transcript, parameters };
+    const attempts = [];
+    const standardRun = await runContextDeletionAssistant(transcript, model, apiKey, headers, signal, thinkingLevel, parameters);
+    if (hasMetContextCompactionTarget(standardRun, parameters))
+        return standardRun.validatedResult;
+    attempts.push({ ...standardRun });
+    throw new Error(formatContextCompactionTargetFailureMessage(attempts, parameters));
 }
 //# sourceMappingURL=context-compaction.js.map