@bastani/atomic 0.8.30-alpha.1 → 0.8.30-alpha.3

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 any reasoning steps, EXCEPT thinking or redacted_thinking blocks in the latest assistant message.
+- 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);
@@ -535,29 +535,63 @@ function assertNoRecentContextDeletionTargets(transcript, targets) {
         }
     }
 }
-function latestAssistantEntry(transcript) {
+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")
+        if (entry.role === "assistant" && !deletedEntryIds.has(entry.entryId))
             return entry;
     }
     return undefined;
 }
-function assertNoLatestAssistantThinkingDeletionTargets(transcript, targets) {
-    const latestAssistant = latestAssistantEntry(transcript);
-    if (!latestAssistant || !assistantEntryHasThinkingContentBlock(latestAssistant))
-        return;
+function findAssistantThinkingContentBlockDeletionViolation(transcript, targets) {
+    const deletedEntryIds = getDeletedEntryIds(targets);
     for (const target of targets) {
-        if (target.entryId !== latestAssistant.entryId)
+        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);
+    for (const target of targets) {
         if (target.kind === "entry") {
-            throw new Error(`Cannot delete assistant entry ${target.entryId} because it is the latest assistant message and contains thinking/redacted_thinking content blocks`);
+            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;
         }
-        const block = latestAssistant.contentBlocks.find((candidate) => candidate.blockIndex === target.blockIndex);
-        if (block && isAssistantThinkingBlockType(block.type)) {
-            throw new Error(`Cannot delete content block ${target.entryId}:${target.blockIndex} because it is a thinking/redacted_thinking block in the latest assistant message`);
+        if (latestRetainedAssistant?.entryId === target.entryId &&
+            assistantEntryHasThinkingContentBlock(latestRetainedAssistant)) {
+            return target;
         }
     }
+    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)
+        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))
@@ -615,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 };
@@ -685,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));
@@ -869,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) {
@@ -1075,6 +1117,34 @@ function filterProtectedGrepCandidates(candidates, matches, currentTargets, tran
             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) {