fix(server): Claude background subagents get approvals after the root turn ends#20347

@@ -2738,6 +2588,10 @@ describe("ClaudeAdapterV2 background wake turns", () => {
         yield* Queue.unbounded<
           Extract<ProviderAdapter.ProviderAdapterV2Event, { type: "subagent.updated" }>
         >();
+      const runtimeRequestReceipts =
+        yield* Queue.unbounded<
+          Extract<ProviderAdapter.ProviderAdapterV2Event, { type: "runtime_request.updated" }>
+        >();

@@ -8689,8 +8623,32 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
           toolName: Parameters<CanUseTool>[0],
           toolInput: Parameters<CanUseTool>[1],
           callbackOptions: Parameters<CanUseTool>[2],
+          owningQueryClosed?: Deferred.Deferred<void, never>,
         ) {
-          const context = yield* Ref.get(activeTurn);
+          let context = yield* Ref.get(activeTurn);
+          const settled = context === null;
+          if (settled && !callbackOptions.signal.aborted) {
+            const live = yield* Ref.get(queryContext);
+            const previous =
+              live === null ? undefined : settledTurnByNativeThread.get(live.nativeThreadId);
+            if (
+              live !== null &&
+              !live.stopping &&
+              live.closed === owningQueryClosed &&
+              previous !== undefined
+            ) {
+              // Only this run still ingests its subagent's approval after the root result.
+              const subagents = yield* Ref.get(sessionSubagentsByTaskId);
+              const running = [...subagents].some(
+                ([taskId, subagent]) =>
+                  (callbackOptions.agentID === undefined || callbackOptions.agentID === taskId) &&
+                  subagent.task.status === "running" &&
+                  subagent.task.runId === previous.input.runId &&

@@ -5759,6 +5759,211 @@ describe("ClaudeAdapterV2 background wake turns", () => {
     ),
   );
 
+  it.effect.each([
+    "accept",
+    "decline",
+    "full-access",
+    "without-agent-id",
+    "no-subagent",
+    "earlier-run",
+    "wrong-agent",
+    "aborted",
+    "stopping",
+    "replaced-process",
+    "resumed",
+  ] as const)("handles a settled subagent permission request: %s", (scenario) =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const closeStarted = yield* Deferred.make<void>();
+        const finishClose = yield* Deferred.make<void>();
+        const harness = yield* makeWakeHarnessWithOptions({
+          freshQueueOnReopen: true,
+          close: (messages) =>
+            scenario === "stopping"
+              ? Deferred.succeed(closeStarted, undefined).pipe(
+                  Effect.andThen(Deferred.await(finishClose)),
+                  Effect.andThen(Queue.shutdown(messages)),
+                )
+              : Queue.shutdown(messages),
+        });
+        const now = yield* DateTime.now;
+        const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
+          runtimeMode: scenario === "full-access" ? "full-access" : "approval-required",
+          interactionMode: "default",
+          cwd: "/workspace",
+        });
+        const start = (ordinal: number) =>
+          harness.runtime.startTurn(
+            makeClaudeTestTurnInput({
+              threadId: harness.threadId,
+              providerThread: harness.providerThread,
+              now,
+              attemptId: RunAttemptId.make(`attempt-idle-permission-${ordinal}`),
+              providerTurnOrdinal: ordinal,
+              text: "Start the subagent, then return.",
+              attachments: [],
+              runtimePolicy,
+            }),
+          );
+        const taskStarted = (toolUseId: string) =>
+          claudeSdkFrame({
+            type: "system",
+            subtype: "task_started",
+            task_id: "idle-permission-agent",
+            tool_use_id: toolUseId,
+            description: "Background permission probe",
+            subagent_type: "general-purpose",
+            task_type: "local_agent",
+            is_backgrounded: true,
+            prompt: "Read a file after the parent returns.",
+            uuid: `idle-permission-${toolUseId}`,
+            session_id: WAKE_NATIVE_SESSION,
+          });
+        const resultFrame = (ordinal: number) =>
+          makeResultFrame({ uuid: `idle-permission-result-${ordinal}`, result: "Started." });
+        yield* start(1);
+        const callback = harness.getOpenedOptions()!.canUseTool!;
+        if (scenario !== "no-subagent") {
+          yield* harness.offerAndWait(taskStarted("idle-launch"));
+        }
+        if (scenario === "resumed") {
+          yield* harness.offerAndWait(
+            claudeSdkFrame({
+              type: "system",
+              subtype: "task_notification",
+              task_id: "idle-permission-agent",
+              tool_use_id: "idle-launch",
+              status: "completed",
+              output_file: "/tmp/idle-permission-agent.output",
+              summary: "First answer.",
+              uuid: "idle-permission-completed",
+              session_id: WAKE_NATIVE_SESSION,
+            }),
+          );
+        }
+        yield* harness.offerAndWait(resultFrame(1));
+        yield* Queue.take(harness.terminalReceipts);
+        const stop =
+          scenario === "stopping" || scenario === "replaced-process"
+            ? yield* harness.runtime
+                .interruptTurn({
+                  providerThread: harness.providerThread,
+                  providerTurnId: harness.terminalEvents()[0]!.providerTurnId,
+                  requestRuntimeRestart: true,
+                })
+                .pipe(Effect.forkScoped)
+            : null;
+        if (scenario === "stopping") yield* Deferred.await(closeStarted);
+        else if (stop !== null) yield* Fiber.join(stop);
+        if (
+          scenario === "earlier-run" ||
+          scenario === "resumed" ||
+          scenario === "replaced-process"
+        ) {
+          yield* start(2);
+          if (scenario === "replaced-process") {
+            yield* Queue.offer(harness.processQueues[1]!, taskStarted("replacement-launch"));
+            yield* Queue.take(harness.subagentReceipts);
+            yield* Queue.offer(harness.processQueues[1]!, resultFrame(2));
+          } else {
+            if (scenario === "resumed") {
+              yield* harness.offerAndWait(taskStarted("idle-send-message"));
+            }
+            yield* harness.offerAndWait(resultFrame(2));
+          }
+          yield* Queue.take(harness.terminalReceipts);
+        }
+        const controller = new AbortController();
+        if (scenario === "aborted") controller.abort();
+        let callbackReturned = false;
+        const permission = yield* Effect.promise(async () => {
+          const decision = await callback(
+            "Read",
+            { file_path: "/etc/hosts" },
+            {
+              signal: controller.signal,
+              toolUseID: "idle-read",
+              requestId: "idle-permission-request",
+              ...(scenario === "without-agent-id"
+                ? {}
+                : {
+                    agentID: scenario === "wrong-agent" ? "another-agent" : "idle-permission-agent",
+                  }),
+            },
+          );
+          callbackReturned = true;
+          return decision;
+        }).pipe(Effect.forkScoped);
+        const needsApproval =
+          scenario === "accept" ||
+          scenario === "decline" ||
+          scenario === "resumed" ||
+          scenario === "without-agent-id";
+        if (needsApproval) {
+          yield* awaitUntil(
+            () =>
+              callbackReturned ||
+              harness.events.some((event) => event.type === "runtime_request.updated"),
+            "settled subagent approval",
+          );
+          const request = harness.events.findLast(
+            (event) => event.type === "runtime_request.updated",
+          );
+          assert.equal(request?.type, "runtime_request.updated");
+          if (request?.type !== "runtime_request.updated") return;
+          assert.equal(
+            request.runtimeRequest.providerTurnId,
+            harness.terminalEvents().at(-1)!.providerTurnId,
+          );
+          const node = harness.events.findLast(
+            (event) =>
+              event.type === "node.updated" && event.node.id === request.runtimeRequest.nodeId,
+          );
+          assert.equal(
+            node?.type === "node.updated" ? node.node.parentNodeId : null,
+            node?.type === "node.updated" ? node.node.rootNodeId : undefined,
+          );