🤖 fix: move retry-state ownership from streamWithHistory to work boundaries

Replace the coupled lastAutoRetryOptions + lastAutoRetryAgentInitiated pair
with a single lastAutoRetryRequest (StartupRetrySendOptions), and move
ownership from the low-level stream runner to higher-level work boundaries.

This fixes manual /compact followed by a failed follow-up dispatch leaving
stale compact-agent retry state that could cause no-tools confusion.

---

_Generated with `mux` • Model: `anthropic:claude-opus-4-6` • Thinking: `xhigh`_

<!-- mux-attribution: model=anthropic:claude-opus-4-6 thinking=xhigh -->

Author: ethanndickson

src/node/services/agentSession.continueMessageAgentId.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test, mock, afterEach } from "bun:test";
-import { buildContinueMessage } from "@/common/types/message";
+import { buildContinueMessage, type StartupRetrySendOptions } from "@/common/types/message";
 import type { FilePart, SendMessageOptions } from "@/common/orpc/types";
 import { AgentSession } from "./agentSession";
 import type { Config } from "@/node/config";
@@ -25,6 +25,7 @@ interface SessionInternals {
   scheduleStartupRecovery: () => void;
   startupRecoveryPromise: Promise<void> | null;
   startupRecoveryScheduled: boolean;
+  lastAutoRetryRequest?: StartupRetrySendOptions;
 }
 
 describe("AgentSession continue-message agentId fallback", () => {
@@ -136,6 +137,109 @@ describe("AgentSession continue-message agentId fallback", () => {
     session.dispose();
   });
 
+  test("dispatchPendingFollowUp rewrites stale compact retry state to the reconstructed follow-up", async () => {
+    const aiService: AIService = {
+      on() {
+        return this;
+      },
+      off() {
+        return this;
+      },
+      isStreaming: () => false,
+      stopStream: mock(() => Promise.resolve({ success: true as const, data: undefined })),
+    } as unknown as AIService;
+
+    const legacyFollowUp = {
+      text: "follow up retry",
+      model: "openai:gpt-4o",
+      agentId: undefined as unknown as string,
+      mode: "plan" as const,
+      thinkingLevel: "high" as const,
+    };
+
+    const mockSummaryMessage = {
+      id: "summary-retry-state",
+      role: "assistant" as const,
+      parts: [{ type: "text" as const, text: "Compaction summary" }],
+      metadata: {
+        muxMetadata: {
+          type: "compaction-summary" as const,
+          pendingFollowUp: legacyFollowUp,
+        },
+      },
+    } satisfies MuxMessage;
+
+    const { historyService, cleanup } = await createTestHistoryService();
+    historyCleanup = cleanup;
+    await historyService.appendToHistory("ws", mockSummaryMessage);
+
+    const initStateManager: InitStateManager = {
+      on() {
+        return this;
+      },
+      off() {
+        return this;
+      },
+    } as unknown as InitStateManager;
+
+    const backgroundProcessManager: BackgroundProcessManager = {
+      cleanup: mock(() => Promise.resolve()),
+      setMessageQueued: mock(() => undefined),
+    } as unknown as BackgroundProcessManager;
+
+    const config: Config = {
+      srcDir: "/tmp",
+      getSessionDir: mock(() => "/tmp"),
+    } as unknown as Config;
+
+    const session = new AgentSession({
+      workspaceId: "ws",
+      config,
+      historyService,
+      aiService,
+      initStateManager,
+      backgroundProcessManager,
+    });
+
+    const internals = session as unknown as SessionInternals;
+    internals.lastAutoRetryRequest = {
+      model: "openai:gpt-4o-mini",
+      agentId: "compact",
+      toolPolicy: [{ regex_match: ".*", action: "disable" }],
+      agentInitiated: true,
+    };
+    internals.sendMessage = mock(() =>
+      Promise.resolve({
+        success: false as const,
+        error: { type: "runtime_start_failed", message: "startup failed" },
+      })
+    );
+
+    let dispatchError: unknown;
+    try {
+      await internals.dispatchPendingFollowUp();
+    } catch (error) {
+      dispatchError = error;
+    }
+
+    expect(dispatchError).toBeInstanceOf(Error);
+    if (!(dispatchError instanceof Error)) {
+      throw new Error("Expected dispatchPendingFollowUp to throw when sendMessage fails");
+    }
+    expect(dispatchError.message).toContain("Failed to dispatch pending follow-up");
+    expect(internals.lastAutoRetryRequest).toEqual(
+      expect.objectContaining({
+        model: "openai:gpt-4o",
+        agentId: "plan",
+        thinkingLevel: "high",
+      }) as StartupRetrySendOptions
+    );
+    expect(internals.lastAutoRetryRequest?.toolPolicy).toBeUndefined();
+    expect(internals.lastAutoRetryRequest?.agentInitiated).toBeUndefined();
+
+    session.dispose();
+  });
+
   test("dispatchPendingFollowUp throws when history read fails", async () => {
     const aiService: AIService = {
       on() {

src/node/services/agentSession.startupAutoRetry.test.ts

@@ -8,7 +8,7 @@ import type { HistoryService } from "./historyService";
 import type { Config } from "@/node/config";
 import type { InitStateManager } from "./initStateManager";
 import type { WorkspaceChatMessage, SendMessageOptions } from "@/common/orpc/types";
-import { createMuxMessage } from "@/common/types/message";
+import { createMuxMessage, type StartupRetrySendOptions } from "@/common/types/message";
 import { DEFAULT_RUNTIME_CONFIG } from "@/common/constants/workspace";
 import type { WorkspaceMetadata } from "@/common/types/workspace";
 import { Ok } from "@/common/types/result";
@@ -142,8 +142,11 @@ describe("AgentSession startup auto-retry recovery", () => {
     const scheduledEvent = events.find((event) => event.type === "auto-retry-scheduled");
     expect(scheduledEvent).toBeDefined();
 
-    const retryOptions = (session as unknown as { lastAutoRetryOptions?: SendMessageOptions })
-      .lastAutoRetryOptions;
+    const retryOptions = (
+      session as unknown as {
+        lastAutoRetryRequest?: StartupRetrySendOptions;
+      }
+    ).lastAutoRetryRequest;
     expect(retryOptions).toBeDefined();
     if (!retryOptions) {
       throw new Error("Expected startup auto-retry options to be captured");
@@ -454,8 +457,11 @@ describe("AgentSession startup auto-retry recovery", () => {
     ).startupAutoRetryCheckPromise;
     await startupCheckPromise;
 
-    const retryOptions = (session as unknown as { lastAutoRetryOptions?: SendMessageOptions })
-      .lastAutoRetryOptions;
+    const retryOptions = (
+      session as unknown as {
+        lastAutoRetryRequest?: StartupRetrySendOptions;
+      }
+    ).lastAutoRetryRequest;
     expect(retryOptions).toBeDefined();
     if (!retryOptions) {
       throw new Error("Expected startup retry options");
@@ -714,7 +720,7 @@ describe("AgentSession startup auto-retry recovery", () => {
       persistStartupAutoRetryAbandon: (reason: string, userMessageId?: string) => Promise<void>;
       retryActiveStream: () => Promise<void>;
       getAutoRetryPreferencePath: () => string;
-      lastAutoRetryOptions?: SendMessageOptions;
+      lastAutoRetryRequest?: StartupRetrySendOptions;
       resumeStream: (
         options: SendMessageOptions
       ) => Promise<{ success: true; data: { started: boolean } }>;
@@ -726,7 +732,7 @@ describe("AgentSession startup auto-retry recovery", () => {
     const preferencePath = privateSession.getAutoRetryPreferencePath();
     expect(await Bun.file(preferencePath).exists()).toBe(true);
 
-    privateSession.lastAutoRetryOptions = {
+    privateSession.lastAutoRetryRequest = {
       model: "anthropic:claude-sonnet-4-5",
       agentId: "exec",
     };
@@ -752,13 +758,13 @@ describe("AgentSession startup auto-retry recovery", () => {
 
     const privateSession = session as unknown as {
       retryActiveStream: () => Promise<void>;
-      lastAutoRetryOptions?: SendMessageOptions;
+      lastAutoRetryRequest?: StartupRetrySendOptions;
       resumeStream: (
         options: SendMessageOptions
       ) => Promise<{ success: true; data: { started: boolean } }>;
     };
 
-    privateSession.lastAutoRetryOptions = {
+    privateSession.lastAutoRetryRequest = {
       model: "anthropic:claude-sonnet-4-5",
       agentId: "exec",
     };
@@ -789,7 +795,7 @@ describe("AgentSession startup auto-retry recovery", () => {
 
     const privateSession = session as unknown as {
       retryActiveStream: () => Promise<void>;
-      lastAutoRetryOptions?: SendMessageOptions;
+      lastAutoRetryRequest?: StartupRetrySendOptions;
       activeStreamFailureHandled: boolean;
       resumeStream: (
         options: SendMessageOptions
@@ -799,7 +805,7 @@ describe("AgentSession startup auto-retry recovery", () => {
       >;
     };
 
-    privateSession.lastAutoRetryOptions = {
+    privateSession.lastAutoRetryRequest = {
       model: "anthropic:claude-sonnet-4-5",
       agentId: "exec",
     };
@@ -834,7 +840,7 @@ describe("AgentSession startup auto-retry recovery", () => {
 
     const privateSession = session as unknown as {
       retryActiveStream: () => Promise<void>;
-      lastAutoRetryOptions?: SendMessageOptions;
+      lastAutoRetryRequest?: StartupRetrySendOptions;
       activeStreamFailureHandled: boolean;
       resumeStream: (
         options: SendMessageOptions
@@ -844,7 +850,7 @@ describe("AgentSession startup auto-retry recovery", () => {
       >;
     };
 
-    privateSession.lastAutoRetryOptions = {
+    privateSession.lastAutoRetryRequest = {
       model: "anthropic:claude-sonnet-4-5",
       agentId: "exec",
     };
@@ -872,6 +878,94 @@ describe("AgentSession startup auto-retry recovery", () => {
     session.dispose();
   });
 
+  test("retryActiveStream resumes the reconstructed follow-up after compaction handoff send fails", async () => {
+    const workspaceId = "startup-retry-follow-up-handoff";
+    const { session, historyService, cleanup } = await createSessionBundle(workspaceId);
+    cleanups.push(cleanup);
+
+    const appendResult = await historyService.appendToHistory(
+      workspaceId,
+      createMuxMessage("summary-follow-up", "assistant", "Compaction summary", {
+        muxMetadata: {
+          type: "compaction-summary",
+          pendingFollowUp: {
+            text: "resume the original work",
+            model: "openai:gpt-4o",
+            agentId: "exec",
+            thinkingLevel: "high",
+          },
+        },
+      })
+    );
+    expect(appendResult.success).toBe(true);
+
+    const privateSession = session as unknown as {
+      dispatchPendingFollowUp: () => Promise<boolean>;
+      retryActiveStream: () => Promise<void>;
+      lastAutoRetryRequest?: StartupRetrySendOptions;
+      sendMessage: (
+        message: string,
+        options?: SendMessageOptions,
+        internal?: { synthetic?: boolean }
+      ) => Promise<
+        { success: true } | { success: false; error: { type: string; message?: string } }
+      >;
+      resumeStream: (
+        options: SendMessageOptions,
+        internal?: { agentInitiated?: boolean }
+      ) => Promise<{ success: true; data: { started: boolean } }>;
+    };
+
+    privateSession.lastAutoRetryRequest = {
+      model: "anthropic:claude-sonnet-4-5",
+      agentId: "compact",
+      toolPolicy: [{ regex_match: ".*", action: "disable" }],
+      agentInitiated: true,
+    };
+    privateSession.sendMessage = mock(() =>
+      Promise.resolve({
+        success: false as const,
+        error: { type: "runtime_start_failed", message: "startup failed" },
+      })
+    );
+
+    let dispatchError: unknown;
+    try {
+      await privateSession.dispatchPendingFollowUp();
+    } catch (error) {
+      dispatchError = error;
+    }
+    expect(dispatchError).toBeInstanceOf(Error);
+    expect((dispatchError as Error).message).toContain("Failed to dispatch pending follow-up");
+
+    const resumeStreamMock = mock(
+      (_options: SendMessageOptions, _internal?: { agentInitiated?: boolean }) =>
+        Promise.resolve({ success: true as const, data: { started: true } })
+    );
+    privateSession.resumeStream = resumeStreamMock;
+
+    await privateSession.retryActiveStream();
+
+    expect(resumeStreamMock).toHaveBeenCalledTimes(1);
+    const firstCall = resumeStreamMock.mock.calls[0];
+    expect(firstCall).toBeDefined();
+    const [optionsArg, internalArg] = firstCall as unknown as [
+      SendMessageOptions,
+      { agentInitiated?: boolean } | undefined,
+    ];
+    expect(optionsArg).toEqual(
+      expect.objectContaining({
+        model: "openai:gpt-4o",
+        agentId: "exec",
+        thinkingLevel: "high",
+      }) as SendMessageOptions
+    );
+    expect(optionsArg.toolPolicy).toBeUndefined();
+    expect(internalArg?.agentInitiated).toBeUndefined();
+
+    session.dispose();
+  });
+
   test("persists startup abandon marker for pre-stream user aborts", async () => {
     const workspaceId = "startup-retry-pre-stream-abort";
     const { historyService, config, cleanup } = await createTestHistoryService();