🤖 fix: auto-retry aborted compaction on workspace reload

When compaction is interrupted (app restart, crash, network loss), the
compaction-request user message is left in history without a completed
summary message. Previously, users would need to manually retry.

This change:
- Adds detectAbortedCompaction() to identify when a compaction was
  interrupted by checking if the last user message is a compaction-request
  without a following compacted assistant message
- Emits a new 'aborted-compaction' event during history replay when
  an aborted compaction is detected
- Adds useAbortedCompactionRetry hook to automatically retry the
  compaction using the original request parameters (model, maxOutputTokens,
  continueMessage, source)
- Uses the same pattern as useIdleCompactionHandler for consistency

This provides a strong guarantee that compaction will complete:
1. Original compaction-request stays in history until compaction succeeds
2. On reload, aborted compaction is detected and automatically retried
3. Retry uses the same parameters from the original /compact command

---
_Generated with `mux` • Model: `anthropic:claude-opus-4-5` • Thinking: `high`_

Author: ammar-agent

src/browser/components/AIView.tsx

@@ -67,6 +67,7 @@ import { useAutoCompactionSettings } from "../hooks/useAutoCompactionSettings";
 import { useSendMessageOptions } from "@/browser/hooks/useSendMessageOptions";
 import { useForceCompaction } from "@/browser/hooks/useForceCompaction";
 import { useIdleCompactionHandler } from "@/browser/hooks/useIdleCompactionHandler";
+import { useAbortedCompactionRetry } from "@/browser/hooks/useAbortedCompactionRetry";
 import { useAPI } from "@/browser/contexts/API";
 import { useReviews } from "@/browser/hooks/useReviews";
 import { ReviewsBanner } from "./ReviewsBanner";
@@ -244,6 +245,9 @@ const AIViewInner: React.FC<AIViewProps> = ({
   // Idle compaction - trigger compaction when backend signals workspace has been idle
   useIdleCompactionHandler({ api });
 
+  // Aborted compaction retry - automatically retry compaction interrupted by restart/crash
+  useAbortedCompactionRetry({ api });
+
   // Auto-retry state - minimal setter for keybinds and message sent handler
   // RetryBarrier manages its own state, but we need this for interrupt keybind
   const [, setAutoRetry] = usePersistedState<boolean>(

src/browser/hooks/useAbortedCompactionRetry.ts

@@ -0,0 +1,99 @@
+/**
+ * Hook to handle aborted compaction retry.
+ *
+ * When a compaction is interrupted (app restart, crash, network loss), the backend
+ * detects this on history replay and emits an `aborted-compaction` event.
+ *
+ * This hook listens for these signals and automatically retries the compaction
+ * using the stored parameters from the original request.
+ *
+ * The retry uses the same compaction options (model, maxOutputTokens, etc.) that
+ * were specified in the original /compact command. The compaction-request user
+ * message remains in history as the trigger for the retry.
+ */
+
+import { useEffect, useRef } from "react";
+import type { RouterClient } from "@orpc/server";
+import type { AppRouter } from "@/node/orpc/router";
+import { executeCompaction } from "@/browser/utils/chatCommands";
+import { buildSendMessageOptions } from "@/browser/hooks/useSendMessageOptions";
+import { workspaceStore } from "@/browser/stores/WorkspaceStore";
+import type { AbortedCompactionEventSchema } from "@/common/orpc/schemas/stream";
+import type { z } from "zod";
+
+type CompactionMetadata = z.infer<typeof AbortedCompactionEventSchema>["compactionMetadata"];
+
+export interface AbortedCompactionRetryParams {
+  api: RouterClient<AppRouter> | null;
+}
+
+/**
+ * Hook to automatically retry compaction when the backend detects an aborted compaction.
+ * Should be called at a high level (e.g., App or AIView) to handle all workspaces.
+ */
+export function useAbortedCompactionRetry(params: AbortedCompactionRetryParams): void {
+  const { api } = params;
+
+  // Track which workspaces we've triggered retry for (to prevent duplicates)
+  const retriedWorkspacesRef = useRef(new Set<string>());
+
+  useEffect(() => {
+    if (!api) return;
+
+    const handleAbortedCompaction = (workspaceId: string, metadata: CompactionMetadata) => {
+      // Skip if already retrying for this workspace
+      if (retriedWorkspacesRef.current.has(workspaceId)) {
+        return;
+      }
+
+      retriedWorkspacesRef.current.add(workspaceId);
+
+      console.info(`[compaction] Retrying aborted compaction for workspace ${workspaceId}`);
+
+      // Build send options using current workspace settings
+      const baseSendMessageOptions = buildSendMessageOptions(workspaceId);
+
+      // Apply any model override from the original compaction request
+      const sendMessageOptions = {
+        ...baseSendMessageOptions,
+        // If the original request had a custom model, use it
+        // Otherwise use the workspace default
+        ...(metadata.parsed.model && { model: metadata.parsed.model }),
+      };
+
+      // Determine the source based on original request
+      const source = metadata.source === "idle-compaction" ? "idle-compaction" : undefined;
+
+      // Convert continueMessage from schema shape to ContinueMessage type
+      // Schema has optional text, but ContinueMessage requires it (defaulting to empty string)
+      const continueMessage = metadata.parsed.continueMessage
+        ? {
+            text: metadata.parsed.continueMessage.text ?? "",
+            imageParts: metadata.parsed.continueMessage.imageParts,
+            model: metadata.parsed.continueMessage.model,
+          }
+        : undefined;
+
+      void executeCompaction({
+        api,
+        workspaceId,
+        sendMessageOptions,
+        model: metadata.parsed.model,
+        maxOutputTokens: metadata.parsed.maxOutputTokens,
+        continueMessage,
+        source,
+      }).then((result) => {
+        if (!result.success) {
+          console.error("Aborted compaction retry failed:", result.error);
+        } else {
+          console.info(`[compaction] Successfully retried compaction for workspace ${workspaceId}`);
+        }
+        // Clear from retried set after completion
+        retriedWorkspacesRef.current.delete(workspaceId);
+      });
+    };
+
+    const unsubscribe = workspaceStore.onAbortedCompaction(handleAbortedCompaction);
+    return unsubscribe;
+  }, [api]);
+}

src/browser/stores/WorkspaceStore.ts

@@ -19,7 +19,11 @@ import {
   isMuxMessage,
   isQueuedMessageChanged,
   isRestoreToInput,
+  isAbortedCompaction,
 } from "@/common/orpc/types";
+import type { AbortedCompactionEventSchema } from "@/common/orpc/schemas/stream";
+
+type AbortedCompactionEvent = z.infer<typeof AbortedCompactionEventSchema>;
 import type { StreamEndEvent, StreamAbortEvent } from "@/common/types/stream";
 import { MapStore } from "./MapStore";
 import { createDisplayUsage } from "@/common/utils/tokens/displayUsage";
@@ -301,6 +305,11 @@ export class WorkspaceStore {
   // Idle compaction notification callbacks (called when backend signals idle compaction needed)
   private idleCompactionCallbacks = new Set<(workspaceId: string) => void>();
 
+  // Aborted compaction notification callbacks (called when backend detects an aborted compaction on replay)
+  private abortedCompactionCallbacks = new Set<
+    (workspaceId: string, metadata: AbortedCompactionEvent["compactionMetadata"]) => void
+  >();
+
   // Tracks when a file-modifying tool (file_edit_*, bash) last completed per workspace.
   // ReviewPanel subscribes to trigger diff refresh. Two structures:
   // - timestamps: actual Date.now() values for cache invalidation checks
@@ -1449,6 +1458,34 @@ export class WorkspaceStore {
     }
   }
 
+  /**
+   * Subscribe to aborted compaction events.
+   * Callback is called when backend detects an aborted compaction that needs retry.
+   * Returns unsubscribe function.
+   */
+  onAbortedCompaction(
+    callback: (workspaceId: string, metadata: AbortedCompactionEvent["compactionMetadata"]) => void
+  ): () => void {
+    this.abortedCompactionCallbacks.add(callback);
+    return () => this.abortedCompactionCallbacks.delete(callback);
+  }
+
+  /**
+   * Notify all listeners that an aborted compaction was detected.
+   */
+  private notifyAbortedCompaction(
+    workspaceId: string,
+    metadata: AbortedCompactionEvent["compactionMetadata"]
+  ): void {
+    for (const callback of this.abortedCompactionCallbacks) {
+      try {
+        callback(workspaceId, metadata);
+      } catch (error) {
+        console.error("Error in aborted compaction callback:", error);
+      }
+    }
+  }
+
   /**
    * Subscribe to file-modifying tool completions for a workspace.
    * Used by ReviewPanel to trigger diff refresh.
@@ -1556,6 +1593,12 @@ export class WorkspaceStore {
       return;
     }
 
+    // Handle aborted-compaction event (detected on history replay)
+    if (isAbortedCompaction(data)) {
+      this.notifyAbortedCompaction(workspaceId, data.compactionMetadata);
+      return;
+    }
+
     // OPTIMIZATION: Buffer stream events until caught-up to reduce excess re-renders
     // When first subscribing to a workspace, we receive:
     // 1. Historical messages from chat.jsonl (potentially hundreds of messages)
@@ -1700,6 +1743,9 @@ function getStoreInstance(): WorkspaceStore {
 export const workspaceStore = {
   onIdleCompactionNeeded: (callback: (workspaceId: string) => void) =>
     getStoreInstance().onIdleCompactionNeeded(callback),
+  onAbortedCompaction: (
+    callback: (workspaceId: string, metadata: AbortedCompactionEvent["compactionMetadata"]) => void
+  ) => getStoreInstance().onAbortedCompaction(callback),
   subscribeFileModifyingTool: (workspaceId: string, listener: () => void) =>
     getStoreInstance().subscribeFileModifyingTool(workspaceId, listener),
   getFileModifyingToolMs: (workspaceId: string) =>

src/common/orpc/schemas/stream.ts

@@ -20,6 +20,28 @@ export const IdleCompactionNeededEventSchema = z.object({
   type: z.literal("idle-compaction-needed"),
 });
 
+/** Sent when an aborted compaction is detected on history replay */
+export const AbortedCompactionEventSchema = z.object({
+  type: z.literal("aborted-compaction"),
+  messageId: z.string(),
+  compactionMetadata: z.object({
+    type: z.literal("compaction-request"),
+    rawCommand: z.string(),
+    parsed: z.object({
+      model: z.string().optional(),
+      maxOutputTokens: z.number().optional(),
+      continueMessage: z
+        .object({
+          text: z.string().optional(),
+          imageParts: z.array(ImagePartSchema).optional(),
+          model: z.string().optional(),
+        })
+        .optional(),
+    }),
+    source: z.enum(["idle-compaction"]).optional(),
+  }),
+});
+
 export const StreamErrorMessageSchema = z.object({
   type: z.literal("stream-error"),
   messageId: z.string(),
@@ -318,8 +340,9 @@ export const WorkspaceChatMessageSchema = z.discriminatedUnion("type", [
   UsageDeltaEventSchema,
   QueuedMessageChangedEventSchema,
   RestoreToInputEventSchema,
-  // Idle compaction notification
+  // Compaction notifications
   IdleCompactionNeededEventSchema,
+  AbortedCompactionEventSchema,
   // Init events
   ...WorkspaceInitEventSchema.def.options,
   // Chat messages with type discriminator

src/common/orpc/types.ts

@@ -128,3 +128,9 @@ export function isRestoreToInput(
 ): msg is Extract<WorkspaceChatMessage, { type: "restore-to-input" }> {
   return (msg as { type?: string }).type === "restore-to-input";
 }
+
+export function isAbortedCompaction(
+  msg: WorkspaceChatMessage
+): msg is Extract<WorkspaceChatMessage, { type: "aborted-compaction" }> {
+  return (msg as { type?: string }).type === "aborted-compaction";
+}

src/node/services/agentSession.test.ts

@@ -0,0 +1,149 @@
+import { describe, test, expect } from "bun:test";
+import { detectAbortedCompaction } from "./agentSession";
+import type { MuxMessage, MuxFrontendMetadata } from "@/common/types/message";
+
+describe("detectAbortedCompaction", () => {
+  const createUserMessage = (id: string, muxMetadata?: MuxFrontendMetadata): MuxMessage => ({
+    id,
+    role: "user",
+    parts: [{ type: "text", text: "test message" }],
+    metadata: {
+      historySequence: 1,
+      timestamp: Date.now(),
+      ...(muxMetadata && { muxMetadata }),
+    },
+  });
+
+  const createAssistantMessage = (
+    id: string,
+    compacted?: boolean | "user" | "idle"
+  ): MuxMessage => ({
+    id,
+    role: "assistant",
+    parts: [{ type: "text", text: "assistant response" }],
+    metadata: {
+      historySequence: 2,
+      timestamp: Date.now(),
+      ...(compacted !== undefined && { compacted }),
+    },
+  });
+
+  test("returns null for empty history", () => {
+    expect(detectAbortedCompaction([])).toBeNull();
+  });
+
+  test("returns null when no user messages exist", () => {
+    const messages: MuxMessage[] = [createAssistantMessage("a1")];
+    expect(detectAbortedCompaction(messages)).toBeNull();
+  });
+
+  test("returns null for regular user message (not compaction)", () => {
+    const messages: MuxMessage[] = [createUserMessage("u1"), createAssistantMessage("a1")];
+    expect(detectAbortedCompaction(messages)).toBeNull();
+  });
+
+  test("detects aborted compaction when no assistant response follows", () => {
+    const compactionRequest = createUserMessage("u1", {
+      type: "compaction-request",
+      rawCommand: "/compact",
+      parsed: {},
+    });
+    const messages: MuxMessage[] = [compactionRequest];
+
+    const result = detectAbortedCompaction(messages);
+    expect(result).not.toBeNull();
+    expect(result?.id).toBe("u1");
+  });
+
+  test("detects aborted compaction when assistant response lacks compacted flag", () => {
+    const compactionRequest = createUserMessage("u1", {
+      type: "compaction-request",
+      rawCommand: "/compact",
+      parsed: {},
+    });
+    const messages: MuxMessage[] = [
+      compactionRequest,
+      createAssistantMessage("a1"), // No compacted flag - incomplete
+    ];
+
+    const result = detectAbortedCompaction(messages);
+    expect(result).not.toBeNull();
+    expect(result?.id).toBe("u1");
+  });
+
+  test("returns null when compaction completed (compacted: true)", () => {
+    const compactionRequest = createUserMessage("u1", {
+      type: "compaction-request",
+      rawCommand: "/compact",
+      parsed: {},
+    });
+    const messages: MuxMessage[] = [compactionRequest, createAssistantMessage("a1", true)];
+
+    expect(detectAbortedCompaction(messages)).toBeNull();
+  });
+
+  test("returns null when compaction completed (compacted: 'user')", () => {
+    const compactionRequest = createUserMessage("u1", {
+      type: "compaction-request",
+      rawCommand: "/compact",
+      parsed: {},
+    });
+    const messages: MuxMessage[] = [compactionRequest, createAssistantMessage("a1", "user")];
+
+    expect(detectAbortedCompaction(messages)).toBeNull();
+  });
+
+  test("returns null when compaction completed (compacted: 'idle')", () => {
+    const compactionRequest = createUserMessage("u1", {
+      type: "compaction-request",
+      rawCommand: "/compact --idle",
+      parsed: {},
+    });
+    const messages: MuxMessage[] = [compactionRequest, createAssistantMessage("a1", "idle")];
+
+    expect(detectAbortedCompaction(messages)).toBeNull();
+  });
+
+  test("only looks at last user message", () => {
+    const oldCompactionRequest = createUserMessage("u1", {
+      type: "compaction-request",
+      rawCommand: "/compact",
+      parsed: {},
+    });
+    const normalUserMessage = createUserMessage("u2");
+
+    const messages: MuxMessage[] = [
+      oldCompactionRequest,
+      createAssistantMessage("a1"),
+      normalUserMessage,
+      createAssistantMessage("a2"),
+    ];
+
+    // Last user message is normal, not a compaction request
+    expect(detectAbortedCompaction(messages)).toBeNull();
+  });
+
+  test("detects aborted compaction in longer history", () => {
+    const normalUser1 = createUserMessage("u1");
+    const normalUser2 = createUserMessage("u2");
+    const compactionRequest = createUserMessage("u3", {
+      type: "compaction-request",
+      rawCommand: "/compact",
+      parsed: { model: "claude-sonnet-4-20250514" },
+    });
+
+    const messages: MuxMessage[] = [
+      normalUser1,
+      createAssistantMessage("a1"),
+      normalUser2,
+      createAssistantMessage("a2"),
+      compactionRequest,
+      // No assistant response - compaction was interrupted
+    ];
+
+    const result = detectAbortedCompaction(messages);
+    expect(result).not.toBeNull();
+    expect(result?.id).toBe("u3");
+    expect(result?.metadata?.muxMetadata?.type).toBe("compaction-request");
+  });
+});