🤖 refactor: move compaction logic to backend

Move history compaction handling from WorkspaceStore to agentSession to centralize server-side operations.

Backend changes:
- Added handleCompactionCompletion() to detect and handle compaction stream-end events
- Added handleCompactionAbort() to handle Ctrl+A (accept early with [truncated]) and Ctrl+C (cancel) flows
- Added performCompaction() to atomically replace chat history with summary message
- Added processedCompactionRequestIds Set to dedupe repeated compaction events
- Implemented abandonPartial flag flow from IPC through to StreamAbortEvent
- Extract truncated message content from history instead of partialService

Frontend changes:
- Removed compaction handlers from WorkspaceStore
- Simplified cancelCompaction() to just call interruptStream with abandonPartial flag
- Fixed Ctrl+A keybind to pass abandonPartial: false for early accept

Shared changes:
- Updated StreamAbortEvent to include abandonPartial flag
- historyService.clearHistory() now returns deleted sequence numbers
- Created calculateCumulativeUsage() utility to extract and sum usage from messages

Author: ethanndickson

src/browser/stores/WorkspaceStore.ts

@@ -1,6 +1,5 @@
 import assert from "@/common/utils/assert";
 import type { MuxMessage, DisplayedMessage, QueuedMessage } from "@/common/types/message";
-import { createMuxMessage } from "@/common/types/message";
 import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
 import type { WorkspaceChatMessage } from "@/common/types/ipc";
 import type { TodoItem } from "@/common/types/tools";
@@ -18,17 +17,11 @@ import {
   isRestoreToInput,
 } from "@/common/types/ipc";
 import { MapStore } from "./MapStore";
-import { createDisplayUsage } from "@/common/utils/tokens/displayUsage";
+import { getUsageHistory } from "@/common/utils/tokens/displayUsage";
 import { WorkspaceConsumerManager } from "./WorkspaceConsumerManager";
 import type { ChatUsageDisplay } from "@/common/utils/tokens/usageAggregator";
-import { sumUsageHistory } from "@/common/utils/tokens/usageAggregator";
 import type { TokenConsumer } from "@/common/types/chatStats";
 import type { LanguageModelV2Usage } from "@ai-sdk/provider";
-import { getCancelledCompactionKey } from "@/common/constants/storage";
-import {
-  isCompactingStream,
-  findCompactionRequestMessage,
-} from "@/common/utils/compaction/handler";
 import { createFreshRetryState } from "@/browser/utils/messages/retryState";
 
 export interface WorkspaceState {
@@ -149,10 +142,6 @@ export class WorkspaceStore {
       aggregator.handleStreamEnd(data as never);
       aggregator.clearTokenState((data as { messageId: string }).messageId);
 
-      if (this.handleCompactionCompletion(workspaceId, aggregator, data)) {
-        return;
-      }
-
       // Reset retry state on successful stream completion
       updatePersistedState(getRetryStateKey(workspaceId), createFreshRetryState());
 
@@ -164,10 +153,6 @@ export class WorkspaceStore {
       aggregator.clearTokenState((data as { messageId: string }).messageId);
       aggregator.handleStreamAbort(data as never);
 
-      if (this.handleCompactionAbort(workspaceId, aggregator, data)) {
-        return;
-      }
-
       this.states.bump(workspaceId);
       this.dispatchResumeCheck(workspaceId);
       this.finalizeUsageStats(workspaceId, (data as { metadata?: never }).metadata);
@@ -446,42 +431,8 @@ export class WorkspaceStore {
       const aggregator = this.assertGet(workspaceId);
 
       const messages = aggregator.getAllMessages();
-
-      // Extract usage from assistant messages
-      const usageHistory: ChatUsageDisplay[] = [];
-      let cumulativeHistorical: ChatUsageDisplay | undefined;
-
-      for (const msg of messages) {
-        if (msg.role === "assistant") {
-          // Check for historical usage from compaction summaries
-          // This preserves costs from messages deleted during compaction
-          if (msg.metadata?.historicalUsage) {
-            cumulativeHistorical = msg.metadata.historicalUsage;
-          }
-
-          // Extract current message's usage
-          if (msg.metadata?.usage) {
-            // Use the model from this specific message (not global)
-            const model = msg.metadata.model ?? aggregator.getCurrentModel() ?? "unknown";
-
-            const usage = createDisplayUsage(
-              msg.metadata.usage,
-              model,
-              msg.metadata.providerMetadata
-            );
-
-            if (usage) {
-              usageHistory.push(usage);
-            }
-          }
-        }
-      }
-
-      // If we have historical usage from a compaction, prepend it to history
-      // This ensures costs from pre-compaction messages are included in totals
-      if (cumulativeHistorical) {
-        usageHistory.unshift(cumulativeHistorical);
-      }
+      const model = aggregator.getCurrentModel();
+      const usageHistory = getUsageHistory(messages, model);
 
       // Calculate total from usage history (now includes historical)
       const totalTokens = usageHistory.reduce(
@@ -544,178 +495,6 @@ export class WorkspaceStore {
     return this.consumersStore.subscribeKey(workspaceId, listener);
   }
 
-  /**
-   * Handle compact_summary tool completion.
-   * Returns true if compaction was handled (caller should early return).
-   */
-  // Track processed compaction-request IDs to dedupe performCompaction across duplicated events
-  private processedCompactionRequestIds = new Set<string>();
-
-  private handleCompactionCompletion(
-    workspaceId: string,
-    aggregator: StreamingMessageAggregator,
-    data: WorkspaceChatMessage
-  ): boolean {
-    // Type guard: only StreamEndEvent has messageId
-    if (!("messageId" in data)) return false;
-
-    // Check if this was a compaction stream
-    if (!isCompactingStream(aggregator)) {
-      return false;
-    }
-
-    // Extract the compaction-request message to identify this compaction run
-    const compactionRequestMsg = findCompactionRequestMessage(aggregator);
-    if (!compactionRequestMsg) {
-      return false;
-    }
-
-    // Dedupe: If we've already processed this compaction-request, skip re-running
-    if (this.processedCompactionRequestIds.has(compactionRequestMsg.id)) {
-      return true; // Already handled compaction for this request
-    }
-
-    // Extract the summary text from the assistant's response
-    const summary = aggregator.getCompactionSummary(data.messageId);
-    if (!summary) {
-      console.warn("[WorkspaceStore] Compaction completed but no summary text found");
-      return false;
-    }
-
-    // Mark this compaction-request as processed before performing compaction
-    this.processedCompactionRequestIds.add(compactionRequestMsg.id);
-
-    this.performCompaction(workspaceId, aggregator, data, summary);
-    return true;
-  }
-
-  /**
-   * Handle interruption of a compaction stream (StreamAbortEvent).
-   *
-   * Two distinct flows trigger this:
-   * - **Ctrl+A (accept early)**: Perform compaction with [truncated] sentinel
-   * - **Ctrl+C (cancel)**: Skip compaction, let cancelCompaction handle cleanup
-   *
-   * Uses localStorage to distinguish flows:
-   * - Checks for cancellation marker in localStorage
-   * - Verifies messageId matches for freshness
-   * - Reload-safe: localStorage persists across page reloads
-   */
-  private handleCompactionAbort(
-    workspaceId: string,
-    aggregator: StreamingMessageAggregator,
-    data: WorkspaceChatMessage
-  ): boolean {
-    // Type guard: only StreamAbortEvent has messageId
-    if (!("messageId" in data)) return false;
-
-    // Check if this was a compaction stream
-    if (!isCompactingStream(aggregator)) {
-      return false;
-    }
-
-    // Get the compaction request message for ID verification
-    const compactionRequestMsg = findCompactionRequestMessage(aggregator);
-    if (!compactionRequestMsg) {
-      return false;
-    }
-
-    // Ctrl+C flow: Check localStorage for cancellation marker
-    // Verify compaction-request user message ID matches (stable across retries)
-    const storageKey = getCancelledCompactionKey(workspaceId);
-    const cancelData = localStorage.getItem(storageKey);
-    if (cancelData) {
-      try {
-        const parsed = JSON.parse(cancelData) as { compactionRequestId: string; timestamp: number };
-        if (parsed.compactionRequestId === compactionRequestMsg.id) {
-          // This is a cancelled compaction - clean up marker and skip compaction
-          localStorage.removeItem(storageKey);
-          return false; // Skip compaction, cancelCompaction() handles cleanup
-        }
-      } catch (error) {
-        console.error("[WorkspaceStore] Failed to parse cancellation data:", error);
-      }
-      // If compactionRequestId doesn't match or parse failed, clean up stale data
-      localStorage.removeItem(storageKey);
-    }
-
-    // Ctrl+A flow: Accept early with [truncated] sentinel
-    const partialSummary = aggregator.getCompactionSummary(data.messageId);
-    if (!partialSummary) {
-      console.warn("[WorkspaceStore] Compaction aborted but no partial summary found");
-      return false;
-    }
-
-    // Append [truncated] sentinel on new line to indicate incomplete summary
-    const truncatedSummary = partialSummary.trim() + "\n\n[truncated]";
-
-    this.performCompaction(workspaceId, aggregator, data, truncatedSummary);
-    return true;
-  }
-
-  /**
-   * Perform history compaction by replacing chat history with summary message.
-   * Type-safe: only called when we've verified data is a StreamEndEvent.
-   */
-  private performCompaction(
-    workspaceId: string,
-    aggregator: StreamingMessageAggregator,
-    data: WorkspaceChatMessage,
-    summary: string
-  ): void {
-    // Extract metadata safely with type guard
-    const metadata = "metadata" in data ? data.metadata : undefined;
-
-    // Calculate cumulative historical usage before replacing history
-    // This preserves costs from all messages that are about to be deleted
-    const currentUsage = this.getWorkspaceUsage(workspaceId);
-    const historicalUsage =
-      currentUsage.usageHistory.length > 0 ? sumUsageHistory(currentUsage.usageHistory) : undefined;
-
-    // Extract continueMessage from compaction-request before history gets replaced
-    const compactRequestMsg = findCompactionRequestMessage(aggregator);
-    const muxMeta = compactRequestMsg?.metadata?.muxMetadata;
-    const continueMessage =
-      muxMeta?.type === "compaction-request" ? muxMeta.parsed.continueMessage : undefined;
-
-    const summaryMessage = createMuxMessage(
-      `summary-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
-      "assistant",
-      summary,
-      {
-        timestamp: Date.now(),
-        compacted: true,
-        model: aggregator.getCurrentModel(),
-        usage: metadata?.usage,
-        historicalUsage, // Store cumulative costs from all pre-compaction messages
-        providerMetadata:
-          metadata && "providerMetadata" in metadata
-            ? (metadata.providerMetadata as Record<string, unknown> | undefined)
-            : undefined,
-        duration: metadata?.duration,
-        systemMessageTokens:
-          metadata && "systemMessageTokens" in metadata
-            ? (metadata.systemMessageTokens as number | undefined)
-            : undefined,
-        // Store continueMessage in summary so it survives history replacement
-        muxMetadata: continueMessage
-          ? { type: "compaction-result", continueMessage, requestId: compactRequestMsg?.id }
-          : { type: "normal" },
-      }
-    );
-
-    void (async () => {
-      try {
-        await window.api.workspace.replaceChatHistory(workspaceId, summaryMessage);
-      } catch (error) {
-        console.error("[WorkspaceStore] Failed to replace history:", error);
-      } finally {
-        this.states.bump(workspaceId);
-        this.checkAndBumpRecencyIfChanged();
-      }
-    })();
-  }
-
   /**
    * Update usage and schedule consumer calculation after stream completion.
    *

src/common/types/stream.ts

@@ -56,6 +56,7 @@ export interface StreamAbortEvent {
     usage?: LanguageModelV2Usage;
     duration?: number;
   };
+  abandonPartial?: boolean;
 }
 
 export interface ErrorEvent {

src/common/utils/compaction/handler.ts

@@ -12,7 +12,6 @@
  */
 
 import type { StreamingMessageAggregator } from "@/browser/utils/messages/StreamingMessageAggregator";
-import { getCancelledCompactionKey } from "@/common/constants/storage";
 
 /**
  * Check if the workspace is currently in a compaction stream
@@ -55,19 +54,14 @@ export function getCompactionCommand(aggregator: StreamingMessageAggregator): st
  * Cancel compaction (Ctrl+C flow)
  *
  * Aborts the compaction stream and puts user in edit mode for compaction-request:
- * - Interrupts stream with abandonPartial flag (deletes partial, doesn't commit)
- * - Skips compaction (via localStorage marker checked by handleCompactionAbort)
+ * - Interrupts stream with abandonPartial=true flag (backend skips compaction)
  * - Enters edit mode on compaction-request message
  * - Restores original /compact command to input for re-editing
  * - Leaves compaction-request message in history (can edit or delete it)
  *
  * Flow:
- * 1. Store cancellation marker in localStorage with compactionRequestId for verification
- * 2. Interrupt stream with {abandonPartial: true} - backend deletes partial
- * 3. handleCompactionAbort checks localStorage, verifies compactionRequestId, skips compaction
- * 4. Enter edit mode on compaction-request message with original command
- *
- * Reload-safe: localStorage persists across reloads, compactionRequestId ensures freshness
+ * 1. Interrupt stream with {abandonPartial: true} - backend detects and skips compaction
+ * 2. Enter edit mode on compaction-request message with original command
  */
 export async function cancelCompaction(
   workspaceId: string,
@@ -86,21 +80,8 @@ export async function cancelCompaction(
     return false;
   }
 
-  // CRITICAL: Store cancellation marker in localStorage BEFORE interrupt
-  // Use the compaction-request user message ID (stable across retries)
-  // This persists across reloads and verifies we're cancelling the right compaction
-  const storageKey = getCancelledCompactionKey(workspaceId);
-  localStorage.setItem(
-    storageKey,
-    JSON.stringify({
-      compactionRequestId: compactionRequestMsg.id,
-      timestamp: Date.now(),
-    })
-  );
-
   // Interrupt stream with abandonPartial flag
-  // This tells backend to DELETE the partial instead of committing it
-  // Result: history ends with the compaction-request user message (which is fine - just a user message)
+  // Backend detects this and skips compaction (Ctrl+C flow)
   await window.api.workspace.interruptStream(workspaceId, { abandonPartial: true });
 
   // Enter edit mode on the compaction-request message with original command

src/common/utils/tokens/displayUsage.ts

@@ -8,6 +8,7 @@
 import type { LanguageModelV2Usage } from "@ai-sdk/provider";
 import { getModelStats } from "./modelStats";
 import type { ChatUsageDisplay } from "./usageAggregator";
+import type { MuxMessage } from "@/common/types/message";
 
 /**
  * Create a display-friendly usage object from AI SDK usage
@@ -90,3 +91,42 @@ export function createDisplayUsage(
     model, // Include model for display purposes
   };
 }
+
+export function getUsageHistory(
+  messages: MuxMessage[],
+  fallbackModel?: string
+): ChatUsageDisplay[] {
+  // Extract usage from assistant messages
+  const usageHistory: ChatUsageDisplay[] = [];
+  let cumulativeHistorical: ChatUsageDisplay | undefined;
+
+  for (const msg of messages) {
+    if (msg.role === "assistant") {
+      // Check for historical usage from compaction summaries
+      // This preserves costs from messages deleted during compaction
+      if (msg.metadata?.historicalUsage) {
+        cumulativeHistorical = msg.metadata.historicalUsage;
+      }
+
+      // Extract current message's usage
+      if (msg.metadata?.usage) {
+        // Use the model from this specific message (not global)
+        const model = msg.metadata.model ?? fallbackModel ?? "unknown";
+
+        const usage = createDisplayUsage(msg.metadata.usage, model, msg.metadata.providerMetadata);
+
+        if (usage) {
+          usageHistory.push(usage);
+        }
+      }
+    }
+  }
+
+  // If we have historical usage from a compaction, prepend it to history
+  // This ensures costs from pre-compaction messages are included in totals
+  if (cumulativeHistorical) {
+    usageHistory.unshift(cumulativeHistorical);
+  }
+
+  return usageHistory;
+}