Commit c572cb71d2711d8cdb4ff7e0ba88af5e9a23aa81 | the-knife

apps/server/src/mcp/OrchestratorMcpService.test.ts+10-1

...	@@ -200,7 +200,16 @@ describe("OrchestratorMcpService", () => {	...	@@ -200,7 +200,16 @@ describe("OrchestratorMcpService", () => {
200	} as unknown as OrchestrationV2ThreadProjection;	200	} as unknown as OrchestrationV2ThreadProjection;
201	const childProjection = {	201	const childProjection = {
202	thread: { id: childThreadId },	202	thread: { id: childThreadId },
203	runs: [{ id: RunId.make("run:mcp-restart-child"), ordinal: 1, status: "cancelled" }],	203	runs: [
		204	{
		205	id: RunId.make("run:mcp-restart-child"),
		206	ordinal: 1,
		207	status: "cancelled",
		208	delegatedTaskId: taskId,
		209	},
		210	// An unrelated later run cannot supply this follow-up's result.
		211	{ id: RunId.make("run:mcp-restart-later"), ordinal: 2, status: "running" },
		212	],
204	contextTransfers: [],	213	contextTransfers: [],
205	messages: [],	214	messages: [],
206	subagents: [],	215	subagents: [],

apps/server/src/mcp/OrchestratorMcpService.ts+109-54

 @@ -351,6 +351,8 @@ export function delegatedTaskRun(
   childProjection: Pick<OrchestrationV2ThreadProjection, "runs" | "contextTransfers">,
   task: OrchestrationV2Subagent,
 ): OrchestrationV2Run | undefined {
+  const taskRun = childProjection.runs.find((run) => run.delegatedTaskId === task.id);
+  if (taskRun !== undefined) return taskRun;
   const spawnTransfer = childProjection.contextTransfers.find(
     (transfer) =>
       transfer.type === "subagent_spawn" &&
 @@ -390,22 +392,62 @@ function isTerminalTaskStatus(
   );
 }
-function directAppOwnedChildTask(
+function directAppOwnedChildTasks(
   parent: Pick<OrchestrationV2ThreadProjection, "thread" | "subagents">,
-  target: Pick<OrchestrationV2ThreadProjection, "thread">,
+  target: Pick<OrchestrationV2ThreadProjection, "thread" | "runs">,
-): OrchestrationV2Subagent | undefined {
+  returnedRunIds: ReadonlySet<RunId | null>,
+): ReadonlyArray<OrchestrationV2Subagent> {
   if (
     target.thread.lineage.parentThreadId !== parent.thread.id ||
     target.thread.lineage.relationshipToParent !== "subagent"
   ) {
-    return undefined;
+    return [];
   }
-  return parent.subagents.find(
+  const original = parent.subagents.find(
     (task) =>
       task.origin === "app_owned" &&
       task.threadId === parent.thread.id &&
+      task.id ===
+        (target.thread.forkedFrom?.type === "node" ? target.thread.forkedFrom.nodeId : undefined) &&
       task.childThreadId === target.thread.id,
   );
+  const taskIds = new Set(
+    target.runs
+      .filter((run) => returnedRunIds.has(run.id))
+      .map((run) => run.delegatedTaskId ?? original?.id),
+  );
+  return parent.subagents.filter(
+    (task) =>
+      taskIds.has(task.id) &&
+      task.origin === "app_owned" &&
+      task.childThreadId === target.thread.id,
+  );
+}
+function taskResultTransfer(
+  parent: Pick<OrchestrationV2ThreadProjection, "thread" | "contextTransfers">,
+  child: Pick<OrchestrationV2ThreadProjection, "runs" | "contextTransfers">,
+  task: OrchestrationV2Subagent,
+) {
+  const originalRun = delegatedTaskRun(child, task);
+  const resultRunIds = new Set(
+    child.runs
+      .filter(
+        (run) =>
+          run.delegatedTaskId === task.id ||
+          (originalRun?.delegatedTaskId === undefined && run.delegatedTaskId === undefined),
+      )
+      .map((run) => run.id),
+  );
+  if (originalRun !== undefined) resultRunIds.add(originalRun.id);
+  return parent.contextTransfers.find(
+    (transfer) =>
+      transfer.type === "subagent_result" &&
+      transfer.sourceThreadId === task.childThreadId &&
+      transfer.targetThreadId === parent.thread.id &&
+      ((transfer.sourcePoint.runId !== undefined && resultRunIds.has(transfer.sourcePoint.runId)) ||
+        (transfer.sourcePoint.runId === undefined && originalRun?.delegatedTaskId === undefined)),
+  );
 }
 function pageIncludesTerminalTaskResult(input: {
 @@ -418,12 +460,7 @@ function pageIncludesTerminalTaskResult(input: {
   >;
   readonly maxChars: number;
 }): boolean {
-  const transfer = input.parent.contextTransfers.find(
+  const transfer = taskResultTransfer(input.parent, input.target, input.task);
-    (transfer) =>
-      transfer.type === "subagent_result" &&
-      transfer.sourceThreadId === input.target.thread.id &&
-      transfer.targetThreadId === input.parent.thread.id,
-  );
   if (transfer === undefined) return false;
   const run =
     transfer.sourcePoint.runId === undefined
 @@ -1241,9 +1278,21 @@ const make = Effect.gen(function* () {
       const childRun = delegatedTaskRun(childControls, task);
       const terminalRun = latestTerminalResultRun(childControls, childRun);
       const progress = delegatedTaskProgress(childControls);
+      const taskResultRun =
+        childRun?.delegatedTaskId === task.id
+          ? childControls.runs
+              .filter((run) => run.delegatedTaskId === task.id)
+              .toSorted((a, b) => b.ordinal - a.ordinal)[0]
+          : progress.resultRun;
+      const taskWorkState =
+        childRun?.delegatedTaskId === task.id
+          ? isTerminalTaskStatus(taskStatusForRun(taskResultRun))
+            ? "result_available"
+            : "working"
+          : progress.state;
       const resultRunIds = [
         ...new Set(
-          [progress.resultRun?.id, terminalRun?.id].filter((id): id is RunId => id !== undefined),
+          [taskResultRun?.id, terminalRun?.id].filter((id): id is RunId => id !== undefined),
         ),
       ];
       const resultRecords = yield* threadManagement
 @@ -1263,12 +1312,12 @@ const make = Effect.gen(function* () {
       // the child started working again after this read.
       const heldForRestart =
         task.result === null &&
-        progress.state === "result_available" &&
+        taskWorkState === "result_available" &&
         (yield* threadManagement
-          .delegatedTaskResultPending(task.childThreadId)
+          .delegatedTaskResultPending(task.childThreadId, childRun?.delegatedTaskId)
           .pipe(Effect.mapError(threadManagementFailure)));
       const workState =
-        task.result !== null ? "result_available" : heldForRestart ? "working" : progress.state;
+        task.result !== null ? "result_available" : heldForRestart ? "working" : taskWorkState;
       const status =
         task.result !== null
           ? taskStatusForRun(
 @@ -1280,15 +1329,15 @@ const make = Effect.gen(function* () {
                 : childRun,
             )
           : workState === "result_available"
-            ? taskStatusForRun(progress.resultRun ?? childRun)
+            ? taskStatusForRun(taskResultRun ?? childRun)
-            : taskStatusForRun(childRun) === "queued"
+            : taskStatusForRun(taskResultRun ?? childRun) === "queued"
               ? "queued"
               : "running";
       const derivedResult =
         task.result !== null
           ? task.result
-          : progress.resultRun !== undefined && isTerminalTaskStatus(status)
+          : taskResultRun !== undefined && isTerminalTaskStatus(status)
-            ? subagentResultForRun(childProjection, progress.resultRun).text
+            ? subagentResultForRun(childProjection, taskResultRun).text
             : null;
       const resultTransfers = parentProjection.contextTransfers.filter(
         (transfer) =>
 @@ -1304,7 +1353,7 @@ const make = Effect.gen(function* () {
               ? resultTransfers.find((transfer) => transfer.sourcePoint.runId === undefined)
               : undefined) ??
             null);
-      const resultTransfer = resultTransfers[0] ?? null;
+      const resultTransfer = taskResultTransfer(parentProjection, childProjection, task) ?? null;
       const terminalStatus = terminalRun === undefined ? null : taskStatusForRun(terminalRun);
       const response = {
         taskId: task.id,
 @@ -2315,45 +2364,48 @@ const make = Effect.gen(function* () {
           { concurrency: 1 },
         );
         const messagesByThreadId = new Map(sourceMessages);
-        const task = parent === undefined ? undefined : directAppOwnedChildTask(parent, target);
+        const returnedRunIds = new Set(
+          page
+            .filter((row) => row.sourceThreadId === target.thread.id)
+            .map((row) => row.item.runId),
+        );
+        const tasks =
+          parent === undefined ? [] : directAppOwnedChildTasks(parent, target, returnedRunIds);
         if (
           parent !== undefined &&
           scope.thread !== undefined &&
-          task !== undefined &&
+          tasks.length > 0 &&
           (input.textOffset ?? 0) === 0
         ) {
-          const transfer = parent.contextTransfers.find(
+          for (const task of tasks) {
-            (transfer) =>
+            const transfer = taskResultTransfer(parent, target, task);
-              transfer.type === "subagent_result" &&
+            const resultRunId = transfer?.sourcePoint.runId ?? delegatedTaskRun(target, task)?.id;
-              transfer.sourceThreadId === target.thread.id &&
+            const resultRunIds = resultRunId === undefined ? [] : [resultRunId];
-              transfer.targetThreadId === parent.thread.id,
+            const resultRecords = yield* threadManagement
-          );
+              .getThreadRecords(target.thread.id, ["messages", "turnItems"], {
-          const resultRunId = transfer?.sourcePoint.runId ?? delegatedTaskRun(target, task)?.id;
+                messageRoles: ["assistant"],
-          const resultRunIds = resultRunId === undefined ? [] : [resultRunId];
+                messageRunIds: resultRunIds,
-          const resultRecords = yield* threadManagement
+                turnItemRunIds: resultRunIds,
-            .getThreadRecords(target.thread.id, ["messages", "turnItems"], {
+                turnItemTypes: ["assistant_message", "error"],
-              messageRoles: ["assistant"],
+              })
-              messageRunIds: resultRunIds,
+              .pipe(Effect.mapError(threadManagementFailure));
-              turnItemRunIds: resultRunIds,
+            if (
-              turnItemTypes: ["assistant_message", "error"],
+              pageIncludesTerminalTaskResult({
-            })
+                parent,
-            .pipe(Effect.mapError(threadManagementFailure));
+                page,
-          if (
+                task,
-            pageIncludesTerminalTaskResult({
+                target: { ...target, ...resultRecords },
-              parent,
+                maxChars,
-              page,
+              })
-              task,
+            ) {
-              target: { ...target, ...resultRecords },
+              yield* readTask(
-              maxChars,
+                scope as McpThreadInvocationScope,
-            })
+                task.id,
-          ) {
+                false,
-            yield* readTask(
+                true,
-              scope as McpThreadInvocationScope,
+                "thread-read-acknowledge",
-              task.id,
+              );
-              false,
+            }
-              true,
-              "thread-read-acknowledge",
-            );
           }
         }
         return {
 @@ -2419,6 +2471,9 @@ const make = Effect.gen(function* () {
           threadId: input.threadId,
           messageId,
           runId: result.run.id,
+          ...(result.run.delegatedTaskId === undefined
+            ? {}
+            : { taskId: result.run.delegatedTaskId }),
           status: result.run.status,
           delivery: result.delivery,
         } satisfies OrchestratorMcpThreadSendResult;

apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts+75-5

...	@@ -1782,6 +1782,9 @@ describe("orchestrator MCP toolkit", () => {	...	@@ -1782,6 +1782,9 @@ describe("orchestrator MCP toolkit", () => {
1782	expect(delegatedStatus.resultContextTransferId).not.toBeNull();	1782	expect(delegatedStatus.resultContextTransferId).not.toBeNull();
1783	expect(delegatedStatus.latestTerminalResultContextTransferId).not.toBeNull();	1783	expect(delegatedStatus.latestTerminalResultContextTransferId).not.toBeNull();
1784		1784
		1785	// Wait-mode completion already returned its result while the parent was live.
		1786	yield* expectOffersToStay(0);
		1787
1785	const childFollowupCall = yield* invoke("t3_thread_send", {	1788	const childFollowupCall = yield* invoke("t3_thread_send", {
1786	threadId: delegated.childThreadId,	1789	threadId: delegated.childThreadId,
1787	message: "Confirm the delegated API boundary remains inspected.",	1790	message: "Confirm the delegated API boundary remains inspected.",
...	@@ -1924,10 +1927,14 @@ describe("orchestrator MCP toolkit", () => {	...	@@ -1924,10 +1927,14 @@ describe("orchestrator MCP toolkit", () => {
1924	latestTerminalStatus: "interrupted",	1927	latestTerminalStatus: "interrupted",
1925	});	1928	});
1926		1929
1927	// A wait-mode child (completionWake settled_only) that completes	1930	// Later requested work has its own delivery, including an interrupted follow-up.
1928	// while the parent run is live does not offer a wake: the	1931	expect(childFollowup.taskId).toBeDefined();
1929	// blocking delegate_task call above already returned the result.	1932	expect(activeChildFollowup.taskId).toBeDefined();
1930	yield* expectOffersToStay(0);	1933	yield* waitForContinuationOffers(2);
		1934	yield* expectOffersToStay(2);
		1935	yield* invoke("task_status", { taskId: childFollowup.taskId });
		1936	yield* invoke("task_status", { taskId: activeChildFollowup.taskId });
		1937	yield* Ref.set(continuationOffers, []);
1931		1938
1932	const repeatedDelegatedCall = yield* invoke("delegate_task", {	1939	const repeatedDelegatedCall = yield* invoke("delegate_task", {
1933	task: delegatedPrompt,	1940	task: delegatedPrompt,
...	@@ -4007,6 +4014,18 @@ describe("orchestrator MCP toolkit", () => {	...	@@ -4007,6 +4014,18 @@ describe("orchestrator MCP toolkit", () => {
4007	const pendingProjection = yield* orchestrator.getThreadProjection(	4014	const pendingProjection = yield* orchestrator.getThreadProjection(
4008	delegated.childThreadId,	4015	delegated.childThreadId,
4009	);	4016	);
		4017	const followupTasks = (yield* orchestrator.getThreadProjection(
		4018	parentThreadId,
		4019	)).subagents.filter(
		4020	(task) =>
		4021	task.childThreadId === delegated.childThreadId && task.id !== delegated.taskId,
		4022	);
		4023	expect(followupTasks).toHaveLength(2);
		4024	expect(followupTasks.every((task) => task.result === null)).toBe(true);
		4025	expect(followupTasks.map((task) => task.id)).toEqual([
		4026	runningFollowup.taskId,
		4027	queuedFollowup.taskId,
		4028	]);
4010	expect(	4029	expect(
4011	pendingProjection.runs.find((run) => run.id === delegated.childRunId)?.status,	4030	pendingProjection.runs.find((run) => run.id === delegated.childRunId)?.status,
4012	).toBe("completed");	4031	).toBe("completed");
...	@@ -4082,6 +4101,47 @@ describe("orchestrator MCP toolkit", () => {	...	@@ -4082,6 +4101,47 @@ describe("orchestrator MCP toolkit", () => {
4082	expect(finalProjection.runs.find((run) => run.id === queuedFollowup.runId)?.status).toBe(	4101	expect(finalProjection.runs.find((run) => run.id === queuedFollowup.runId)?.status).toBe(
4083	"completed",	4102	"completed",
4084	);	4103	);
		4104	yield* orchestrator
		4105	.streamStoredEventsFrom({
		4106	threadId: parentThreadId,
		4107	afterSequence: finalSequence,
		4108	})
		4109	.pipe(
		4110	Stream.filter(
		4111	(stored) =>
		4112	stored.event.type === "subagent.updated" &&
		4113	stored.event.payload.id === followupTasks[1]!.id &&
		4114	stored.event.payload.status === "completed",
		4115	),
		4116	Stream.runHead,
		4117	Effect.flatMap(
		4118	Option.match({
		4119	onNone: () => Effect.die("Follow-up task did not settle."),
		4120	onSome: () => Effect.void,
		4121	}),
		4122	),
		4123	);
		4124	const finishedParent = yield* orchestrator.getThreadProjection(parentThreadId);
		4125	expect(
		4126	finishedParent.subagents.find((task) => task.id === followupTasks[0]!.id)?.status,
		4127	).toBe("interrupted");
		4128	expect(
		4129	finishedParent.subagents.find((task) => task.id === followupTasks[1]!.id),
		4130	).toMatchObject({
		4131	status: "completed",
		4132	result: queuedFollowupResult,
		4133	});
		4134	expect(
		4135	finishedParent.contextTransfers.filter(
		4136	(transfer) =>
		4137	transfer.type === "subagent_result" &&
		4138	transfer.sourceThreadId === delegated.childThreadId,
		4139	),
		4140	).toHaveLength(3);
		4141	expect(
		4142	finishedParent.subagents.find((task) => task.id === followupTasks[1]!.id)
		4143	?.completionDelivery?.state,
		4144	).toBe("claimed");
4085	const finalStatusCall = yield* invoke("task_status", {	4145	const finalStatusCall = yield* invoke("task_status", {
4086	taskId: delegated.taskId,	4146	taskId: delegated.taskId,
4087	});	4147	});
...	@@ -4097,8 +4157,18 @@ describe("orchestrator MCP toolkit", () => {	...	@@ -4097,8 +4157,18 @@ describe("orchestrator MCP toolkit", () => {
4097	latestTerminalRunId: queuedFollowup.runId,	4157	latestTerminalRunId: queuedFollowup.runId,
4098	latestTerminalStatus: "completed",	4158	latestTerminalStatus: "completed",
4099	latestTerminalSummary: queuedFollowupResult,	4159	latestTerminalSummary: queuedFollowupResult,
4100	latestTerminalResultContextTransferId: null,
4101	});	4160	});
		4161	expect(finalStatus.latestTerminalResultContextTransferId).not.toBeNull();
		4162	const read = yield* invoke("t3_thread_read", {
		4163	threadId: delegated.childThreadId,
		4164	limit: 100,
		4165	});
		4166	expect(read.isError).not.toBe(true);
		4167	const afterRead = yield* orchestrator.getThreadProjection(parentThreadId);
		4168	expect(
		4169	afterRead.subagents.find((task) => task.id === queuedFollowup.taskId)
		4170	?.completionDelivery?.state,
		4171	).toBe("acknowledged");
4102	}).pipe(Effect.provide(layerTest));	4172	}).pipe(Effect.provide(layerTest));
4103	}),	4173	}),
4104	),	4174	),

apps/server/src/mcp/toolkits/orchestrator/tools.test.ts+1-1

...	@@ -22,7 +22,7 @@ describe("orchestrator MCP tool guidance", () => {	...	@@ -22,7 +22,7 @@ describe("orchestrator MCP tool guidance", () => {
22	assert.include(DelegateTaskTool.description ?? "", "childThreadId is backing storage");	22	assert.include(DelegateTaskTool.description ?? "", "childThreadId is backing storage");
23	assert.include(	23	assert.include(
24	OrchestratorToolkit.tools.t3_thread_send.description ?? "",	24	OrchestratorToolkit.tools.t3_thread_send.description ?? "",
25	"Do not use a delegated task's childThreadId to start another review round",	25	"a requested follow-up creates a fresh task",
26	);	26	);
27	assert.include(	27	assert.include(
28	OrchestratorToolkit.tools.task_cancel.description ?? "",	28	OrchestratorToolkit.tools.task_cancel.description ?? "",

apps/server/src/mcp/toolkits/orchestrator/tools.ts+1-1

...	@@ -219,7 +219,7 @@ export const ThreadUpdateTool = Tool.make("t3_thread_update", {	...	@@ -219,7 +219,7 @@ export const ThreadUpdateTool = Tool.make("t3_thread_update", {
219		219
220	const ThreadSendTool = Tool.make("t3_thread_send", {	220	const ThreadSendTool = Tool.make("t3_thread_send", {
221	description:	221	description:
222	"Send a message to any T3 thread in this environment. The target cannot have broader permission modes than the caller. Do not use a delegated task's childThreadId to start another review round here; use delegate_task with the full review context and a new clientRequestId for that round. Thread messages do not create a new delegated task or reopen a completed task. mode='auto' starts an idle thread, steers a fully active turn, or queues behind a turn that is not yet steerable. Use queue for a separate follow-up turn, steer for an in-flight update, or restart to interrupt-and-restart the active turn. clientRequestId makes retries idempotent.",	222	"Send a message to any T3 thread in this environment. The target cannot have broader permission modes than the caller. Use delegate_task with the full review context and a new clientRequestId for independent review rounds. For a follow-up that needs the same child's conversation, send to its childThreadId. After the original task completes, a requested follow-up creates a fresh task in that child thread and returns taskId; its completion notifies the parent, and the original result stays unchanged. mode='auto' starts an idle thread, steers a fully active turn, or queues behind a turn that is not yet steerable. Use queue for a separate follow-up turn, steer for an in-flight update, or restart to interrupt-and-restart the active turn. clientRequestId makes retries idempotent.",
223	parameters: OrchestratorMcpThreadSendInput,	223	parameters: OrchestratorMcpThreadSendInput,
224	success: OrchestratorMcpThreadSendResult,	224	success: OrchestratorMcpThreadSendResult,
225	failure: OrchestratorMcpFailure,	225	failure: OrchestratorMcpFailure,

apps/server/src/orchestration-v2/DelegatedCompletionDelivery.test.ts+313

...	@@ -41,6 +41,7 @@ import { continueRestartedRun } from "./RestartContinuation.ts";	...	@@ -41,6 +41,7 @@ import { continueRestartedRun } from "./RestartContinuation.ts";
41	import * as RuntimeLayer from "./runtimeLayer.ts";	41	import * as RuntimeLayer from "./runtimeLayer.ts";
42	import * as ProviderTurnStartServiceTestkit from "./ProviderTurnStartService.testkit.ts";	42	import * as ProviderTurnStartServiceTestkit from "./ProviderTurnStartService.testkit.ts";
43	import type * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";	43	import type * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
		44	import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests";
44		45
45	const layerPlatformTest = Layer.merge(	46	const layerPlatformTest = Layer.merge(
46	NodeServices.layer,	47	NodeServices.layer,
...	@@ -904,6 +905,318 @@ const seedRestartCancelledChild = (input: {	...	@@ -904,6 +905,318 @@ const seedRestartCancelledChild = (input: {
904	return { taskId, childThreadId, childRunId };	905	return { taskId, childThreadId, childRunId };
905	});	906	});
906		907
		908	it.layer(Layer.merge(layerTest, ProviderContinuationRequests.layer))(
		909	"subagent follow-ups",
		910	(it) => {
		911	const outcomes = [
		912	"completed",
		913	"failed",
		914	"interrupted",
		915	"restarted",
		916	"stopped",
		917	"overlapping",
		918	] as const;
		919	it.effect.each(outcomes)(
		920	"delivers a %s follow-up independently of the original task",
		921	(outcome) =>
		922	Effect.gen(function* () {
		923	const orchestrator = yield* Orchestrator.OrchestratorV2;
		924	const eventSink = yield* EventSink.EventSinkV2;
		925	const requests = yield* ProviderContinuationRequests.ProviderContinuationRequests;
		926	const now = yield* DateTime.now;
		927	const parentThreadId = ThreadId.make(`thread:followup-${outcome}`);
		928	const projectId = ProjectId.make(`project:followup-${outcome}`);
		929	const parentRunId = RunId.make(`run:followup-${outcome}`);
		930	const rootNodeId = NodeId.make(`node:followup-${outcome}`);
		931	yield* seedParentWithTerminalTask({
		932	threadId: parentThreadId,
		933	projectId,
		934	runId: parentRunId,
		935	rootNodeId,
		936	taskId: NodeId.make(`node:seed-${outcome}`),
		937	deliveryState: "acknowledged",
		938	now,
		939	});
		940	const child = yield* seedRestartCancelledChild({
		941	parentThreadId,
		942	projectId,
		943	parentRunId,
		944	rootNodeId,
		945	name: `followup-child-${outcome}`,
		946	completionWake: "always",
		947	continuationPending: false,
		948	runStatus: "completed",
		949	now,
		950	});
		951	yield* orchestrator.recoverDelegatedTasks;
		952	let firstWake = yield* requests.take;
		953	while (firstWake.threadId !== parentThreadId) firstWake = yield* requests.take;
		954	assert.equal(firstWake.delegatedCompletion?.parentRunId, parentRunId);
		955	yield* orchestrator.dispatch({
		956	type: "delegated_task.completion-delivery.acknowledge",
		957	commandId: CommandId.make(`command:followup-ack-${outcome}`),
		958	parentThreadId,
		959	taskId: child.taskId,
		960	observedByRunId: parentRunId,
		961	});
		962	const original = (yield* orchestrator.getThreadProjection(parentThreadId)).subagents.find(
		963	(task) => task.id === child.taskId,
		964	)!;
		965	const parentRun = (yield* orchestrator.getThreadProjection(parentThreadId)).runs.find(
		966	(run) => run.id === parentRunId,
		967	)!;
		968	yield* eventSink.write({
		969	commandId: reconcileCommandId(`followup-parent-finished-${outcome}`),
		970	events: [
		971	{
		972	id: EventId.make(`event:followup-parent-finished-${outcome}`),
		973	type: "run.updated",
		974	threadId: parentThreadId,
		975	runId: parentRunId,
		976	occurredAt: now,
		977	payload: { ...parentRun, status: "completed", completedAt: now },
		978	},
		979	],
		980	});
		981	const messageId = MessageId.make(`message:followup-${outcome}`);
		982	yield* orchestrator.dispatch({
		983	type: "message.dispatch",
		984	createdBy: outcome === "failed" ? "user" : "agent",
		985	creationSource: outcome === "failed" ? "web" : "mcp",
		986	commandId: CommandId.make(`command:followup-send-${outcome}`),
		987	threadId: child.childThreadId,
		988	senderThreadId: parentThreadId,
		989	messageId,
		990	text: "Check the same work again.",
		991	attachments: [],
		992	dispatchMode: { type: "start_immediately" },
		993	});
		994	const childProjection = yield* orchestrator.getThreadProjection(child.childThreadId);
		995	let run = childProjection.runs.find((row) => row.userMessageId === messageId)!;
		996	assert.isDefined(run.delegatedTaskId);
		997	const workingParent = yield* orchestrator.getShellSnapshot();
		998	const backgroundTask = workingParent.threads
		999	.find((thread) => thread.id === parentThreadId)
		1000	?.pendingBackgroundTasks?.find((task) => task.kind === "subagent");
		1001	assert.equal(backgroundTask?.childThreadId, child.childThreadId);
		1002	if (outcome === "overlapping") {
		1003	yield* orchestrator.dispatch({
		1004	type: "message.dispatch",
		1005	createdBy: "agent",
		1006	creationSource: "mcp",
		1007	commandId: CommandId.make("command:overlapping-followup"),
		1008	threadId: child.childThreadId,
		1009	senderThreadId: parentThreadId,
		1010	messageId: MessageId.make("message:overlapping-followup"),
		1011	text: "Keep working on another follow-up.",
		1012	attachments: [],
		1013	dispatchMode: { type: "queue_after_active" },
		1014	});
		1015	}
		1016	if (outcome === "restarted") {
		1017	const cut = { ...run, status: "cancelled" as const, startedAt: now, completedAt: now };
		1018	yield* eventSink.writeWithEffects({
		1019	commandId: reconcileCommandId("followup-restart-cut"),
		1020	events: [
		1021	{
		1022	id: EventId.make("event:followup-restart-cut"),
		1023	type: "run.updated",
		1024	threadId: child.childThreadId,
		1025	runId: run.id,
		1026	occurredAt: now,
		1027	payload: cut,
		1028	},
		1029	],
		1030	effects: [
		1031	{
		1032	id: `effect:restart-continuation:${run.id}`,
		1033	commandId: reconcileCommandId("followup-restart-cut"),
		1034	threadId: child.childThreadId,
		1035	request: { type: "provider-runtime.continue", sourceRunId: run.id },
		1036	},
		1037	],
		1038	});
		1039	yield* orchestrator.recoverDelegatedTasks;
		1040	assert.isNull(
		1041	(yield* orchestrator.getThreadProjection(parentThreadId)).subagents.find(
		1042	(task) => task.id === run.delegatedTaskId,
		1043	)!.result,
		1044	);
		1045	const continuationMessageId = MessageId.make("message:followup-restart-continuation");
		1046	yield* orchestrator.dispatch({
		1047	type: "message.dispatch",
		1048	createdBy: "agent",
		1049	creationSource: "server",
		1050	commandId: CommandId.make("command:followup-restart-continuation"),
		1051	threadId: child.childThreadId,
		1052	restartContinuationOfRunId: run.id,
		1053	messageId: continuationMessageId,
		1054	text: "Continue where you left off.",
		1055	attachments: [],
		1056	dispatchMode: { type: "start_immediately" },
		1057	});
		1058	const continuation = (yield* orchestrator.getThreadProjection(
		1059	child.childThreadId,
		1060	)).runs.find((row) => row.userMessageId === continuationMessageId)!;
		1061	assert.equal(continuation.delegatedTaskId, run.delegatedTaskId);
		1062	run = continuation;
		1063	}
		1064	if (outcome === "stopped") {
		1065	yield* orchestrator.dispatch({
		1066	type: "thread.stop",
		1067	threadId: parentThreadId,
		1068	commandId: CommandId.make(`command:followup-stop-${outcome}`),
		1069	});
		1070	}
		1071	// Reconciliation skips the live terminal listener; recovery must finish this recorded task.
		1072	yield* eventSink.write({
		1073	commandId: reconcileCommandId(`followup-finish-${outcome}`),
		1074	events: [
		1075	{
		1076	id: EventId.make(`event:followup-finish-${outcome}`),
		1077	type: "run.updated",
		1078	threadId: child.childThreadId,
		1079	runId: run.id,
		1080	occurredAt: now,
		1081	payload: {
		1082	...run,
		1083	status:
		1084	outcome === "stopped"
		1085	? "interrupted"
		1086	: outcome === "restarted" \|\| outcome === "overlapping"
		1087	? "completed"
		1088	: outcome,
		1089	startedAt: now,
		1090	completedAt: now,
		1091	},
		1092	},
		1093	],
		1094	});
		1095	yield* orchestrator.recoverDelegatedTasks;
		1096	const finished = yield* orchestrator.getThreadProjection(parentThreadId);
		1097	assert.deepEqual(
		1098	finished.subagents.find((task) => task.id === child.taskId),
		1099	original,
		1100	);
		1101	const followup = finished.subagents.find((task) => task.id === run.delegatedTaskId)!;
		1102	if (outcome === "overlapping") {
		1103	const later = finished.subagents.find(
		1104	(task) =>
		1105	task.childThreadId === child.childThreadId &&
		1106	task.id !== child.taskId &&
		1107	task.id !== followup.id,
		1108	)!;
		1109	assert.equal(later.status, "pending");
		1110	assert.isNull(later.result);
		1111	}
		1112	assert.equal(
		1113	followup.status,
		1114	outcome === "stopped"
		1115	? "interrupted"
		1116	: outcome === "restarted" \|\| outcome === "overlapping"
		1117	? "completed"
		1118	: outcome,
		1119	);
		1120	assert.equal(
		1121	followup.completionDelivery?.state,
		1122	outcome === "stopped" ? "disposed" : "claimed",
		1123	);
		1124	if (outcome !== "stopped") {
		1125	let wake = yield* requests.take;
		1126	while (
		1127	wake.threadId !== parentThreadId \|\|
		1128	wake.delegatedCompletion?.messageId === firstWake.delegatedCompletion?.messageId
		1129	) {
		1130	wake = yield* requests.take;
		1131	}
		1132	assert.equal(wake.delegatedCompletion?.parentRunId, parentRunId);
		1133	assert.notEqual(
		1134	wake.delegatedCompletion?.messageId,
		1135	firstWake.delegatedCompletion?.messageId,
		1136	);
		1137	}
		1138	assert.equal(
		1139	finished.contextTransfers.filter(
		1140	(transfer) =>
		1141	transfer.type === "subagent_result" &&
		1142	transfer.sourceThreadId === child.childThreadId,
		1143	).length,
		1144	2,
		1145	);
		1146	yield* orchestrator.recoverDelegatedTasks;
		1147	const recovered = yield* orchestrator.getThreadProjection(parentThreadId);
		1148	assert.equal(recovered.contextTransfers.length, finished.contextTransfers.length);
		1149	if (outcome === "completed") {
		1150	const automaticMessageId = MessageId.make("message:followup-automatic-wake");
		1151	yield* orchestrator.dispatch({
		1152	type: "message.dispatch",
		1153	createdBy: "agent",
		1154	creationSource: "server",
		1155	commandId: CommandId.make("command:followup-automatic-wake"),
		1156	threadId: child.childThreadId,
		1157	messageId: automaticMessageId,
		1158	text: "A monitor reported new output.",
		1159	attachments: [],
		1160	notification: {
		1161	source: { kind: "monitor" },
		1162	outcome: "updated",
		1163	summary: "Monitor updated",
		1164	},
		1165	dispatchMode: { type: "queue_after_active" },
		1166	});
		1167	const automatic = (yield* orchestrator.getThreadProjection(
		1168	child.childThreadId,
		1169	)).runs.find((run) => run.userMessageId === automaticMessageId)!;
		1170	assert.isUndefined(automatic.delegatedTaskId);
		1171	yield* eventSink.write({
		1172	commandId: reconcileCommandId("followup-automatic-finished"),
		1173	events: [
		1174	{
		1175	id: EventId.make("event:followup-automatic-finished"),
		1176	type: "run.updated",
		1177	threadId: child.childThreadId,
		1178	runId: automatic.id,
		1179	occurredAt: now,
		1180	payload: { ...automatic, status: "completed", startedAt: now, completedAt: now },
		1181	},
		1182	],
		1183	});
		1184	yield* orchestrator.recoverDelegatedTasks;
		1185	const afterAutomatic = yield* orchestrator.getThreadProjection(parentThreadId);
		1186	assert.deepEqual(afterAutomatic.subagents, recovered.subagents);
		1187	assert.equal(afterAutomatic.contextTransfers.length, recovered.contextTransfers.length);
		1188	const control = yield* seedRestartCancelledChild({
		1189	parentThreadId,
		1190	projectId,
		1191	parentRunId,
		1192	rootNodeId,
		1193	name: "followup-control-child",
		1194	completionWake: "always",
		1195	continuationPending: false,
		1196	runStatus: "completed",
		1197	now,
		1198	});
		1199	yield* orchestrator.recoverDelegatedTasks;
		1200	const afterControl = yield* orchestrator.getThreadProjection(parentThreadId);
		1201	assert.equal(
		1202	afterControl.subagents.find((task) => task.id === control.taskId)?.completionDelivery
		1203	?.state,
		1204	"claimed",
		1205	);
		1206	assert.equal(
		1207	afterControl.contextTransfers.filter(
		1208	(transfer) =>
		1209	transfer.type === "subagent_result" &&
		1210	transfer.sourceThreadId === control.childThreadId,
		1211	).length,
		1212	1,
		1213	);
		1214	}
		1215	}),
		1216	);
		1217	},
		1218	);
		1219
907	it.layer(layerTest)("delegated tasks across a server restart", (it) => {	1220	it.layer(layerTest)("delegated tasks across a server restart", (it) => {
908	it.effect("holds a restart-cancelled child for its continuation's result", () =>	1221	it.effect("holds a restart-cancelled child for its continuation's result", () =>
909	Effect.gen(function* () {	1222	Effect.gen(function* () {

apps/server/src/orchestration-v2/Orchestrator.ts+262-16

...	@@ -22,6 +22,7 @@ import {	...	@@ -22,6 +22,7 @@ import {
22	CommandId,	22	CommandId,
23	isProviderNativeSubagentThread,	23	isProviderNativeSubagentThread,
24	MessageId,	24	MessageId,
		25	type NodeId,
25	type ModelSelection,	26	type ModelSelection,
26	OrchestrationV2Command,	27	OrchestrationV2Command,
27	type OrchestrationV2InternalCommand,	28	type OrchestrationV2InternalCommand,
...	@@ -279,9 +280,11 @@ export interface OrchestratorV2Shape {	...	@@ -279,9 +280,11 @@ export interface OrchestratorV2Shape {
279	/**	280	/**
280	* Whether a delegated child's apparent result is not final yet: a restart	281	* Whether a delegated child's apparent result is not final yet: a restart
281	* continuation is pending, or the child is working again.	282	* continuation is pending, or the child is working again.
		283	* A taskId limits the check to that follow-up's runs.
282	*/	284	*/
283	readonly delegatedTaskResultPending: (	285	readonly delegatedTaskResultPending: (
284	childThreadId: ThreadId,	286	childThreadId: ThreadId,
		287	taskId?: NodeId,
285	) => Effect.Effect<boolean, OrchestratorProjectionError>;	288	) => Effect.Effect<boolean, OrchestratorProjectionError>;
286	readonly dispatch: (	289	readonly dispatch: (
287	command: OrchestrationV2ServerCommand,	290	command: OrchestrationV2ServerCommand,
...	@@ -4561,6 +4564,10 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio	...	@@ -4561,6 +4564,10 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
4561	}	4564	}
4562	}	4565	}
4563		4566
		4567	const continuedTaskId = projection.runs.find(
		4568	(run) => run.id === command.restartContinuationOfRunId,
		4569	)?.delegatedTaskId;
		4570
4564	if (projection.thread.settledOverride !== null) {	4571	if (projection.thread.settledOverride !== null) {
4565	const now = yield* DateTime.now;	4572	const now = yield* DateTime.now;
4566	const thread: OrchestrationV2AppThread = {	4573	const thread: OrchestrationV2AppThread = {
...	@@ -4980,6 +4987,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio	...	@@ -4980,6 +4987,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
4980	...(command.restartContinuationOfRunId === undefined	4987	...(command.restartContinuationOfRunId === undefined
4981	? {}	4988	? {}
4982	: { restartContinuationOfRunId: command.restartContinuationOfRunId }),	4989	: { restartContinuationOfRunId: command.restartContinuationOfRunId }),
		4990	...(continuedTaskId === undefined ? {} : { delegatedTaskId: continuedTaskId }),
4983	};	4991	};
4984	const attempt: OrchestrationV2RunAttempt = {	4992	const attempt: OrchestrationV2RunAttempt = {
4985	id: attemptId,	4993	id: attemptId,
...	@@ -5322,6 +5330,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio	...	@@ -5322,6 +5330,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
5322	...(dispatchMode.type === "defer_start" && dispatchMode.workspaceStrategy !== undefined	5330	...(dispatchMode.type === "defer_start" && dispatchMode.workspaceStrategy !== undefined
5323	? { workspacePreparation: dispatchMode.workspaceStrategy }	5331	? { workspacePreparation: dispatchMode.workspaceStrategy }
5324	: {}),	5332	: {}),
		5333	...(continuedTaskId === undefined ? {} : { delegatedTaskId: continuedTaskId }),
5325	...wakeWorkStartedAt(projection.runs, command),	5334	...wakeWorkStartedAt(projection.runs, command),
5326	};	5335	};
5327	const attempt: OrchestrationV2RunAttempt = {	5336	const attempt: OrchestrationV2RunAttempt = {
...	@@ -6015,6 +6024,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio	...	@@ -6015,6 +6024,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
6015	...(command.restartContinuationOfRunId === undefined	6024	...(command.restartContinuationOfRunId === undefined
6016	? {}	6025	? {}
6017	: { restartContinuationOfRunId: command.restartContinuationOfRunId }),	6026	: { restartContinuationOfRunId: command.restartContinuationOfRunId }),
		6027	...(continuedTaskId === undefined ? {} : { delegatedTaskId: continuedTaskId }),
6018	...wakeWorkStartedAt(projection.runs, command),	6028	...wakeWorkStartedAt(projection.runs, command),
6019	};	6029	};
6020	const attempt: OrchestrationV2RunAttempt = {	6030	const attempt: OrchestrationV2RunAttempt = {
...	@@ -6738,6 +6748,165 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio	...	@@ -6738,6 +6748,165 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
6738	},	6748	},
6739	);	6749	);
6740		6750
		6751	// A follow-up is new requested work in the same child conversation. Give it
		6752	// its own task so results, acknowledgments, Stop, and recovery use the same
		6753	// lifecycle as a fresh delegation without replacing the original result.
		6754	const recordSubagentFollowup = Effect.fnUntraced(function* (
		6755	command: Extract<OrchestrationV2Command, { readonly type: "message.dispatch" }>,
		6756	events: Ref.Ref<Array<OrchestrationV2DomainEvent>>,
		6757	) {
		6758	if (
		6759	command.scheduledTaskId !== undefined \|\|
		6760	command.notification !== undefined \|\|
		6761	command.restartContinuationOfRunId !== undefined \|\|
		6762	(command.createdBy !== "user" && command.creationSource !== "mcp")
		6763	)
		6764	return;
		6765	const pending = yield* Ref.get(events);
		6766	const message = pending
		6767	.flatMap((event) =>
		6768	event.type === "message.updated" && event.payload.id === command.messageId
		6769	? [event.payload]
		6770	: [],
		6771	)
		6772	.at(-1);
		6773	if (message?.runId == null) return;
		6774	const child = yield* projectionStore.getThread(command.threadId);
		6775	const parentThreadId = child.lineage.parentThreadId;
		6776	if (
		6777	child.lineage.relationshipToParent !== "subagent" \|\|
		6778	parentThreadId === null \|\|
		6779	(command.createdBy !== "user" && command.senderThreadId !== parentThreadId)
		6780	)
		6781	return;
		6782	const run =
		6783	pending
		6784	.flatMap((event) =>
		6785	(event.type === "run.created" \|\| event.type === "run.updated") &&
		6786	event.payload.id === message.runId
		6787	? [event.payload]
		6788	: [],
		6789	)
		6790	.at(-1) ??
		6791	(yield* projectionStore.getThreadRecords(command.threadId, ["runs"])).runs.find(
		6792	(row) => row.id === message.runId,
		6793	);
		6794	if (run === undefined \|\| run.delegatedTaskId !== undefined) return;
		6795	const parent = yield* projectionStore
		6796	.getThreadRecords(parentThreadId, ["runs", "subagents", "providerTurns", "attempts"])
		6797	.pipe(mapDispatchError(command));
		6798	const original = parent.subagents.find(
		6799	(task) =>
		6800	task.origin === "app_owned" &&
		6801	task.childThreadId === child.id &&
		6802	task.id === (child.forkedFrom?.type === "node" ? child.forkedFrom.nodeId : undefined),
		6803	);
		6804	// Before first publication, follow-ups remain part of the original task.
		6805	if (original === undefined \|\| original.result === null) return;
		6806	const owner =
		6807	parent.runs.filter(isBlockingRun).toSorted((a, b) => b.ordinal - a.ordinal)[0] ??
		6808	latestExecutedRun(parent.runs);
		6809	if (owner === null \|\| owner.rootNodeId === null) return;
		6810	const now = message.createdAt;
		6811	const adapter = yield* providerAdapters.get(run.providerInstanceId);
		6812	const taskId = idAllocator.derive.delegatedTaskNode({ commandId: command.commandId });
		6813	const task: OrchestrationV2Subagent = {
		6814	...original,
		6815	createdBy: command.createdBy,
		6816	driver: adapter.driver,
		6817	id: taskId,
		6818	runId: owner.id,
		6819	parentNodeId: owner.rootNodeId,
		6820	providerInstanceId: run.providerInstanceId,
		6821	providerThreadId: run.providerThreadId,
		6822	model: run.modelSelection.model,
		6823	modelSelection: run.modelSelection,
		6824	prompt: command.text,
		6825	title: child.title,
		6826	completionWake: "always",
		6827	completionDelivery: { state: "pending", observedByRunId: null },
		6828	status: run.status === "queued" ? "pending" : "running",
		6829	progress: undefined,
		6830	result: null,
		6831	startedAt: now,
		6832	completedAt: null,
		6833	updatedAt: now,
		6834	};
		6835	const node: OrchestrationV2ExecutionNode = {
		6836	id: taskId,
		6837	threadId: parentThreadId,
		6838	runId: owner.id,
		6839	parentNodeId: owner.rootNodeId,
		6840	rootNodeId: owner.rootNodeId,
		6841	kind: "subagent",
		6842	status: task.status,
		6843	countsForRun: false,
		6844	providerThreadId: run.providerThreadId,
		6845	providerTurnId: null,
		6846	nativeItemRef: null,
		6847	runtimeRequestId: null,
		6848	checkpointScopeId: null,
		6849	startedAt: now,
		6850	completedAt: null,
		6851	};
		6852	const turnItem: OrchestrationV2TurnItem = {
		6853	id: idAllocator.derive.delegatedTaskTurnItem({ commandId: command.commandId }),
		6854	threadId: parentThreadId,
		6855	runId: owner.id,
		6856	nodeId: taskId,
		6857	providerThreadId: owner.providerThreadId,
		6858	providerTurnId: providerTurnForRun(parent, owner)?.id ?? null,
		6859	nativeItemRef: null,
		6860	parentItemId: null,
		6861	ordinal: yield* nextTurnItemOrdinal(parent),
		6862	status: task.status,
		6863	title: child.title,
		6864	startedAt: now,
		6865	completedAt: null,
		6866	updatedAt: now,
		6867	type: "subagent",
		6868	subagentId: taskId,
		6869	origin: "app_owned",
		6870	driver: task.driver,
		6871	providerInstanceId: task.providerInstanceId,
		6872	childThreadId: child.id,
		6873	prompt: command.text,
		6874	result: null,
		6875	};
		6876	const emitEvent = emit(events, command);
		6877	yield* emitEvent({
		6878	type: "run.updated",
		6879	threadId: child.id,
		6880	runId: run.id,
		6881	occurredAt: now,
		6882	payload: { ...run, delegatedTaskId: taskId },
		6883	});
		6884	yield* emitEvent({
		6885	type: "node.updated",
		6886	threadId: parentThreadId,
		6887	runId: owner.id,
		6888	nodeId: taskId,
		6889	occurredAt: now,
		6890	payload: node,
		6891	});
		6892	yield* emitEvent({
		6893	type: "subagent.updated",
		6894	threadId: parentThreadId,
		6895	runId: owner.id,
		6896	nodeId: taskId,
		6897	occurredAt: now,
		6898	payload: task,
		6899	});
		6900	yield* emitEvent({
		6901	type: "turn-item.updated",
		6902	threadId: parentThreadId,
		6903	runId: owner.id,
		6904	nodeId: taskId,
		6905	occurredAt: now,
		6906	payload: turnItem,
		6907	});
		6908	});
		6909
6741	// Rewrites a delegated task's completionWake after creation. The wait path	6910	// Rewrites a delegated task's completionWake after creation. The wait path
6742	// uses this when its blocking window ends without a terminal (timeout), so	6911	// uses this when its blocking window ends without a terminal (timeout), so
6743	// a child that later terminalizes mid-parent-turn still wakes the parent.	6912	// a child that later terminalizes mid-parent-turn still wakes the parent.
...	@@ -9581,16 +9750,18 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio	...	@@ -9581,16 +9750,18 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
9581	* running). `settledContinuationOf` names the restart continuation that just	9750	* running). `settledContinuationOf` names the restart continuation that just
9582	* declined or failed, so its own still-running effect does not hold the child.	9751	* declined or failed, so its own still-running effect does not hold the child.
9583	*/	9752	*/
9584	const finalizeAppOwnedSubagent = (	9753	const finalizeAppOwnedSubagentTask = (
9585	childThreadId: ThreadId,	9754	childControls: ProjectionRecords<
9586	options?: { readonly settledContinuationOf?: RunId },	9755	"runs" \| "messages" \| "subagents" \| "providerThreads" \| "providerTurns" \| "attempts"
		9756	>,
		9757	options: {
		9758	readonly settledContinuationOf?: RunId;
		9759	readonly taskId: NodeId;
		9760	readonly resultRun?: OrchestrationV2Run;
		9761	},
9587	) =>	9762	) =>
9588	Effect.gen(function* () {	9763	Effect.gen(function* () {
9589	const childControls = yield* projectionStore.getThreadRecords(	9764	const childThreadId = childControls.thread.id;
9590	childThreadId,
9591	["runs", "messages", "subagents", "providerThreads", "providerTurns", "attempts"],
9592	{ messageRoles: ["user"] },
9593	);
9594	const forkedFrom = childControls.thread.forkedFrom;	9765	const forkedFrom = childControls.thread.forkedFrom;
9595	if (	9766	if (
9596	childControls.thread.lineage.relationshipToParent !== "subagent" \|\|	9767	childControls.thread.lineage.relationshipToParent !== "subagent" \|\|
...	@@ -9599,9 +9770,13 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio	...	@@ -9599,9 +9770,13 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
9599	) {	9770	) {
9600	return;	9771	return;
9601	}	9772	}
9602	const progress = delegatedTaskProgress(childControls);	9773	const taskRuns = childControls.runs.filter((run) => run.delegatedTaskId === options.taskId);
9603	if (progress.state !== "result_available") return;	9774	const childRun =
9604	const childRun = progress.resultRun;	9775	taskRuns.length === 0
		9776	? options.taskId === forkedFrom.nodeId
		9777	? options.resultRun
		9778	: undefined
		9779	: taskRuns.toSorted((a, b) => b.ordinal - a.ordinal)[0];
9605	if (childRun === undefined) return;	9780	if (childRun === undefined) return;
9606	const terminalStatus = delegatedTaskTerminalStatus(childRun.status);	9781	const terminalStatus = delegatedTaskTerminalStatus(childRun.status);
9607	if (terminalStatus === null) {	9782	if (terminalStatus === null) {
...	@@ -9609,7 +9784,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio	...	@@ -9609,7 +9784,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
9609	}	9784	}
9610	if (	9785	if (
9611	yield* childAwaitsRestartContinuation(	9786	yield* childAwaitsRestartContinuation(
9612	childControls.runs,	9787	taskRuns.length === 0 ? childControls.runs : taskRuns,
9613	childRun,	9788	childRun,
9614	options?.settledContinuationOf,	9789	options?.settledContinuationOf,
9615	)	9790	)
...	@@ -9649,7 +9824,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio	...	@@ -9649,7 +9824,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
9649	);	9824	);
9650	const task = parentProjection.subagents.find(	9825	const task = parentProjection.subagents.find(
9651	(candidate) =>	9826	(candidate) =>
9652	candidate.id === forkedFrom.nodeId &&	9827	candidate.id === options.taskId &&
9653	candidate.origin === "app_owned" &&	9828	candidate.origin === "app_owned" &&
9654	candidate.childThreadId === childThreadId,	9829	candidate.childThreadId === childThreadId,
9655	);	9830	);
...	@@ -9660,7 +9835,9 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio	...	@@ -9660,7 +9835,9 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
9660	(transfer) =>	9835	(transfer) =>
9661	transfer.type === "subagent_result" &&	9836	transfer.type === "subagent_result" &&
9662	transfer.sourceThreadId === childThreadId &&	9837	transfer.sourceThreadId === childThreadId &&
9663	transfer.targetThreadId === parentThreadId,	9838	transfer.targetThreadId === parentThreadId &&
		9839	(transfer.sourcePoint.runId === childRun.id \|\|
		9840	(options.taskId === forkedFrom.nodeId && transfer.sourcePoint.runId === undefined)),
9664	);	9841	);
9665	if (existingResultTransfer !== undefined) {	9842	if (existingResultTransfer !== undefined) {
9666	return;	9843	return;
...	@@ -9873,6 +10050,49 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio	...	@@ -9873,6 +10050,49 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
9873	}	10050	}
9874	});	10051	});
9875		10052
		10053	const finalizeAppOwnedSubagent = (
		10054	childThreadId: ThreadId,
		10055	options?: { readonly settledContinuationOf?: RunId },
		10056	) =>
		10057	Effect.gen(function* () {
		10058	const childControls = yield* projectionStore.getThreadRecords(
		10059	childThreadId,
		10060	["runs", "messages", "subagents", "providerThreads", "providerTurns", "attempts"],
		10061	{ messageRoles: ["user"] },
		10062	);
		10063	const parentThreadId = childControls.thread.lineage.parentThreadId;
		10064	if (
		10065	childControls.thread.lineage.relationshipToParent !== "subagent" \|\|
		10066	parentThreadId === null \|\|
		10067	childControls.thread.forkedFrom?.type !== "node"
		10068	)
		10069	return;
		10070	const progress = delegatedTaskProgress(childControls);
		10071	const parent = yield* projectionStore.getThreadRecords(parentThreadId, [
		10072	"subagents",
		10073	"contextTransfers",
		10074	]);
		10075	for (const task of parent.subagents) {
		10076	if (
		10077	task.origin !== "app_owned" \|\|
		10078	task.childThreadId !== childThreadId \|\|
		10079	(task.id === childControls.thread.forkedFrom.nodeId &&
		10080	progress.state !== "result_available") \|\|
		10081	(task.result !== null &&
		10082	parent.contextTransfers.some(
		10083	(transfer) =>
		10084	transfer.type === "subagent_result" && transfer.sourceThreadId === childThreadId,
		10085	))
		10086	)
		10087	continue;
		10088	yield* finalizeAppOwnedSubagentTask(childControls, {
		10089	...options,
		10090	taskId: task.id,
		10091	...(progress.resultRun === undefined ? {} : { resultRun: progress.resultRun }),
		10092	});
		10093	}
		10094	});
		10095
9876	const finalizeDelegatedCompletionDelivery = (threadId: ThreadId, runId: RunId) =>	10096	const finalizeDelegatedCompletionDelivery = (threadId: ThreadId, runId: RunId) =>
9877	Effect.gen(function* () {	10097	Effect.gen(function* () {
9878	// Ordinary turns do not own a delegated delivery. Read just their input	10098	// Ordinary turns do not own a delegated delivery. Read just their input
...	@@ -10266,6 +10486,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio	...	@@ -10266,6 +10486,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
10266	});	10486	});
10267	}	10487	}
10268	yield* dispatchMessage(command, events, effects);	10488	yield* dispatchMessage(command, events, effects);
		10489	yield* recordSubagentFollowup(command, events).pipe(mapDispatchError(command));
10269	break;	10490	break;
10270	}	10491	}
10271	case "notification.delivery.accept":	10492	case "notification.delivery.accept":
...	@@ -10627,7 +10848,26 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio	...	@@ -10627,7 +10848,26 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
10627	});	10848	});
10628		10849
10629	const dispatchWithReceipt = (command: OrchestrationV2ServerCommand) =>	10850	const dispatchWithReceipt = (command: OrchestrationV2ServerCommand) =>
10630	threadDispatch.withLock(commandThreadId(command), dispatchWithReceiptEffect(command));	10851	Effect.gen(function* () {
		10852	const dispatch = threadDispatch.withLock(
		10853	commandThreadId(command),
		10854	dispatchWithReceiptEffect(command),
		10855	);
		10856	if (
		10857	command.type !== "message.dispatch" \|\|
		10858	(command.createdBy !== "user" && command.creationSource !== "mcp")
		10859	)
		10860	return yield* dispatch;
		10861	const parentThreadId = yield* appOwnedSubagentParentThreadId(command.threadId).pipe(
		10862	Effect.mapError(
		10863	(cause) => new OrchestratorProjectionError({ threadId: command.threadId, cause }),
		10864	),
		10865	);
		10866	// Follow-up intake and Stop serialize on the parent before taking the child lock.
		10867	return yield* parentThreadId === undefined
		10868	? dispatch
		10869	: threadDispatch.withLock(parentThreadId, dispatch);
		10870	});
10631		10871
10632	const handleTerminalRun = (stored: OrchestrationV2StoredEvent) =>	10872	const handleTerminalRun = (stored: OrchestrationV2StoredEvent) =>
10633	Effect.gen(function* () {	10873	Effect.gen(function* () {
...	@@ -10792,13 +11032,19 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio	...	@@ -10792,13 +11032,19 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
10792	);	11032	);
10793	});	11033	});
10794		11034
10795	const delegatedTaskResultPending = (childThreadId: ThreadId) =>	11035	const delegatedTaskResultPending = (childThreadId: ThreadId, taskId?: NodeId) =>
10796	Effect.gen(function* () {	11036	Effect.gen(function* () {
10797	const child = yield* projectionStore.getThreadRecords(	11037	const child = yield* projectionStore.getThreadRecords(
10798	childThreadId,	11038	childThreadId,
10799	["runs", "messages", "subagents", "providerThreads", "providerTurns", "attempts"],	11039	["runs", "messages", "subagents", "providerThreads", "providerTurns", "attempts"],
10800	{ messageRoles: ["user"] },	11040	{ messageRoles: ["user"] },
10801	);	11041	);
		11042	if (taskId !== undefined) {
		11043	const runs = child.runs.filter((run) => run.delegatedTaskId === taskId);
		11044	const run = runs.toSorted((a, b) => b.ordinal - a.ordinal)[0];
		11045	if (run === undefined \|\| delegatedTaskTerminalStatus(run.status) === null) return true;
		11046	return yield* childAwaitsRestartContinuation(runs, run);
		11047	}
10802	const progress = delegatedTaskProgress(child);	11048	const progress = delegatedTaskProgress(child);
10803	// A caller's older read saw a result; newer work since then means it is not final.	11049	// A caller's older read saw a result; newer work since then means it is not final.
10804	if (progress.state !== "result_available") return true;	11050	if (progress.state !== "result_available") return true;

apps/server/src/orchestration-v2/ProjectionRecovery.test.ts+83

...	@@ -299,6 +299,89 @@ it.effect("recovers terminal subagent results until their cross-thread transfer	...	@@ -299,6 +299,89 @@ it.effect("recovers terminal subagent results until their cross-thread transfer
299	}).pipe(Effect.provide(layerTest)),	299	}).pipe(Effect.provide(layerTest)),
300	);	300	);
301		301
		302	it.effect.each([
		303	{ name: "SQLite", layer: layerTest },
		304	{ name: "memory", layer: ProjectionStore.layerMemory },
		305	])("recovers only recorded follow-up results with $name projections", ({ layer }) =>
		306	Effect.gen(function* () {
		307	const projections = yield* ProjectionStore.ProjectionStoreV2;
		308	const now = yield* DateTime.now;
		309	const parent = yield* createThread("followup-parent");
		310	const child = yield* createThread("followup-child", {
		311	lineage: { parentThreadId: parent, relationshipToParent: "subagent", rootThreadId: parent },
		312	forkedFrom: { type: "node", nodeId: NodeId.make("node:original") },
		313	});
		314	const originalRunId = yield* createRun(child, "completed");
		315	yield* projections.apply({
		316	id: EventId.make("event:original-result"),
		317	type: "context-transfer.created",
		318	threadId: parent,
		319	occurredAt: now,
		320	payload: {
		321	id: ContextTransferId.make("transfer:original-result"),
		322	type: "subagent_result",
		323	sourceThreadId: child,
		324	targetThreadId: parent,
		325	sourcePoint: { threadId: child, runId: originalRunId },
		326	basePoint: null,
		327	sourceProviderInstanceId: providerInstanceId,
		328	targetProviderInstanceId: providerInstanceId,
		329	targetRunId: null,
		330	status: "pending",
		331	resolution: null,
		332	createdBy: "system",
		333	error: null,
		334	createdAt: now,
		335	updatedAt: now,
		336	consumedAt: null,
		337	},
		338	});
		339	// Historical untracked work does not acquire a notification on restart.
		340	yield* createRun(child, "completed", { ordinal: 2 });
		341	assert.deepEqual(yield* projections.getRecoveryThreadIds("subagent-results"), []);
		342	const taskId = NodeId.make("node:followup");
		343	yield* createRun(child, "completed", { ordinal: 3, delegatedTaskId: taskId });
		344	yield* createRun(child, "running", { ordinal: 4 });
		345	const task = {
		346	id: taskId,
		347	threadId: parent,
		348	runId: null,
		349	parentNodeId: NodeId.make("node:parent"),
		350	origin: "app_owned" as const,
		351	createdBy: "agent" as const,
		352	driver,
		353	providerInstanceId,
		354	providerThreadId: null,
		355	childThreadId: child,
		356	nativeTaskRef: null,
		357	prompt: "Check the follow-up.",
		358	title: null,
		359	model: null,
		360	status: "running" as const,
		361	result: null,
		362	startedAt: now,
		363	completedAt: null,
		364	updatedAt: now,
		365	};
		366	yield* projections.apply({
		367	id: EventId.make("event:followup-task"),
		368	type: "subagent.updated",
		369	threadId: parent,
		370	occurredAt: now,
		371	payload: task,
		372	});
		373	assert.deepEqual(yield* projections.getRecoveryThreadIds("subagent-results"), [child]);
		374	yield* projections.apply({
		375	id: EventId.make("event:followup-settled"),
		376	type: "subagent.updated",
		377	threadId: parent,
		378	occurredAt: now,
		379	payload: { ...task, status: "completed", result: "Follow-up result.", completedAt: now },
		380	});
		381	assert.deepEqual(yield* projections.getRecoveryThreadIds("subagent-results"), []);
		382	}).pipe(Effect.provide(layer)),
		383	);
		384
302	it.effect("includes shared sessions and provider-owned background rosters in recovery", () =>	385	it.effect("includes shared sessions and provider-owned background rosters in recovery", () =>
303	Effect.gen(function* () {	386	Effect.gen(function* () {
304	const projections = yield* ProjectionStore.ProjectionStoreV2;	387	const projections = yield* ProjectionStore.ProjectionStoreV2;

apps/server/src/orchestration-v2/ProjectionStore.ts+50-23

 @@ -537,6 +537,7 @@ export const ORCHESTRATION_V2_PROJECTION_SCHEMA_VERSION = 2;
 function needsRecovery(
   projection: OrchestrationV2ThreadProjection,
   kind: ProjectionRecoveryKind,
+  parent?: Pick<OrchestrationV2ThreadProjection, "subagents" | "contextTransfers">,
 ): boolean {
   if (projection.thread.deletedAt !== null) return false;
   switch (kind) {
 @@ -556,15 +557,28 @@ function needsRecovery(
         projection.thread.lineage.relationshipToParent === "subagent" &&
         parentThreadId !== null &&
         projection.thread.forkedFrom?.type === "node" &&
-        ["completed", "interrupted", "failed", "cancelled", "rolled_back"].includes(
+        ((parent?.subagents ?? []).some(
-          latestUnheldRun(projection.runs)?.status ?? "idle",
+          (task) =>
-        ) &&
+            task.origin === "app_owned" &&
-        !projection.contextTransfers.some(
+            task.result === null &&
-          (transfer) =>
+            task.childThreadId === projection.thread.id &&
-            transfer.type === "subagent_result" &&
+            projection.runs.some(
-            transfer.sourceThreadId === projection.thread.id &&
+              (run) =>
-            transfer.targetThreadId === parentThreadId,
+                run.delegatedTaskId === task.id &&
-        )
+                ["completed", "interrupted", "failed", "cancelled", "rolled_back"].includes(
+                  run.status,
+                ),
+            ),
+        ) ||
+          (["completed", "interrupted", "failed", "cancelled", "rolled_back"].includes(
+            latestUnheldRun(projection.runs)?.status ?? "idle",
+          ) &&
+            ![...projection.contextTransfers, ...(parent?.contextTransfers ?? [])].some(
+              (transfer) =>
+                transfer.type === "subagent_result" &&
+                transfer.sourceThreadId === projection.thread.id &&
+                transfer.targetThreadId === parentThreadId,
+            )))
       );
     }
     case "runtime":
 @@ -3576,23 +3590,28 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
                   json_extract(child.payload_json, '$.lineage.relationshipToParent') = 'subagent'
                   AND json_extract(child.payload_json, '$.lineage.parentThreadId') IS NOT NULL
                   AND json_extract(child.payload_json, '$.forkedFrom.type') = 'node'
-                  -- A held queue waits for the user, so the newest unheld run
+                  AND (EXISTS (
-                  -- decides, matching latestUnheldRun.
+                    SELECT 1 FROM orchestration_v2_projection_runs AS requested
-                  AND (
+                    JOIN orchestration_v2_projection_subagents AS task
-                    SELECT status FROM orchestration_v2_projection_runs
+                      ON task.subagent_id = json_extract(requested.payload_json, '$.delegatedTaskId')
-                    WHERE thread_id = child.thread_id
+                    WHERE requested.thread_id = child.thread_id
-                      AND NOT (
+                      AND requested.status IN ('completed', 'interrupted', 'failed', 'cancelled', 'rolled_back')
-                        status = 'queued'
+                      AND task.child_thread_id = child.thread_id
-                        AND json_extract(payload_json, '$.queueHeld') IS 1
+                      AND json_extract(task.payload_json, '$.origin') = 'app_owned'
-                      )
+                      AND json_extract(task.payload_json, '$.result') IS NULL
-                    ORDER BY ordinal DESC LIMIT 1
+                  ) OR (
-                  ) IN ('completed', 'interrupted', 'failed', 'cancelled', 'rolled_back')
+                    -- The original task still waits for the latest unheld work.
-                  AND NOT EXISTS (
+                    (SELECT status FROM orchestration_v2_projection_runs
+                     WHERE thread_id = child.thread_id
+                       AND NOT (status = 'queued' AND json_extract(payload_json, '$.queueHeld') IS 1)
+                     ORDER BY ordinal DESC LIMIT 1
+                    ) IN ('completed', 'interrupted', 'failed', 'cancelled', 'rolled_back')
+                    AND NOT EXISTS (
                     SELECT 1 FROM orchestration_v2_projection_context_transfers
                     WHERE source_thread_id = child.thread_id
                       AND target_thread_id = json_extract(child.payload_json, '$.lineage.parentThreadId')
                       AND type = 'subagent_result'
-                  )
+                  )))
                   ELSE 0 END
               `;
             case "runtime":
 @@ -6121,7 +6140,15 @@ export const layerMemory: Layer.Layer<ProjectionStoreV2> = Layer.effect(
         Effect.gen(function* () {
           const projections = (yield* Ref.get(replayState)).projections;
           return [...projections.values()]
-            .filter((projection) => needsRecovery(projection, kind))
+            .filter((projection) =>
+              needsRecovery(
+                projection,
+                kind,
+                projection.thread.lineage.parentThreadId === null
+                  ? undefined
+                  : projections.get(projection.thread.lineage.parentThreadId),
+              ),
+            )
             .toSorted(
               (left, right) =>
                 DateTime.toEpochMillis(left.thread.updatedAt) -

apps/web/src/components/chat/ThreadRelationshipsControl.tsx+23-11

 @@ -170,23 +170,35 @@ function relationshipThreadTitle(input: {
 }
 /**
- * A delegated task settles with its first run, but the parent can keep sending
+ * The row's timer and hover card follow current child work, including queued
- * the child follow-ups. While the child thread has a live run, the row's timer
+ * follow-ups whose provider turn has not started yet.
- * and hover card follow that run instead of the settled task.
  */
-function liveSubagent<Agent extends RuntimeSubagent>(
+function currentSubagent<Agent extends RuntimeSubagent>(
   agent: Agent | undefined,
   childThread: OrchestrationV2ThreadShell | null | undefined,
 ): Agent | undefined {
-  const liveStatus = childThread?.activityRunStatus;
+  const liveStatus =
-  if (!agent || !liveStatus) return agent;
+    childThread?.activityRunStatus ?? (childThread?.status === "queued" ? "queued" : null);
-  const startedAt = childThread.activityRunStartedAt;
+  if (!agent || !childThread) return agent;
+  const newerRun =
+    childThread.latestRunRequestedAt &&
+    DateTime.toEpochMillis(childThread.latestRunRequestedAt) >
+      Date.parse(agent.completedAt ?? agent.startedAt ?? agent.updatedAt);
+  if (!liveStatus && !newerRun) return agent;
+  const status = liveStatus ?? childThread.status;
+  const startedAt = liveStatus ? childThread.activityRunStartedAt : childThread.latestRunStartedAt;
+  const completedAt = liveStatus ? null : childThread.latestRunCompletedAt;
   return {
     ...agent,
-    status: liveStatus === "running" || liveStatus === "waiting" ? liveStatus : "pending",
+    status:
+      status === "preparing" || status === "starting" || status === "queued"
+        ? "pending"
+        : status === "rolled_back"
+          ? "interrupted"
+          : status,
     startedAt: startedAt ? DateTime.formatIso(startedAt) : null,
-    completedAt: null,
+    completedAt: completedAt ? DateTime.formatIso(completedAt) : null,
-    // The settled task's output belongs to its first run, not this one.
+    // The task's output belongs to its recorded run, not newer child work.
     progress: null,
     result: null,
     error: null,
 @@ -380,7 +392,7 @@ export function ThreadRelationshipsPanel(props: {
                   ? BotIcon
                   : GitForkIcon;
               const relationship = relationshipLabel(edge, props.threadId);
-              const agent = liveSubagent(
+              const agent = currentSubagent(
                 isSubagent && !isParent ? subagentsByThreadId.get(threadId) : undefined,
                 node?.thread,
               );

packages/client-runtime/src/state/threadRelationships.test.ts+12-5

 @@ -188,11 +188,17 @@ describe("thread relationships", () => {
   });
   it.each([
-    ["running", "running"],
+    ["running", "running", "running"],
-    [null, "completed"],
+    ["waiting", "completed", "waiting"],
+    [null, "queued", "queued"],
+    [null, "failed", "failed"],
+    [null, "interrupted", "interrupted"],
+    [null, "cancelled", "cancelled"],
+    [null, "completed", "completed"],
+    [null, "rolled_back", "interrupted"],
   ])(
-    "shows a subagent whose child activity is %s as %s after its delegated task settled",
+    "shows child activity %s and latest status %s as %s after its delegated task settled",
-    (childActivity, expected) => {
+    (childActivity, childStatus, expected) => {
       const parent = ThreadId.make("thread-parent");
       const child = ThreadId.make("thread-child");
       const graph = deriveThreadRelationshipGraph({
 @@ -200,8 +206,9 @@ describe("thread relationships", () => {
           { id: parent, status: "completed", forkedFrom: null, lineage: { parentThreadId: null } },
           {
             id: child,
-            status: childActivity ?? "completed",
+            status: childStatus,
             activityRunStatus: childActivity,
+            latestRunId: "run-child-followup",
             forkedFrom: null,
             lineage: { parentThreadId: parent, relationshipToParent: "subagent" },
           },

packages/client-runtime/src/state/threadRelationships.ts+11-5

 @@ -71,7 +71,12 @@ export function deriveThreadRelationshipGraph(input: {
   const addEdge = (edge: ThreadRelationshipEdge) => {
     ensureNode(edge.sourceThreadId);
     ensureNode(edge.targetThreadId);
-    edgesByKey.set(edgeKey(edge), edge);
+    edgesByKey.set(
+      edgeKey(edge),
+      edge.kind === "subagent" && edge.status === "rolled_back"
+        ? { ...edge, status: "interrupted" }
+        : edge,
+    );
   };
   for (const thread of threads) {
 @@ -92,14 +97,15 @@ export function deriveThreadRelationshipGraph(input: {
     const ownerThreadId = input.projection.thread.id;
     for (const subagent of input.projection.subagents) {
       if (subagent.childThreadId === null) continue;
-      // The subagent record settles with the delegated task's first run, but the
+      const child = threadsById.get(subagent.childThreadId);
-      // parent can keep sending the child follow-ups. A live run on the child
+      // The row describes the child conversation, including queued follow-ups
-      // thread outranks that settled status.
+      // and their outcomes. A child without an app run still uses its task.
       addEdge({
         sourceThreadId: ownerThreadId,
         targetThreadId: subagent.childThreadId,
         kind: "subagent",
-        status: threadsById.get(subagent.childThreadId)?.activityRunStatus ?? subagent.status,
+        status:
+          child?.activityRunStatus ?? (child?.latestRunId != null ? child.status : subagent.status),
       });
     }
     for (const transfer of input.projection.contextTransfers) {

packages/contracts/src/orchestrationV2.ts+2

...	@@ -561,6 +561,8 @@ export const OrchestrationV2Run = Schema.Struct({	...	@@ -561,6 +561,8 @@ export const OrchestrationV2Run = Schema.Struct({
561	contextHandoffId: Schema.NullOr(ContextHandoffId),	561	contextHandoffId: Schema.NullOr(ContextHandoffId),
562	/** Links server-generated restart continuations to the interrupted run. */	562	/** Links server-generated restart continuations to the interrupted run. */
563	restartContinuationOfRunId: Schema.optional(RunId),	563	restartContinuationOfRunId: Schema.optional(RunId),
		564	/** The delegated task this run answers, including a follow-up in an existing child thread. */
		565	delegatedTaskId: Schema.optional(NodeId),
564	/**	566	/**
565	* Set on wake runs (background notifications, delegated task results,	567	* Set on wake runs (background notifications, delegated task results,
566	* restart continuations): when the work they continue started. Read it	568	* restart continuations): when the work they continue started. Read it

packages/contracts/src/orchestratorMcp.ts+2

...	@@ -434,6 +434,8 @@ export const OrchestratorMcpThreadSendResult = Schema.Struct({	...	@@ -434,6 +434,8 @@ export const OrchestratorMcpThreadSendResult = Schema.Struct({
434	threadId: ThreadId,	434	threadId: ThreadId,
435	messageId: MessageId,	435	messageId: MessageId,
436	runId: RunId,	436	runId: RunId,
		437	/** Fresh task for a follow-up to an app-owned child; the previous task stays terminal. */
		438	taskId: Schema.optional(NodeId),
437	status: OrchestrationV2RunStatus,	439	status: OrchestrationV2RunStatus,
438	delivery: Schema.Literals(["started", "queued", "steered", "restarted"]),	440	delivery: Schema.Literals(["started", "queued", "steered", "restarted"]),
439	});	441	});

author	Yash Singh <saiansh2525@gmail.com> 2026-10-10 00:10:10-05:00
committer	GitHub <noreply@github.com> 2026-10-10 00:10:10-05:00
log	c572cb71d2711d8cdb4ff7e0ba88af5e9a23aa81
tree	0685f7d7fdcd522f63d0eb460ab56c2ddc377b99
parent	fa9f936ef5cbbe4bd4f9890b638766fc92f45075
signature	Signed by PGP key B5690EEEBB952194

fix(server): track resumed subagent follow-ups as separate tasks (#17696)