refactor: use message queue for compact continue messages

Previously, compact continue messages were handled by a frontend hook
(useAutoCompactContinue) that watched for completed compactions and
then sent the continue message. This introduced complexity, race
conditions, and required tracking processed message IDs.

Now leverages the existing message queue system:
- Backend queues continue message when compaction starts
- Queue auto-sends when compaction stream ends (existing behavior)
- Continue message shown in queue UI during compaction
- Proper cleanup on all error paths

Net reduction of 124 lines. Simpler, more reliable, better UX.

Author: ethanndickson

src/browser/App.tsx

@@ -12,7 +12,6 @@ import { usePersistedState, updatePersistedState } from "./hooks/usePersistedSta
 import { matchesKeybind, KEYBINDS } from "./utils/ui/keybinds";
 import { useResumeManager } from "./hooks/useResumeManager";
 import { useUnreadTracking } from "./hooks/useUnreadTracking";
-import { useAutoCompactContinue } from "./hooks/useAutoCompactContinue";
 import { useWorkspaceStoreRaw, useWorkspaceRecency } from "./stores/WorkspaceStore";
 import { ChatInput } from "./components/ChatInput/index";
 import type { ChatInputAPI } from "./components/ChatInput/types";
@@ -116,9 +115,6 @@ function AppInner() {
   // Auto-resume interrupted streams on app startup and when failures occur
   useResumeManager();
 
-  // Handle auto-continue after compaction (when user uses /compact -c)
-  useAutoCompactContinue();
-
   // Sync selectedWorkspace with URL hash
   useEffect(() => {
     if (selectedWorkspace) {

src/browser/hooks/useAutoCompactContinue.ts

@@ -672,12 +672,6 @@ export class WorkspaceStore {
     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",
@@ -697,10 +691,7 @@ export class WorkspaceStore {
           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" },
+        muxMetadata: { type: "normal" },
       }
     );
 

src/browser/stores/WorkspaceStore.ts

@@ -126,15 +126,6 @@ export const PREFERRED_COMPACTION_MODEL_KEY = "preferredCompactionModel";
  */
 export const VIM_ENABLED_KEY = "vimEnabled";
 
-/**
- * Get the localStorage key for the compact continue message for a workspace
- * Temporarily stores the continuation prompt for the current compaction
- * Should be deleted immediately after use to prevent bugs
- */
-export function getCompactContinueMessageKey(workspaceId: string): string {
-  return `compactContinueMessage:${workspaceId}`;
-}
-
 /**
  * Get the localStorage key for hunk expand/collapse state in Review tab
  * Stores user's manual expand/collapse preferences per hunk
@@ -164,7 +155,6 @@ export function getReviewSearchStateKey(workspaceId: string): string {
 
 /**
  * List of workspace-scoped key functions that should be copied on fork and deleted on removal
- * Note: Excludes ephemeral keys like getCompactContinueMessageKey
  */
 const PERSISTENT_WORKSPACE_KEY_FUNCTIONS: Array<(workspaceId: string) => string> = [
   getModelKey,
@@ -183,7 +173,6 @@ const PERSISTENT_WORKSPACE_KEY_FUNCTIONS: Array<(workspaceId: string) => string>
  */
 const EPHEMERAL_WORKSPACE_KEY_FUNCTIONS: Array<(workspaceId: string) => string> = [
   getCancelledCompactionKey,
-  getCompactContinueMessageKey,
 ];
 
 /**

src/common/constants/storage.ts

@@ -20,11 +20,6 @@ export type MuxFrontendMetadata =
       rawCommand: string; // The original /compact command as typed by user (for display)
       parsed: CompactionRequestData;
     }
-  | {
-      type: "compaction-result";
-      continueMessage: string; // Message to send after compaction completes
-      requestId?: string; // ID of the compaction-request user message that produced this summary (for idempotency)
-    }
   | {
       type: "normal"; // Regular messages
     };

src/common/types/message.ts

@@ -314,6 +314,15 @@ export class AgentSession {
 
     this.emitChatEvent(userMessage);
 
+    // If this is a compaction request with a continue message, queue it for auto-send after compaction
+    const muxMeta = options?.muxMetadata;
+    if (muxMeta?.type === "compaction-request" && muxMeta.parsed.continueMessage && options) {
+      // Strip out muxMetadata & mode so the queued message doesn't compact
+      const { muxMetadata, mode, ...continueOptions } = options;
+      this.messageQueue.add(muxMeta.parsed.continueMessage, continueOptions);
+      this.emitQueuedMessageChanged();
+    }
+
     if (!options?.model || options.model.trim().length === 0) {
       return Err(
         createUnknownSendMessageError("No model specified. Please select a model using /model.")
@@ -412,16 +421,17 @@ export class AgentSession {
     forward("reasoning-delta", (payload) => this.emitChatEvent(payload));
     forward("reasoning-end", (payload) => this.emitChatEvent(payload));
 
-    forward("stream-end", (payload) => {
-      this.emitChatEvent(payload);
+    forward("stream-end", async (payload) => {
       // Stream end: auto-send queued messages
       if (!this.messageQueue.isEmpty()) {
         const { message, options } = this.messageQueue.produceMessage();
         this.messageQueue.clear();
         this.emitQueuedMessageChanged();
 
-        void this.sendMessage(message, options);
+        await this.sendMessage(message, options);
       }
+      // Don't update the frontend until the message is sent
+      this.emitChatEvent(payload);
     });
 
     forward("stream-abort", (payload) => {