The best way to control Claude Code, Codex and more from any computer or phone
fix(server): a follow-up delegated task waits for a run its child queued on its own thread (#32504)
Julius Marminge committed
Nov 11, 2026 at 01:11 UTC
24e77473ecf41bc1f7142529c7911c1c1aae1d76
4 files changed
+310
-8
apps/server/src/mcp/OrchestratorMcpService.ts
+2
-4
@@ -100,7 +100,7 @@ import type {
100
ProjectionRecordField,
101
ProjectionRecordFilter,
102
} from "../orchestration-v2/ProjectionStore.ts";
103
-import { runOutcome } from "../orchestration-v2/RestartBackgroundNote.ts";
103
+import { delegatedTaskResultRun, runOutcome } from "../orchestration-v2/RestartBackgroundNote.ts";
104
import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
105
import * as ThreadLaunchService from "../orchestration-v2/ThreadLaunchService.ts";
106
import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
@@ -1489,9 +1489,7 @@ const make = Effect.gen(function* () {
1489
const progress = delegatedTaskProgress(childControls);
1490
const taskResultRun =
1491
childRun?.delegatedTaskId === task.id
1492
- ? childControls.runs
1493
- .filter((run) => run.delegatedTaskId === task.id)
1494
- .toSorted((a, b) => b.ordinal - a.ordinal)[0]
1492
+ ? delegatedTaskResultRun(childControls.runs, task.id)
1493
: progress.resultRun;
1494
const taskWorkState =
1495
childRun?.delegatedTaskId === task.id
apps/server/src/orchestration-v2/DelegatedCompletionDelivery.test.ts
+281
@@ -2498,6 +2498,287 @@ it.layer(Layer.merge(layerTest, ProviderContinuationRequests.layer))(
2498
}),
2499
);
2500
2501
+ // The child's follow-up run sends `t3_thread_send` to its own thread before it ends.
2502
+ const startSelfQueuedFollowup = (name: string) =>
2503
+ Effect.gen(function* () {
2504
+ const orchestrator = yield* Orchestrator.OrchestratorV2;
2505
+ const eventSink = yield* EventSink.EventSinkV2;
2506
+ const requests = yield* ProviderContinuationRequests.ProviderContinuationRequests;
2507
+ const now = yield* DateTime.now;
2508
+ const parentThreadId = ThreadId.make(`thread:${name}-parent`);
2509
+ const projectId = ProjectId.make(`project:${name}`);
2510
+ const parentRunId = RunId.make(`run:${name}-parent`);
2511
+ const rootNodeId = NodeId.make(`node:${name}-parent`);
2512
+ yield* seedParentWithTerminalTask({
2513
+ threadId: parentThreadId,
2514
+ projectId,
2515
+ runId: parentRunId,
2516
+ rootNodeId,
2517
+ taskId: NodeId.make(`node:${name}-seed`),
2518
+ deliveryState: "acknowledged",
2519
+ now,
2520
+ });
2521
+ const child = yield* seedRestartCancelledChild({
2522
+ parentThreadId,
2523
+ projectId,
2524
+ parentRunId,
2525
+ rootNodeId,
2526
+ name: `${name}-child`,
2527
+ completionWake: "always",
2528
+ continuationPending: false,
2529
+ runStatus: "completed",
2530
+ now,
2531
+ });
2532
+ yield* orchestrator.recoverDelegatedTasks;
2533
+ let firstWake = yield* requests.take;
2534
+ while (firstWake.threadId !== parentThreadId) firstWake = yield* requests.take;
2535
+ yield* orchestrator.dispatch({
2536
+ type: "delegated_task.completion-delivery.acknowledge",
2537
+ commandId: CommandId.make(`command:${name}-ack`),
2538
+ parentThreadId,
2539
+ taskId: child.taskId,
2540
+ observedByRunId: parentRunId,
2541
+ });
2542
+ const parentRun = (yield* orchestrator.getThreadProjection(parentThreadId)).runs.find(
2543
+ (run) => run.id === parentRunId,
2544
+ )!;
2545
+ yield* eventSink.write({
2546
+ commandId: reconcileCommandId(`${name}-parent-finished`),
2547
+ events: [
2548
+ {
2549
+ id: EventId.make(`event:${name}-parent-finished`),
2550
+ type: "run.updated",
2551
+ threadId: parentThreadId,
2552
+ runId: parentRunId,
2553
+ occurredAt: now,
2554
+ payload: { ...parentRun, status: "completed", completedAt: now },
2555
+ },
2556
+ ],
2557
+ });
2558
+ const followupMessageId = MessageId.make(`message:${name}`);
2559
+ yield* orchestrator.dispatch({
2560
+ type: "message.dispatch",
2561
+ createdBy: "agent",
2562
+ creationSource: "mcp",
2563
+ commandId: CommandId.make(`command:${name}`),
2564
+ threadId: child.childThreadId,
2565
+ senderThreadId: parentThreadId,
2566
+ messageId: followupMessageId,
2567
+ text: "Check the same work again.",
2568
+ attachments: [],
2569
+ dispatchMode: { type: "start_immediately" },
2570
+ });
2571
+ const queuedRun = (yield* orchestrator.getThreadProjection(child.childThreadId)).runs.find(
2572
+ (row) => row.userMessageId === followupMessageId,
2573
+ )!;
2574
+ const followupTaskId = queuedRun.delegatedTaskId;
2575
+ assert.isDefined(followupTaskId);
2576
+ const followupRun = { ...queuedRun, status: "running" as const, startedAt: now };
2577
+ yield* eventSink.write({
2578
+ commandId: reconcileCommandId(`${name}-running`),
2579
+ events: [
2580
+ {
2581
+ id: EventId.make(`event:${name}-running`),
2582
+ type: "run.updated",
2583
+ threadId: child.childThreadId,
2584
+ runId: followupRun.id,
2585
+ occurredAt: now,
2586
+ payload: followupRun,
2587
+ },
2588
+ ],
2589
+ });
2590
+ const selfQueuedMessageId = MessageId.make(`message:${name}-self-send`);
2591
+ yield* orchestrator.dispatch({
2592
+ type: "message.dispatch",
2593
+ createdBy: "agent",
2594
+ creationSource: "mcp",
2595
+ commandId: CommandId.make(`command:${name}-self-send`),
2596
+ threadId: child.childThreadId,
2597
+ senderThreadId: child.childThreadId,
2598
+ messageId: selfQueuedMessageId,
2599
+ text: "Finish the work after this turn.",
2600
+ attachments: [],
2601
+ dispatchMode: { type: "queue_after_active" },
2602
+ });
2603
+ const selfQueuedRun = (yield* orchestrator.getThreadProjection(
2604
+ child.childThreadId,
2605
+ )).runs.find((row) => row.userMessageId === selfQueuedMessageId)!;
2606
+ assert.equal(selfQueuedRun.status, "queued");
2607
+ const finishRun = (step: string, run: OrchestrationV2Run, text: string) =>
2608
+ eventSink.write({
2609
+ commandId: reconcileCommandId(`${name}-${step}`),
2610
+ events: [
2611
+ {
2612
+ id: EventId.make(`event:${name}-${step}:result`),
2613
+ type: "message.updated",
2614
+ threadId: child.childThreadId,
2615
+ runId: run.id,
2616
+ occurredAt: now,
2617
+ payload: {
2618
+ id: MessageId.make(`message:${name}-${step}:result`),
2619
+ threadId: child.childThreadId,
2620
+ runId: run.id,
2621
+ nodeId: null,
2622
+ role: "assistant",
2623
+ text,
2624
+ attachments: [],
2625
+ streaming: false,
2626
+ createdBy: "agent",
2627
+ creationSource: "server",
2628
+ createdAt: now,
2629
+ updatedAt: now,
2630
+ },
2631
+ },
2632
+ {
2633
+ id: EventId.make(`event:${name}-${step}:finished`),
2634
+ type: "run.updated",
2635
+ threadId: child.childThreadId,
2636
+ runId: run.id,
2637
+ occurredAt: now,
2638
+ payload: { ...run, status: "completed", startedAt: now, completedAt: now },
2639
+ },
2640
+ ],
2641
+ });
2642
+ const removeSelfQueuedRun = orchestrator.dispatch({
2643
+ type: "queued-run.cancel",
2644
+ commandId: CommandId.make(`command:${name}-remove-self-send`),
2645
+ threadId: child.childThreadId,
2646
+ runId: selfQueuedRun.id,
2647
+ });
2648
+ const readFollowup = Effect.gen(function* () {
2649
+ yield* orchestrator.recoverDelegatedTasks;
2650
+ return (yield* orchestrator.getThreadProjection(parentThreadId)).subagents.find(
2651
+ (task) => task.id === followupTaskId,
2652
+ )!;
2653
+ });
2654
+ return {
2655
+ parentThreadId,
2656
+ parentRunId,
2657
+ childThreadId: child.childThreadId,
2658
+ firstWake,
2659
+ followupRun,
2660
+ selfQueuedRun,
2661
+ finishRun,
2662
+ removeSelfQueuedRun,
2663
+ readFollowup,
2664
+ };
2665
+ });
2666
+
2667
+ it.effect("waits for a run the follow-up's child queued on its own thread", () =>
2668
+ Effect.gen(function* () {
2669
+ const requests = yield* ProviderContinuationRequests.ProviderContinuationRequests;
2670
+ const followup = yield* startSelfQueuedFollowup("self-queued-followup");
2671
+ yield* followup.finishRun("handoff", followup.followupRun, "HANDOFF-C");
2672
+ const waiting = yield* followup.readFollowup;
2673
+ assert.isNull(
2674
+ waiting.result,
2675
+ "the follow-up task settled on its handoff turn while the run its child queued was pending",
2676
+ );
2677
+ assert.notEqual(waiting.status, "completed");
2678
+
2679
+ yield* followup.finishRun("final", followup.selfQueuedRun, "FINAL-D");
2680
+ const finished = yield* followup.readFollowup;
2681
+ assert.equal(finished.status, "completed");
2682
+ assert.equal(finished.result, "FINAL-D");
2683
+ assert.equal(finished.completionDelivery?.state, "claimed");
2684
+ let wake = yield* requests.take;
2685
+ while (
2686
+ wake.threadId !== followup.parentThreadId ||
2687
+ wake.delegatedCompletion?.messageId === followup.firstWake.delegatedCompletion?.messageId
2688
+ ) {
2689
+ wake = yield* requests.take;
2690
+ }
2691
+ assert.equal(wake.delegatedCompletion?.parentRunId, followup.parentRunId);
2692
+ }),
2693
+ );
2694
+
2695
+ it.effect("keeps a follow-up running when the run its child queued is removed early", () =>
2696
+ Effect.gen(function* () {
2697
+ const followup = yield* startSelfQueuedFollowup("self-queued-removed-early-followup");
2698
+ yield* followup.removeSelfQueuedRun;
2699
+ const running = yield* followup.readFollowup;
2700
+ assert.isNull(running.result);
2701
+ assert.equal(running.status, "running");
2702
+
2703
+ yield* followup.finishRun("handoff", followup.followupRun, "HANDOFF-C");
2704
+ const finished = yield* followup.readFollowup;
2705
+ assert.equal(finished.status, "completed");
2706
+ assert.equal(finished.result, "HANDOFF-C");
2707
+ }),
2708
+ );
2709
+
2710
+ it.effect.each(["removed", "held"] as const)(
2711
+ "settles a follow-up on its last turn when the run it queued is %s",
2712
+ (ending) =>
2713
+ Effect.gen(function* () {
2714
+ const eventSink = yield* EventSink.EventSinkV2;
2715
+ const now = yield* DateTime.now;
2716
+ const followup = yield* startSelfQueuedFollowup(`self-queued-${ending}-followup`);
2717
+ if (ending === "held") {
2718
+ yield* eventSink.write({
2719
+ commandId: reconcileCommandId("self-queued-held-followup-hold"),
2720
+ events: [
2721
+ {
2722
+ id: EventId.make("event:self-queued-held-followup-hold"),
2723
+ type: "run.updated",
2724
+ threadId: followup.childThreadId,
2725
+ runId: followup.selfQueuedRun.id,
2726
+ occurredAt: now,
2727
+ payload: { ...followup.selfQueuedRun, queueHeld: true },
2728
+ },
2729
+ ],
2730
+ });
2731
+ }
2732
+ yield* followup.finishRun("handoff", followup.followupRun, "HANDOFF-C");
2733
+ if (ending === "removed") yield* followup.removeSelfQueuedRun;
2734
+ const finished = yield* followup.readFollowup;
2735
+ assert.equal(finished.status, "completed");
2736
+ assert.equal(finished.result, "HANDOFF-C");
2737
+ }),
2738
+ );
2739
+
2740
+ it.effect("waits for every run its child queued when a later one is moved ahead", () =>
2741
+ Effect.gen(function* () {
2742
+ const orchestrator = yield* Orchestrator.OrchestratorV2;
2743
+ const followup = yield* startSelfQueuedFollowup("self-queued-reordered-followup");
2744
+ const laterMessageId = MessageId.make("message:self-queued-reordered-followup-later");
2745
+ yield* orchestrator.dispatch({
2746
+ type: "message.dispatch",
2747
+ createdBy: "agent",
2748
+ creationSource: "mcp",
2749
+ commandId: CommandId.make("command:self-queued-reordered-followup-later"),
2750
+ threadId: followup.childThreadId,
2751
+ senderThreadId: followup.childThreadId,
2752
+ messageId: laterMessageId,
2753
+ text: "Do this part first.",
2754
+ attachments: [],
2755
+ dispatchMode: { type: "queue_after_active" },
2756
+ });
2757
+ const later = (yield* orchestrator.getThreadProjection(followup.childThreadId)).runs.find(
2758
+ (run) => run.userMessageId === laterMessageId,
2759
+ )!;
2760
+ yield* orchestrator.dispatch({
2761
+ type: "queued-run.reorder",
2762
+ commandId: CommandId.make("command:self-queued-reordered-followup-reorder"),
2763
+ threadId: followup.childThreadId,
2764
+ runId: later.id,
2765
+ beforeRunId: followup.selfQueuedRun.id,
2766
+ });
2767
+ assert.equal((yield* followup.readFollowup).status, "running");
2768
+ yield* followup.finishRun("handoff", followup.followupRun, "HANDOFF-C");
2769
+ yield* followup.finishRun("later", later, "PART-ONE");
2770
+ const waiting = yield* followup.readFollowup;
2771
+ assert.isNull(waiting.result, "the follow-up settled while an earlier queued run waited");
2772
+
2773
+ // Promotion moves a queued run after the runs that started ahead of it.
2774
+ const promoted = { ...followup.selfQueuedRun, ordinal: later.ordinal + 1 };
2775
+ yield* followup.finishRun("final", promoted, "FINAL-D");
2776
+ const finished = yield* followup.readFollowup;
2777
+ assert.equal(finished.status, "completed");
2778
+ assert.equal(finished.result, "FINAL-D");
2779
+ }),
2780
+ );
2781
+
2782
const outcomes = [
2783
"completed",
2784
"failed",
apps/server/src/orchestration-v2/Orchestrator.ts
+8
-4
@@ -124,6 +124,7 @@ import {
124
cancelledBeforeStart,
125
continuationFailedBeforePrompt,
126
continuationStartRetryDelayMs,
127
+ delegatedTaskResultRun,
128
isRestartContinuationSource,
129
runOutcome,
130
} from "./RestartBackgroundNote.ts";
@@ -6035,8 +6036,11 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
6036
projection = applyToProjection(projection, event);
6037
}
6038
6038
- const continuedTaskId = projection.runs.find(
6039
- (run) => run.id === command.restartContinuationOfRunId,
6039
+ // A run the thread queues for itself continues the task of the run that sent it.
6040
+ const continuedTaskId = projection.runs.find((run) =>
6041
+ command.restartContinuationOfRunId === undefined
6042
+ ? command.senderThreadId === command.threadId && isActiveRun(run)
6043
+ : run.id === command.restartContinuationOfRunId,
6044
)?.delegatedTaskId;
6045
6046
if (projection.thread.settledOverride !== null) {
@@ -13029,7 +13033,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
13033
? options.task.id === forkedFrom.nodeId
13034
? options.resultRun
13035
: undefined
13032
- : taskRuns.toSorted((a, b) => b.ordinal - a.ordinal)[0];
13036
+ : delegatedTaskResultRun(taskRuns, options.task.id);
13037
if (childRun === undefined) return;
13038
const outcome = runOutcome(childRun);
13039
const terminalStatus = delegatedTaskTerminalStatus(outcome);
@@ -14543,7 +14547,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
14547
);
14548
if (taskId !== undefined) {
14549
const runs = child.runs.filter((run) => run.delegatedTaskId === taskId);
14546
- const run = runs.toSorted((a, b) => b.ordinal - a.ordinal)[0];
14550
+ const run = delegatedTaskResultRun(runs, taskId);
14551
if (run === undefined || delegatedTaskTerminalStatus(run.status) === null) return true;
14552
return yield* childAwaitsRestartContinuation(runs, run);
14553
}
apps/server/src/orchestration-v2/RestartBackgroundNote.ts
+19
@@ -1,4 +1,5 @@
1
import type {
2
+ NodeId,
3
OrchestrationV2PendingBackgroundTask,
4
OrchestrationV2ProviderTurn,
5
OrchestrationV2RestartCancelledBackgroundWork,
@@ -185,6 +186,24 @@ export function cancelledBeforeStart(
186
return run.status === "cancelled" && neverStarted(run);
187
}
188
189
+/** A follow-up task's latest run, passing over queued work it no longer waits on, as the original task does. */
190
+export function delegatedTaskResultRun(
191
+ runs: ReadonlyArray<OrchestrationV2Run>,
192
+ taskId: NodeId,
193
+): OrchestrationV2Run | undefined {
194
+ const taskRuns = runs
195
+ .filter((run) => run.delegatedTaskId === taskId)
196
+ .toSorted((a, b) => b.ordinal - a.ordinal);
197
+ const awaited = taskRuns.filter(
198
+ (run) => !cancelledBeforeStart(run) && !(run.status === "queued" && run.queueHeld === true),
199
+ );
200
+ // Executing work reports the task's state; a reordered queue can finish a newer run before an older one.
201
+ const executing = awaited.find((run) =>
202
+ ["preparing", "starting", "running", "waiting"].includes(run.status),
203
+ );
204
+ return executing ?? awaited.find((run) => run.status === "queued") ?? awaited[0] ?? taskRuns[0];
205
+}
206
+
207
/** The provider never accepted this continuation's prompt, so starting it again repeats nothing. */
208
export function continuationFailedBeforePrompt(
209
run: Pick<OrchestrationV2Run, "status" | "activeAttemptId" | "restartContinuationOfRunId">,