@bastani/atomic 0.8.25 → 0.8.26-alpha.10

package/dist/core/agent-session.js

@@ -22,14 +22,14 @@ import { sleep } from "../utils/sleep.js";
 import { ATOMIC_GUIDE_COMMAND_NAME, ATOMIC_GUIDE_HELP_CHOICES, atomicGuideModeForChoice, getAtomicGuideMessage, isAtomicGuideHelpChoice, normalizeAtomicGuideMode, } from "./atomic-guide-command.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { executeBashWithOperations } from "./bash-executor.js";
-import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
+import { calculateContextTokens, collectEntriesForBranchSummary, contextCompact as runContextCompact, estimateContextTokens, generateBranchSummary, prepareContextCompaction, shouldCompact, } from "./compaction/index.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
-import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-manager.js";
+import { CURRENT_SESSION_VERSION, getLatestCompactionBoundaryEntry } from "./session-manager.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
 import { buildSystemPrompt } from "./system-prompt.js";
 import { createLocalBashOperations } from "./tools/bash.js";
@@ -1476,11 +1476,42 @@ export class AgentSession {
     // Compaction
     // =========================================================================
     /**
-     * Manually compact the session context.
-     * Aborts current agent operation first.
-     * @param customInstructions Optional instructions for the compaction summary
+     * Apply validated logical deletions and rebuild active agent context.
+     * Retained transcript entries/content blocks stay verbatim.
+     */
+    async _applyContextVerbatimCompaction(options) {
+        if (!this.model) {
+            throw new Error(formatNoModelSelectedMessage());
+        }
+        const pathEntries = this.sessionManager.getBranch();
+        const settings = this.settingsManager.getCompactionSettings();
+        const mode = options.mode ?? "standard";
+        const preparation = prepareContextCompaction(pathEntries, settings, { mode });
+        if (!preparation) {
+            return undefined;
+        }
+        const validated = await runContextCompact(preparation, this.model, options.apiKey, options.headers, options.abortController.signal, undefined, mode);
+        if (options.abortController.signal.aborted) {
+            throw new Error("Compaction cancelled");
+        }
+        const backupPath = this.sessionManager.writeBackupSnapshot(options.backupLabel);
+        this.sessionManager.appendContextCompaction(validated.deletedTargets, validated.protectedEntryIds, validated.stats, backupPath);
+        const sessionContext = this.sessionManager.buildSessionContext();
+        this.agent.state.messages = sessionContext.messages;
+        return {
+            ...validated,
+            promptVersion: 1,
+            ...(backupPath ? { backupPath } : {}),
+        };
+    }
+    /**
+     * Manually compact the session context using deletion-only verbatim context compaction.
+     * Aborts current agent operation first. Custom summary instructions are not accepted.
      */
     async compact(customInstructions) {
+        if (customInstructions?.trim()) {
+            throw new Error("Custom compaction instructions are not supported; use /compact without arguments");
+        }
         this._disconnectFromAgent();
         await this.abort();
         this._compactionAbortController = new AbortController();
@@ -1490,84 +1521,23 @@ export class AgentSession {
                 throw new Error(formatNoModelSelectedMessage());
             }
             const { apiKey, headers } = await this._getRequiredRequestAuth(this.model);
-            const pathEntries = this.sessionManager.getBranch();
-            const settings = this.settingsManager.getCompactionSettings();
-            const preparation = prepareCompaction(pathEntries, settings);
-            if (!preparation) {
-                // Check why we can't compact
-                const lastEntry = pathEntries[pathEntries.length - 1];
-                if (lastEntry?.type === "compaction") {
-                    throw new Error("Already compacted");
-                }
+            const result = await this._applyContextVerbatimCompaction({
+                apiKey,
+                headers,
+                abortController: this._compactionAbortController,
+                backupLabel: "compact",
+            });
+            if (!result) {
                 throw new Error("Nothing to compact (session too small)");
             }
-            let extensionCompaction;
-            let fromExtension = false;
-            if (this._extensionRunner.hasHandlers("session_before_compact")) {
-                const result = (await this._extensionRunner.emit({
-                    type: "session_before_compact",
-                    preparation,
-                    branchEntries: pathEntries,
-                    customInstructions,
-                    signal: this._compactionAbortController.signal,
-                }));
-                if (result?.cancel) {
-                    throw new Error("Compaction cancelled");
-                }
-                if (result?.compaction) {
-                    extensionCompaction = result.compaction;
-                    fromExtension = true;
-                }
-            }
-            let summary;
-            let firstKeptEntryId;
-            let tokensBefore;
-            let details;
-            if (extensionCompaction) {
-                // Extension provided compaction content
-                summary = extensionCompaction.summary;
-                firstKeptEntryId = extensionCompaction.firstKeptEntryId;
-                tokensBefore = extensionCompaction.tokensBefore;
-                details = extensionCompaction.details;
-            }
-            else {
-                // Generate compaction result
-                const result = await compact(preparation, this.model, apiKey, headers, customInstructions, this._compactionAbortController.signal, this.thinkingLevel);
-                summary = result.summary;
-                firstKeptEntryId = result.firstKeptEntryId;
-                tokensBefore = result.tokensBefore;
-                details = result.details;
-            }
-            if (this._compactionAbortController.signal.aborted) {
-                throw new Error("Compaction cancelled");
-            }
-            this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension);
-            const newEntries = this.sessionManager.getEntries();
-            const sessionContext = this.sessionManager.buildSessionContext();
-            this.agent.state.messages = sessionContext.messages;
-            // Get the saved compaction entry for the extension event
-            const savedCompactionEntry = newEntries.find((e) => e.type === "compaction" && e.summary === summary);
-            if (this._extensionRunner && savedCompactionEntry) {
-                await this._extensionRunner.emit({
-                    type: "session_compact",
-                    compactionEntry: savedCompactionEntry,
-                    fromExtension,
-                });
-            }
-            const compactionResult = {
-                summary,
-                firstKeptEntryId,
-                tokensBefore,
-                details,
-            };
             this._emit({
                 type: "compaction_end",
                 reason: "manual",
-                result: compactionResult,
+                result,
                 aborted: false,
                 willRetry: false,
             });
-            return compactionResult;
+            return result;
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -1587,6 +1557,56 @@ export class AgentSession {
             this._reconnectToAgent();
         }
     }
+    /**
+     * Manually compact the session context by applying validated logical deletions.
+     * Retained transcript entries/content blocks stay verbatim; no user prompt text is accepted.
+     */
+    async contextCompact() {
+        this._disconnectFromAgent();
+        await this.abort();
+        this._compactionAbortController = new AbortController();
+        this._emit({ type: "context_compaction_start", reason: "manual" });
+        try {
+            if (!this.model) {
+                throw new Error(formatNoModelSelectedMessage());
+            }
+            const { apiKey, headers } = await this._getRequiredRequestAuth(this.model);
+            const result = await this._applyContextVerbatimCompaction({
+                apiKey,
+                headers,
+                abortController: this._compactionAbortController,
+                backupLabel: "context-compact",
+            });
+            if (!result) {
+                throw new Error("Nothing to context-compact (session too small)");
+            }
+            this._emit({
+                type: "context_compaction_end",
+                reason: "manual",
+                result,
+                aborted: false,
+                willRetry: false,
+            });
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const aborted = message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
+            this._emit({
+                type: "context_compaction_end",
+                reason: "manual",
+                result: undefined,
+                aborted,
+                willRetry: false,
+                errorMessage: aborted ? undefined : `Context compaction failed: ${message}`,
+            });
+            throw error;
+        }
+        finally {
+            this._compactionAbortController = undefined;
+            this._reconnectToAgent();
+        }
+    }
     /**
      * Cancel in-progress compaction (manual or auto).
      */
@@ -1606,7 +1626,7 @@ export class AgentSession {
      *
      * Two cases:
      * 1. Overflow: LLM returned context overflow error, remove error message from agent state, compact, auto-retry
-     * 2. Threshold: Context over threshold, compact, NO auto-retry (user continues manually)
+     * 2. Threshold: Context over threshold, compact, resume queued active-turn work if present; otherwise wait for user
      *
      * @param assistantMessage The assistant message to check
      * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
@@ -1627,9 +1647,10 @@ export class AgentSession {
         // Skip compaction checks if this assistant message is older than the latest
         // compaction boundary. This prevents a stale pre-compaction usage/error
         // from retriggering compaction on the first prompt after compaction.
-        const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
-        const assistantIsFromBeforeCompaction = compactionEntry !== null && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime();
-        if (assistantIsFromBeforeCompaction) {
+        const compactionBoundaryEntry = getLatestCompactionBoundaryEntry(this.sessionManager.getBranch());
+        const assistantIsFromBeforeCompactionBoundary = compactionBoundaryEntry !== null &&
+            assistantMessage.timestamp <= new Date(compactionBoundaryEntry.timestamp).getTime();
+        if (assistantIsFromBeforeCompactionBoundary) {
             return;
         }
         // Case 1: Overflow - LLM returned context overflow error
@@ -1668,9 +1689,9 @@ export class AgentSession {
             // have stale usage reflecting the old (larger) context and would falsely
             // trigger compaction right after one just finished.
             const usageMsg = messages[estimate.lastUsageIndex];
-            if (compactionEntry &&
+            if (compactionBoundaryEntry &&
                 usageMsg.role === "assistant" &&
-                usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
+                usageMsg.timestamp <= new Date(compactionBoundaryEntry.timestamp).getTime()) {
                 return;
             }
             contextTokens = estimate.tokens;
@@ -1682,11 +1703,44 @@ export class AgentSession {
             await this._runAutoCompaction("threshold", false);
         }
     }
+    /**
+     * Internal: remove the trailing overflow error from retry context if it is still present.
+     */
+    _dropTrailingOverflowAssistantErrorIfPresent() {
+        const messages = this.agent.state.messages;
+        const lastMsg = messages[messages.length - 1];
+        if (lastMsg?.role === "assistant" && lastMsg.stopReason === "error") {
+            this.agent.state.messages = messages.slice(0, -1);
+        }
+    }
+    /**
+     * Internal: schedule a live post-event continuation probe after compaction_end listeners can flush queues.
+     */
+    _schedulePostAutoCompactionContinuationProbe(reason, willRetry) {
+        setTimeout(() => {
+            if (this.isCompacting || this.isStreaming) {
+                return;
+            }
+            if (reason === "overflow" && willRetry) {
+                this._resumeAfterAutoCompaction();
+                return;
+            }
+            if (!this.agent.hasQueuedMessages()) {
+                return;
+            }
+            this._resumeAfterAutoCompaction();
+        }, 100);
+    }
+    /**
+     * Internal: resume generation after successful auto-compaction only when active work remains.
+     */
+    _resumeAfterAutoCompaction() {
+        this.agent.continue().catch(() => { });
+    }
     /**
      * Internal: Run auto-compaction with events.
      */
     async _runAutoCompaction(reason, willRetry) {
-        const settings = this.settingsManager.getCompactionSettings();
         this._emit({ type: "compaction_start", reason });
         this._autoCompactionAbortController = new AbortController();
         try {
@@ -1711,10 +1765,14 @@ export class AgentSession {
                 });
                 return;
             }
-            const { apiKey, headers } = authResult;
-            const pathEntries = this.sessionManager.getBranch();
-            const preparation = prepareCompaction(pathEntries, settings);
-            if (!preparation) {
+            const result = await this._applyContextVerbatimCompaction({
+                apiKey: authResult.apiKey,
+                headers: authResult.headers,
+                abortController: this._autoCompactionAbortController,
+                backupLabel: reason === "overflow" ? "overflow-auto-compact" : "auto-compact",
+                mode: reason === "overflow" ? "critical_overflow" : "standard",
+            });
+            if (!result) {
                 this._emit({
                     type: "compaction_end",
                     reason,
@@ -1724,109 +1782,26 @@ export class AgentSession {
                 });
                 return;
             }
-            let extensionCompaction;
-            let fromExtension = false;
-            if (this._extensionRunner.hasHandlers("session_before_compact")) {
-                const extensionResult = (await this._extensionRunner.emit({
-                    type: "session_before_compact",
-                    preparation,
-                    branchEntries: pathEntries,
-                    customInstructions: undefined,
-                    signal: this._autoCompactionAbortController.signal,
-                }));
-                if (extensionResult?.cancel) {
-                    this._emit({
-                        type: "compaction_end",
-                        reason,
-                        result: undefined,
-                        aborted: true,
-                        willRetry: false,
-                    });
-                    return;
-                }
-                if (extensionResult?.compaction) {
-                    extensionCompaction = extensionResult.compaction;
-                    fromExtension = true;
-                }
-            }
-            let summary;
-            let firstKeptEntryId;
-            let tokensBefore;
-            let details;
-            if (extensionCompaction) {
-                // Extension provided compaction content
-                summary = extensionCompaction.summary;
-                firstKeptEntryId = extensionCompaction.firstKeptEntryId;
-                tokensBefore = extensionCompaction.tokensBefore;
-                details = extensionCompaction.details;
+            if (reason === "overflow" && willRetry) {
+                this._dropTrailingOverflowAssistantErrorIfPresent();
             }
-            else {
-                // Generate compaction result
-                const compactResult = await compact(preparation, this.model, apiKey, headers, undefined, this._autoCompactionAbortController.signal, this.thinkingLevel);
-                summary = compactResult.summary;
-                firstKeptEntryId = compactResult.firstKeptEntryId;
-                tokensBefore = compactResult.tokensBefore;
-                details = compactResult.details;
-            }
-            if (this._autoCompactionAbortController.signal.aborted) {
-                this._emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: true,
-                    willRetry: false,
-                });
-                return;
-            }
-            this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension);
-            const newEntries = this.sessionManager.getEntries();
-            const sessionContext = this.sessionManager.buildSessionContext();
-            this.agent.state.messages = sessionContext.messages;
-            // Get the saved compaction entry for the extension event
-            const savedCompactionEntry = newEntries.find((e) => e.type === "compaction" && e.summary === summary);
-            if (this._extensionRunner && savedCompactionEntry) {
-                await this._extensionRunner.emit({
-                    type: "session_compact",
-                    compactionEntry: savedCompactionEntry,
-                    fromExtension,
-                });
-            }
-            const result = {
-                summary,
-                firstKeptEntryId,
-                tokensBefore,
-                details,
-            };
             this._emit({ type: "compaction_end", reason, result, aborted: false, willRetry });
-            if (willRetry) {
-                const messages = this.agent.state.messages;
-                const lastMsg = messages[messages.length - 1];
-                if (lastMsg?.role === "assistant" && lastMsg.stopReason === "error") {
-                    this.agent.state.messages = messages.slice(0, -1);
-                }
-                setTimeout(() => {
-                    this.agent.continue().catch(() => { });
-                }, 100);
-            }
-            else if (this.agent.hasQueuedMessages()) {
-                // Auto-compaction can complete while follow-up/steering/custom messages are waiting.
-                // Kick the loop so queued messages are actually delivered.
-                setTimeout(() => {
-                    this.agent.continue().catch(() => { });
-                }, 100);
-            }
+            this._schedulePostAutoCompactionContinuationProbe(reason, willRetry);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
+            const aborted = errorMessage === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
             this._emit({
                 type: "compaction_end",
                 reason,
                 result: undefined,
-                aborted: false,
+                aborted,
                 willRetry: false,
-                errorMessage: reason === "overflow"
-                    ? `Context overflow recovery failed: ${errorMessage}`
-                    : `Auto-compaction failed: ${errorMessage}`,
+                errorMessage: aborted
+                    ? undefined
+                    : reason === "overflow"
+                        ? `Context overflow recovery failed: ${errorMessage}`
+                        : `Auto-compaction failed: ${errorMessage}`,
             });
         }
         finally {
@@ -2633,10 +2608,10 @@ export class AgentSession {
         // We can only trust usage from an assistant that responded after the latest compaction.
         // If no such assistant exists, context token count is unknown until the next LLM response.
         const branchEntries = this.sessionManager.getBranch();
-        const latestCompaction = getLatestCompactionEntry(branchEntries);
-        if (latestCompaction) {
+        const latestCompactionBoundary = getLatestCompactionBoundaryEntry(branchEntries);
+        if (latestCompactionBoundary) {
             // Check if there's a valid assistant usage after the compaction boundary
-            const compactionIndex = branchEntries.lastIndexOf(latestCompaction);
+            const compactionIndex = branchEntries.lastIndexOf(latestCompactionBoundary);
             let hasPostCompactionUsage = false;
             for (let i = branchEntries.length - 1; i > compactionIndex; i--) {
                 const entry = branchEntries[i];