@bastani/atomic 0.8.30-alpha.2 → 0.8.30

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

@@ -150,7 +150,7 @@ What Survives:
 - 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.
+- Old Reasoning decisions: If there is nothing else to remove and the target reduction is not met, you can remove entire stale assistant entries, EXCEPT do not delete individual content blocks from any retained assistant message that contains thinking or redacted_thinking blocks. Thinking-bearing assistant messages are all-or-nothing for replay safety.
 
 <output_format>
 Call the context_delete tool one or more times with deletion targets in this shape:
@@ -525,7 +525,7 @@ function formatProtectedToolDependencyError(transcript, blockedTarget, context)
 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));
+        /latest assistant message|thinking\/redacted_thinking block in (?:the latest|a retained) assistant message/u.test(message));
 }
 function assertNoRecentContextDeletionTargets(transcript, targets) {
     const recentEntryIds = getRecentContextEntryIds(transcript);
@@ -543,6 +543,19 @@ function latestAssistantEntry(transcript, deletedEntryIds = new Set()) {
     }
     return undefined;
 }
+function findAssistantThinkingContentBlockDeletionViolation(transcript, targets) {
+    const deletedEntryIds = getDeletedEntryIds(targets);
+    for (const target of targets) {
+        if (target.kind !== "content_block")
+            continue;
+        if (deletedEntryIds.has(target.entryId))
+            continue;
+        const entry = findTranscriptEntry(transcript, target.entryId);
+        if (entry && assistantEntryHasThinkingContentBlock(entry))
+            return target;
+    }
+    return undefined;
+}
 function findLatestAssistantThinkingDeletionViolation(transcript, targets) {
     const deletedEntryIds = getDeletedEntryIds(targets);
     const latestRetainedAssistant = latestAssistantEntry(transcript, deletedEntryIds);
@@ -565,6 +578,12 @@ function findLatestAssistantThinkingDeletionViolation(transcript, targets) {
     }
     return undefined;
 }
+function assertNoAssistantThinkingContentBlockDeletionTargets(transcript, targets) {
+    const violation = findAssistantThinkingContentBlockDeletionViolation(transcript, targets);
+    if (!violation)
+        return;
+    throw new Error(`Cannot delete content block ${violation.entryId}:${violation.blockIndex} because a thinking/redacted_thinking block in a retained assistant message must remain unmodified; retained assistant messages containing thinking/redacted_thinking content blocks are all-or-nothing`);
+}
 function assertNoLatestAssistantThinkingDeletionTargets(transcript, targets) {
     const violation = findLatestAssistantThinkingDeletionViolation(transcript, targets);
     if (!violation)
@@ -630,6 +649,11 @@ function canonicalizeEntryTargets(transcript, targets, entry) {
     return deleteEntryTarget(targets, entry.entryId);
 }
 function addToolCallDeletion(transcript, targets, entry, callId) {
+    if (assistantEntryHasThinkingContentBlock(entry)) {
+        if (!canDeleteTarget(transcript, { kind: "entry", entryId: entry.entryId }))
+            return false;
+        return deleteEntryTarget(targets, entry.entryId);
+    }
     let changed = false;
     for (const blockIndex of toolCallBlockIndexes(entry, callId)) {
         const target = { kind: "content_block", entryId: entry.entryId, blockIndex };
@@ -700,7 +724,9 @@ function reconcileToolDependencies(transcript, initialTargets) {
                     continue;
                 recordChange(deleteEntryTarget(targets, result.entryId));
                 const callEntryTarget = { kind: "entry", entryId: callEntry.entryId };
-                const callBlockTarget = firstToolCallBlockTarget(callEntry, callId) ?? callEntryTarget;
+                const callBlockTarget = assistantEntryHasThinkingContentBlock(callEntry)
+                    ? callEntryTarget
+                    : firstToolCallBlockTarget(callEntry, callId) ?? callEntryTarget;
                 if (!canDeleteTarget(transcript, callBlockTarget)) {
                     if (isRecentTarget(transcript, callBlockTarget)) {
                         throw new Error(formatRecentContextDeletionError(transcript, callBlockTarget));
@@ -884,6 +910,7 @@ export function validateContextDeletionRequest(request, transcript) {
     // Tool reconciliation can add targets after the per-request checks above, so
     // these post-reconcile assertions remain authoritative.
     assertNoRecentContextDeletionTargets(transcript, reconciledTargets);
+    assertNoAssistantThinkingContentBlockDeletionTargets(transcript, reconciledTargets);
     assertNoLatestAssistantThinkingDeletionTargets(transcript, reconciledTargets);
     const reconciledDeletedEntryIds = getDeletedEntryIds(reconciledTargets);
     for (const target of reconciledTargets) {