@@ -840,7 +840,7 @@ it.effect(
     ),
 );
 
-it.effect("an app task waits for what its child's native subagent delegated, then its answer", () =>
+it.effect("an app task waits for its child's nested native work and tasks, then its answer", () =>
   Effect.scoped(
     Effect.gen(function* () {
       const h = yield* makeHarness("mixed-delegation-chain");
@@ -849,20 +849,27 @@ it.effect("an app task waits for what its child's native subagent delegated, the
       yield* h.startRoot(rootThreadId, "provider-session:mixed-root");
       const outer = yield* h.delegate(rootScope, "outer");
       const sentinel = yield* h.delegate(rootScope, "sentinel");
+      const wakeSentinel = yield* h.delegate(rootScope, "wake-sentinel");
       const outerThreadId = outer.childThreadId!;
       const outerTurn = h.childTurn(outerThreadId);
       const child = yield* h.orchestrator.getThreadProjection(outerThreadId);
       const childRun = child.runs[0]!;
       yield* h.mcpSessions.set(sessionFor(outerThreadId, "provider-session:mixed-child"));
 
-      // The outer task's child runs a native subagent, which delegates in turn.
+      // The outer task's child runs a native subagent, which delegates and runs its own.
       const native = h.nativeTask({
         name: "mixed",
         listing: child.thread,
         parentNodeId: childRun.rootNodeId!,
         execution: { threadId: outerThreadId, runId: childRun.id },
       });
-      yield* h.project(outerTurn, [native]);
+      const nested = h.nativeTask({
+        name: "mixed-nested",
+        listing: native.thread,
+        parentNodeId: native.rootNodeId,
+        execution: { threadId: outerThreadId, runId: childRun.id },
+      });
+      yield* h.project(outerTurn, [native, nested]);
       yield* h.mcpSessions.bindNativeCaller({
         threadId: outerThreadId,
         callId: "claude-tool:mixed",
@@ -909,8 +916,28 @@ it.effect("an app task waits for what its child's native subagent delegated, the
       const wakeTurn = h.childTurn(outerThreadId);
       assert.notStrictEqual(wakeTurn, outerTurn);
       assert.isNull((yield* h.listed(rootThreadId, outer.taskId)).task?.result ?? null);
-      const settled = yield* h.taskSettles(outer.taskId);
+
+      // The wake ends while the nested native subagent still runs, so the answer waits for it.
+      const wakeSentinelSettles = yield* h.taskSettles(wakeSentinel.taskId);
       yield* h.finishTurn(wakeTurn);
+      yield* h.finishTurn(h.childTurn(wakeSentinel.childThreadId));
+      yield* Fiber.join(wakeSentinelSettles);
+      assert.equal((yield* h.listed(nested.task.threadId, nested.task.id)).task?.status, "running");
+      const nestedWaiting = yield* h.service.taskStatus(rootScope, outer.taskId);
+      assert.equal(nestedWaiting.workState, "waiting_for_children");
+      assert.isNull((yield* h.listed(rootThreadId, outer.taskId)).task?.result ?? null);
+
+      const settled = yield* h.taskSettles(outer.taskId);
+      yield* Queue.offer(outerTurn.events, {
+        type: "subagent.updated",
+        driver,
+        subagent: {
+          ...nested.task,
+          status: "completed",
+          result: "Nested work done.",
+          completedAt: nested.task.startedAt,
+        },
+      });
       yield* Fiber.join(settled);
       assert.equal((yield* h.listed(rootThreadId, outer.taskId)).task?.status, "completed");
     }),
 
@@ -1609,7 +1609,7 @@ const make = Effect.gen(function* () {
       .pipe(Effect.mapError(threadManagementFailure));
     const childRun = delegatedTaskRun(childControls, task);
     const terminalRun = latestTerminalResultRun(childControls, childRun);
-    // Tasks the child's native subagents delegated keep it working, as its own tasks do.
+    // Tasks the child's native subagents delegated or run keep it working, as its own tasks do.
     const progress = delegatedTaskProgress({
       ...childControls,
       subagents: [
@@ -1619,6 +1619,7 @@ const make = Effect.gen(function* () {
               .getTasksExecutedElsewhere({
                 threadId: task.childThreadId,
                 runIds: childControls.runs.map((run) => run.id),
+                includeProviderNative: true,
               })
               .pipe(Effect.mapError(threadManagementFailure))
           : []),
 
@@ -413,6 +413,7 @@ export interface OrchestratorV2Shape {
   readonly getTasksExecutedElsewhere: (input: {
     readonly threadId: ThreadId;
     readonly runIds: ReadonlyArray<RunId>;
+    readonly includeProviderNative?: boolean;
   }) => Effect.Effect<ReadonlyArray<OrchestrationV2Subagent>, OrchestratorV2Error>;
   readonly getThreadProjection: (
     threadId: ThreadId,
@@ -1286,9 +1287,14 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
     function* <P extends Pick<OrchestrationV2ThreadProjection, "thread" | "subagents">>(
       projection: P,
       runIds: ReadonlyArray<RunId>,
+      includeProviderNative = false,
     ) {
       const elsewhere = yield* projectionStore
-        .getTasksExecutedElsewhere({ threadId: projection.thread.id, runIds })
+        .getTasksExecutedElsewhere({
+          threadId: projection.thread.id,
+          runIds,
+          includeProviderNative,
+        })
         .pipe(
           Effect.mapError(
             (cause) => new OrchestratorProjectionError({ threadId: projection.thread.id, cause }),
@@ -1302,7 +1308,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
 
   /**
    * A thread's progress, read with its whole task list: only a thread listing a native subagent
-   * can have tasks listed elsewhere that its runs execute.
+   * can have tasks listed elsewhere that its runs execute, including nested native subagents.
    */
   const withNativeSubagentDelegations = <
     P extends Pick<OrchestrationV2ThreadProjection, "thread" | "subagents" | "runs">,
@@ -1313,6 +1319,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
       ? withTasksExecutedElsewhere(
           projection,
           projection.runs.map((run) => run.id),
+          true,
         )
       : Effect.succeed(projection);
 
 
@@ -451,11 +451,12 @@ export interface ProjectionStoreV2Shape {
   readonly getSubagentCount: (threadId: ThreadId) => Effect.Effect<number, ProjectionStoreV2Error>;
   /**
    * App-owned tasks the thread's runs execute but another thread lists: those a native
-   * subagent of its session delegated.
+   * subagent of its session delegated. Progress also needs its nested native subagents.
    */
   readonly getTasksExecutedElsewhere: (input: {
     readonly threadId: ThreadId;
     readonly runIds: ReadonlyArray<RunId>;
+    readonly includeProviderNative?: boolean;
   }) => Effect.Effect<ReadonlyArray<OrchestrationV2Subagent>, ProjectionStoreV2Error>;
   readonly getNextTurnItemOrdinal: (
     threadId: ThreadId,
@@ -5350,11 +5351,13 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
     const getTasksExecutedElsewhere: ProjectionStoreV2Shape["getTasksExecutedElsewhere"] = ({
       threadId,
       runIds,
+      includeProviderNative = false,
     }) =>
       runIds.length === 0
         ? Effect.succeed([])
         : sql<PayloadRow>`SELECT payload_json FROM orchestration_v2_projection_subagents
-            WHERE origin = 'app_owned' AND run_id IN ${sql.in(runIds)} AND thread_id != ${threadId}
+            WHERE run_id IN ${sql.in(runIds)} AND thread_id != ${threadId}
+              ${includeProviderNative ? sql`` : sql`AND origin = 'app_owned'`}
             ORDER BY subagent_id ASC`.pipe(
             Effect.mapError(controlReadError(threadId)),
             Effect.flatMap(decodeRows(decodeSubagentPayload, threadId)),
 
@@ -4,11 +4,11 @@ import * as SqlClient from "effect/sql/SqlClient";
 export default Effect.gen(function* () {
   const sql = yield* SqlClient.SqlClient;
 
-  // A task a native subagent delegated is listed in that subagent's thread but executed by its
-  // session's root run, so delivery and Stop find it by run instead of by thread.
+  // Tasks a native subagent delegated and its nested native subagents are listed in that
+  // subagent's thread but executed by its session's root run, so delivery, Stop and progress
+  // find them by run instead of by thread.
   yield* sql`
-    CREATE INDEX orchestration_v2_projection_subagents_app_owned_run_idx
+    CREATE INDEX orchestration_v2_projection_subagents_run_idx
     ON orchestration_v2_projection_subagents(run_id)
-    WHERE origin = 'app_owned'
   `;
 });