fix(cloud-task): restore pending permission request on renderer reload

A cloud task that is awaiting a permission/plan approval keeps that
request only as a transient SSE `permission_request` event — it is never
persisted to session_logs. When the renderer reloads (or a second
subscriber attaches) the watcher re-emits a snapshot built from
session_logs alone, so the pending request is dropped and the approve/
deny UI never returns. The user is then forced to cancel and type a
message instead of answering, effectively bypassing the gate (see
#1833).

Track unanswered permission requests on the main-process watcher (which
survives a renderer reload) and replay them right after each
`emitCurrentSnapshot`, so a reconnecting renderer rebuilds its pending-
permission state. The handler keys on toolCallId, so replay is
idempotent. Entries are cleared when the request is answered
(permission_response), when the turn is cancelled, and when the run
reaches a terminal status.

Scope: this covers renderer reload / re-subscribe, where the main
process stays alive. A full app restart tears down the watcher, so
restoring after restart still requires the backend to re-surface the
pending request on a fresh stream — tracked separately.

Author: tatoalo

apps/code/src/main/services/cloud-task/service.test.ts

@@ -459,6 +459,109 @@ describe("CloudTaskService", () => {
     await waitFor(() => getWatcherEmittedEntryCount() === 0);
   });
 
+  it("replays a pending permission request on snapshot until it is answered", async () => {
+    const updates: unknown[] = [];
+    service.on(CloudTaskEvent.Update, (payload) => updates.push(payload));
+
+    const runResponse = {
+      id: "run-1",
+      status: "in_progress",
+      stage: "agent",
+      output: null,
+      error_message: null,
+      branch: "main",
+      updated_at: "2026-01-01T00:00:00Z",
+    };
+    const permissionEvent = {
+      type: "permission_request",
+      requestId: "req-1",
+      toolCall: { toolCallId: "tool-1", title: "Approve?", kind: "other" },
+      options: [],
+    };
+    // Route by URL so the test is robust to call ordering: run-state, session
+    // logs (always empty here), and command responses.
+    mockNetFetch.mockImplementation(async (input: string | Request) => {
+      const url = typeof input === "string" ? input : input.url;
+      if (url.includes("/session_logs/")) {
+        return createJsonResponse([], 200, { "X-Has-More": "false" });
+      }
+      if (url.includes("/command/")) {
+        return createJsonResponse({ result: {} });
+      }
+      return createJsonResponse(runResponse);
+    });
+
+    mockStreamFetch.mockResolvedValueOnce(
+      createOpenSseResponse(
+        `id: 1\ndata: ${JSON.stringify(permissionEvent)}\n\n`,
+      ),
+    );
+
+    const permissionUpdates = () =>
+      updates.filter(
+        (u) =>
+          typeof u === "object" &&
+          u !== null &&
+          (u as { kind?: string }).kind === "permission_request",
+      );
+
+    service.watch({
+      taskId: "task-1",
+      runId: "run-1",
+      apiHost: "https://app.example.com",
+      teamId: 2,
+    });
+
+    // Live permission request surfaces once over the stream.
+    await waitFor(() => permissionUpdates().length === 1);
+
+    // A renderer reload re-subscribes to the still-alive watcher; the pending
+    // permission must be replayed so the approve/deny UI comes back.
+    service.watch({
+      taskId: "task-1",
+      runId: "run-1",
+      apiHost: "https://app.example.com",
+      teamId: 2,
+    });
+
+    await waitFor(() => permissionUpdates().length === 2);
+    expect(permissionUpdates()[1]).toEqual({
+      taskId: "task-1",
+      runId: "run-1",
+      kind: "permission_request",
+      requestId: "req-1",
+      toolCall: permissionEvent.toolCall,
+      options: [],
+    });
+
+    // Answering the request clears it, so later re-subscribes do not replay it.
+    const result = await service.sendCommand({
+      taskId: "task-1",
+      runId: "run-1",
+      apiHost: "https://app.example.com",
+      teamId: 2,
+      method: "permission_response",
+      params: { requestId: "req-1", optionId: "allow" },
+    });
+    expect(result.success).toBe(true);
+
+    const snapshotCount = () =>
+      updates.filter((u) => (u as { kind?: string }).kind === "snapshot")
+        .length;
+    const snapshotsBefore = snapshotCount();
+
+    service.watch({
+      taskId: "task-1",
+      runId: "run-1",
+      apiHost: "https://app.example.com",
+      teamId: 2,
+    });
+
+    // Wait for the re-subscribe snapshot, then confirm no permission replay.
+    await waitFor(() => snapshotCount() > snapshotsBefore);
+    expect(permissionUpdates().length).toBe(2);
+  });
+
   it("ignores keepalive SSE events while keeping the stream open", async () => {
     const updates: unknown[] = [];
     service.on(CloudTaskEvent.Update, (payload) => updates.push(payload));

apps/code/src/main/services/cloud-task/service.ts

@@ -102,6 +102,7 @@ interface WatcherState {
   lastErrorMessage: string | null;
   lastBranch: string | null;
   lastStatusUpdatedAt: string | null;
+  pendingPermissionRequests: Map<string, PermissionRequestEventData>;
   isBootstrapping: boolean;
   hasEmittedSnapshot: boolean;
   bufferedLogBatches: StoredLogEntry[][];
@@ -375,6 +376,8 @@ export class CloudTaskService extends TypedEventEmitter<CloudTaskEvents> {
         method: input.method,
       });
 
+      this.clearPendingPermissionForCommand(input);
+
       return { success: true, result: data.result };
     } catch (error) {
       const errorMessage =
@@ -388,6 +391,21 @@ export class CloudTaskService extends TypedEventEmitter<CloudTaskEvents> {
     }
   }
 
+  private clearPendingPermissionForCommand(input: SendCommandInput): void {
+    const watcher = this.watchers.get(watcherKey(input.taskId, input.runId));
+    if (!watcher) return;
+
+    if (input.method === "permission_response") {
+      const requestId = (input.params as { requestId?: string } | undefined)
+        ?.requestId;
+      if (requestId) {
+        watcher.pendingPermissionRequests.delete(requestId);
+      }
+    } else if (input.method === "cancel") {
+      watcher.pendingPermissionRequests.clear();
+    }
+  }
+
   @preDestroy()
   unwatchAll(): void {
     for (const key of [...this.watchers.keys()]) {
@@ -419,6 +437,7 @@ export class CloudTaskService extends TypedEventEmitter<CloudTaskEvents> {
       lastErrorMessage: null,
       lastBranch: null,
       lastStatusUpdatedAt: null,
+      pendingPermissionRequests: new Map(),
       isBootstrapping: false,
       hasEmittedSnapshot: false,
       bufferedLogBatches: [],
@@ -789,6 +808,7 @@ export class CloudTaskService extends TypedEventEmitter<CloudTaskEvents> {
     }
 
     if (isPermissionRequestEvent(event.data)) {
+      watcher.pendingPermissionRequests.set(event.data.requestId, event.data);
       this.emit(CloudTaskEvent.Update, {
         taskId: watcher.taskId,
         runId: watcher.runId,
@@ -975,6 +995,28 @@ export class CloudTaskService extends TypedEventEmitter<CloudTaskEvents> {
       errorMessage: watcher.lastErrorMessage,
       branch: watcher.lastBranch,
     });
+
+    this.replayPendingPermissionRequests(watcher);
+  }
+
+  private replayPendingPermissionRequests(watcher: WatcherState): void {
+    if (
+      watcher.pendingPermissionRequests.size === 0 ||
+      isTerminalStatus(watcher.lastStatus)
+    ) {
+      return;
+    }
+
+    for (const pending of watcher.pendingPermissionRequests.values()) {
+      this.emit(CloudTaskEvent.Update, {
+        taskId: watcher.taskId,
+        runId: watcher.runId,
+        kind: "permission_request" as const,
+        requestId: pending.requestId,
+        toolCall: pending.toolCall,
+        options: pending.options,
+      });
+    }
   }
 
   private failWatcher(key: string, error: CloudTaskConnectionError): void {
@@ -1234,6 +1276,10 @@ export class CloudTaskService extends TypedEventEmitter<CloudTaskEvents> {
       watcher.lastStatusUpdatedAt = updatedAt;
     }
 
+    if (isTerminalStatus(watcher.lastStatus)) {
+      watcher.pendingPermissionRequests.clear();
+    }
+
     return changed;
   }