fix(cloud-task): recover queued messages after sandbox stops (#3046)

Author: tatoalo

packages/agent/src/server/agent-server.test.ts

@@ -1372,6 +1372,109 @@ describe("AgentServer HTTP Mode", () => {
     });
   });
 
+  describe("resume prompt display", () => {
+    it("hides synthetic resume context while keeping the pending user message visible", async () => {
+      const s = createServer() as unknown as {
+        resumeState: ResumeState | null;
+        session: {
+          payload: JwtPayload;
+          acpSessionId: string;
+          clientConnection: {
+            prompt: ReturnType<typeof vi.fn>;
+          };
+          logWriter: {
+            resetTurnMessages: ReturnType<typeof vi.fn>;
+            appendRawLine: ReturnType<typeof vi.fn>;
+            flushAll: ReturnType<typeof vi.fn>;
+          };
+          sseController: null;
+          deviceInfo: { type: "cloud"; name: string };
+          permissionMode: PermissionMode;
+          hasDesktopConnected: boolean;
+        };
+        sendResumeMessage(
+          payload: JwtPayload,
+          taskRun: TaskRun | null,
+        ): Promise<void>;
+      };
+      const payload: JwtPayload = {
+        run_id: "test-run-id",
+        task_id: "test-task-id",
+        team_id: 1,
+        user_id: 1,
+        distinct_id: "test-distinct-id",
+        mode: "interactive",
+      };
+      const prompt = vi.fn(async () => ({ stopReason: "cancelled" }));
+      s.session = {
+        payload,
+        acpSessionId: "acp-session",
+        clientConnection: { prompt },
+        logWriter: {
+          resetTurnMessages: vi.fn(),
+          appendRawLine: vi.fn(),
+          flushAll: vi.fn(),
+        },
+        sseController: null,
+        deviceInfo: { type: "cloud", name: "test-sandbox" },
+        permissionMode: "bypassPermissions",
+        hasDesktopConnected: false,
+      };
+      s.resumeState = {
+        conversation: [
+          { role: "user", content: [{ type: "text", text: "old request" }] },
+          {
+            role: "assistant",
+            content: [{ type: "text", text: "old answer" }],
+          },
+        ],
+        latestGitCheckpoint: null,
+        interrupted: false,
+        logEntryCount: 2,
+        sessionId: "prior-session",
+      };
+
+      await s.sendResumeMessage(
+        payload,
+        createTaskRun({
+          id: "test-run-id",
+          task: "test-task-id",
+          state: {
+            pending_user_message: "visible follow-up",
+            pending_user_message_ts: "123.456",
+          },
+        }),
+      );
+
+      const [{ prompt: promptBlocks }] = prompt.mock.calls[0] as unknown as [
+        { prompt: ContentBlock[] },
+      ];
+      const visibleText = promptBlocks
+        .filter(
+          (block) =>
+            block.type === "text" &&
+            !(
+              (block as { _meta?: { ui?: { hidden?: boolean } } })._meta?.ui
+                ?.hidden === true
+            ),
+        )
+        .map((block) => (block as { text: string }).text);
+
+      expect(promptBlocks[0]).toMatchObject({
+        type: "text",
+        _meta: { ui: { hidden: true } },
+      });
+      expect((promptBlocks[0] as { text: string }).text).toContain(
+        "You are resuming a previous conversation",
+      );
+      expect(visibleText).toEqual(["visible follow-up"]);
+      expect(promptBlocks.at(-1)).toMatchObject({
+        type: "text",
+        _meta: { ui: { hidden: true } },
+      });
+    });
+  });
+
   describe("runtime adapter selection", () => {
     it("defaults to claude when no runtime adapter is configured", () => {
       const s = createServer();

packages/agent/src/server/agent-server.ts

@@ -250,6 +250,14 @@ interface BuiltPrompt {
   meta?: Record<string, unknown>;
 }
 
+function hiddenTextBlock(text: string): ContentBlock {
+  return {
+    type: "text",
+    text,
+    _meta: { ui: { hidden: true } },
+  } as ContentBlock;
+}
+
 interface LocalSkillPromptContext {
   skillName: string;
   context: string;
@@ -1571,39 +1579,34 @@ export class AgentServer {
 
       const pendingUserPrompt = await this.getPendingUserPrompt(taskRun);
 
-      const sandboxContext = checkpointApplied
+      const checkpointContext = checkpointApplied
         ? `The workspace environment (all files, packages, and code changes) has been fully restored from the latest checkpoint.`
-        : `The workspace from the previous session was not restored from a checkpoint, so you are starting with a fresh environment. Your conversation history is fully preserved below.`;
+        : `No additional git checkpoint was applied before resuming. Use the current workspace contents together with the preserved conversation history below.`;
 
       let resumePromptBlocks: ContentBlock[];
       let resumePromptMeta: Record<string, unknown> | undefined;
       if (pendingUserPrompt?.prompt.length) {
         resumePromptMeta = pendingUserPrompt.meta;
         resumePromptBlocks = [
-          {
-            type: "text",
-            text:
-              `You are resuming a previous conversation. ${sandboxContext}\n\n` +
+          hiddenTextBlock(
+            `You are resuming a previous conversation. ${checkpointContext}\n\n` +
               `Here is the conversation history from the previous session:\n\n` +
               `${conversationSummary}\n\n` +
               `The user has sent a new message:\n\n`,
-          },
+          ),
           ...pendingUserPrompt.prompt,
-          {
-            type: "text",
-            text: "\n\nRespond to the user's new message above. You have full context from the previous session.",
-          },
+          hiddenTextBlock(
+            "\n\nRespond to the user's new message above. You have full context from the previous session.",
+          ),
         ];
       } else {
         resumePromptBlocks = [
-          {
-            type: "text",
-            text:
-              `You are resuming a previous conversation. ${sandboxContext}\n\n` +
+          hiddenTextBlock(
+            `You are resuming a previous conversation. ${checkpointContext}\n\n` +
               `Here is the conversation history from the previous session:\n\n` +
               `${conversationSummary}\n\n` +
               `Continue from where you left off. The user is waiting for your response.`,
-          },
+          ),
         ];
       }
 

packages/core/src/cloud-task/cloud-task-types.ts

@@ -18,6 +18,7 @@ export interface CloudTaskStatusUpdate extends CloudTaskUpdateBase {
   output?: Record<string, unknown> | null;
   errorMessage?: string | null;
   branch?: string | null;
+  sandboxAlive?: boolean | null;
 }
 
 export interface CloudTaskSnapshotUpdate extends CloudTaskUpdateBase {
@@ -29,6 +30,7 @@ export interface CloudTaskSnapshotUpdate extends CloudTaskUpdateBase {
   output?: Record<string, unknown> | null;
   errorMessage?: string | null;
   branch?: string | null;
+  sandboxAlive?: boolean | null;
 }
 
 export interface CloudTaskErrorUpdate extends CloudTaskUpdateBase {

packages/core/src/cloud-task/cloud-task.test.ts

@@ -340,6 +340,75 @@ describe("CloudTaskService", () => {
     );
   });
 
+  it("emits sandbox liveness from run detail when retrying a live watcher", async () => {
+    const updates: unknown[] = [];
+    service.on(CloudTaskEvent.Update, (payload) => updates.push(payload));
+
+    mockNetFetch
+      .mockResolvedValueOnce(
+        createJsonResponse({
+          id: "run-1",
+          status: "in_progress",
+          stage: null,
+          output: null,
+          state: { sandbox_alive: true },
+          error_message: null,
+          branch: "main",
+          updated_at: "2026-01-01T00:00:00Z",
+        }),
+      )
+      .mockResolvedValueOnce(
+        createJsonResponse([], 200, { "X-Has-More": "false" }),
+      )
+      .mockResolvedValueOnce(
+        createJsonResponse({
+          id: "run-1",
+          status: "in_progress",
+          stage: null,
+          output: null,
+          state: { sandbox_alive: false },
+          error_message: null,
+          branch: "main",
+          updated_at: "2026-01-01T00:01:00Z",
+        }),
+      );
+
+    mockStreamFetch
+      .mockResolvedValueOnce(createOpenSseResponse(""))
+      .mockResolvedValueOnce(createOpenSseResponse(""));
+
+    service.watch({
+      taskId: "task-1",
+      runId: "run-1",
+      apiHost: "https://app.example.com",
+      teamId: 2,
+    });
+
+    await waitFor(() =>
+      updates.some(
+        (update) =>
+          typeof update === "object" &&
+          update !== null &&
+          (update as { kind?: string; sandboxAlive?: boolean }).kind ===
+            "snapshot" &&
+          (update as { sandboxAlive?: boolean }).sandboxAlive === true,
+      ),
+    );
+
+    await service.retry("task-1", "run-1");
+
+    await waitFor(() =>
+      updates.some(
+        (update) =>
+          typeof update === "object" &&
+          update !== null &&
+          (update as { kind?: string; sandboxAlive?: boolean }).kind ===
+            "status" &&
+          (update as { sandboxAlive?: boolean }).sandboxAlive === false,
+      ),
+    );
+  });
+
   it("replays a current snapshot when a subscriber attaches to an existing watcher", async () => {
     const updates: unknown[] = [];
     service.on(CloudTaskEvent.Update, (payload) => updates.push(payload));