@devries-cameron20 / t3code Mirror · read-only / commits / d20d535e32
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 18:30 UTC

fix(server): show self-resumed Claude subagents as running (#23831)

Julius Marminge committed Nov 12, 2026 at 19:29 UTC d20d535e32ca1d77f25b6562167aabb5af25bfbe
2 files changed +232 -19
apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
+202
@@ -16478,6 +16478,208 @@ describe("ClaudeAdapterV2 background wake turns", () => {
16478 ),
16479 );
16480
16481 + // Claude reports a background subagent `completed` when its turn ends while
16482 + // its own background shell still runs. When that shell finishes, Claude
16483 + // resumes the subagent with a new task_started for the same task and launch
16484 + // tool_use_id while the root is idle. Frame order mirrors a live capture.
16485 + it.effect("reopens a completed background subagent that resumes while the root is idle", () =>
16486 + Effect.scoped(
16487 + Effect.gen(function* () {
16488 + const TASK_ID = "ae3f32459af762a5f";
16489 + const LAUNCH = "toolu_01LcidmwEK1Y6GC6LpX3kvxX";
16490 + const OWN_SHELL = "toolu_01QAahgijM2KRBBSkWxnui4g";
16491 + const RESUMED_BASH = "toolu_01CkA1juicPNCtQrqKL8h6Rz";
16492 + const harness = yield* makeWakeHarness;
16493 + const now = yield* DateTime.now;
16494 + let sequence = 0;
16495 + const system = (frame: object) =>
16496 + claudeSdkFrame({
16497 + type: "system",
16498 + ...frame,
16499 + uuid: `00000000-0000-4000-8000-0000000162${String(++sequence).padStart(2, "0")}`,
16500 + session_id: WAKE_NATIVE_SESSION,
16501 + });
16502 + const agentEntry = (runId: string) => ({
16503 + task_id: TASK_ID,
16504 + run_id: runId,
16505 + task_type: "local_agent",
16506 + subagent_type: "general-purpose",
16507 + description: "Audit recent commits",
16508 + });
16509 + const shellEntry = (taskId: string) => ({
16510 + task_id: taskId,
16511 + run_id: `run-${taskId}`,
16512 + task_type: "local_bash",
16513 + description: "Sleep",
16514 + parent_task_id: TASK_ID,
16515 + });
16516 + const roster = (tasks: ReadonlyArray<object>) =>
16517 + system({ subtype: "background_tasks_changed", tasks });
16518 + const shellStarted = (taskId: string, toolUseId: string) =>
16519 + system({
16520 + subtype: "task_started",
16521 + task_id: taskId,
16522 + tool_use_id: toolUseId,
16523 + task_type: "local_bash",
16524 + description: "Sleep",
16525 + });
16526 + const startTurn = (ordinal: number, continuation: boolean) =>
16527 + harness.runtime.startTurn(
16528 + makeClaudeTestTurnInput({
16529 + threadId: harness.threadId,
16530 + providerThread: harness.providerThread,
16531 + now,
16532 + attemptId: RunAttemptId.make(`attempt-claude-self-resume-${ordinal}`),
16533 + text: continuation ? "Background task completed." : "Launch a background agent.",
16534 + attachments: [],
16535 + providerTurnOrdinal: ordinal,
16536 + ...(continuation
16537 + ? {
16538 + messageCreatedBy: "agent" as const,
16539 + messageCreationSource: "provider" as const,
16540 + }
16541 + : {}),
16542 + }),
16543 + );
16544 + const subagentUpdates = () =>
16545 + harness.events.flatMap((event) =>
16546 + event.type === "subagent.updated" ? [event.subagent] : [],
16547 + );
16548 +
16549 + yield* startTurn(1, false);
16550 + for (const frame of [
16551 + roster([agentEntry("run-1")]),
16552 + makeSubagentTaskStartedFrame({
16553 + taskId: TASK_ID,
16554 + toolUseId: LAUNCH,
16555 + uuid: "00000000-0000-4000-8000-000000016101",
16556 + }),
16557 + makeResultFrame({ uuid: "00000000-0000-4000-8000-000000016102", result: "LAUNCHED" }),
16558 + ]) {
16559 + yield* harness.offerAndWait(frame);
16560 + }
16561 + yield* Queue.take(harness.terminalReceipts);
16562 +
16563 + // The subagent starts its own background shell, ends its turn, and
16564 + // Claude reports it completed; the parent wakes, answers, goes idle.
16565 + for (const frame of [
16566 + ...makeSubagentAssistantFrames({
16567 + parentToolUseId: LAUNCH,
16568 + uuid: "00000000-0000-4000-8000-000000016103",
16569 + bashToolUseId: OWN_SHELL,
16570 + }),
16571 + roster([agentEntry("run-1"), shellEntry("b455x9pq5")]),
16572 + shellStarted("b455x9pq5", OWN_SHELL),
16573 + makeSubagentToolResultFrame({
16574 + parentToolUseId: LAUNCH,
16575 + uuid: "00000000-0000-4000-8000-000000016104",
16576 + toolUseId: OWN_SHELL,
16577 + }),
16578 + makeSubagentNotificationFrame({
16579 + taskId: TASK_ID,
16580 + toolUseId: LAUNCH,
16581 + summary: "WAITING",
16582 + uuid: "00000000-0000-4000-8000-000000016105",
16583 + }),
16584 + roster([shellEntry("b455x9pq5")]),
16585 + wakeTurnInit,
16586 + ]) {
16587 + yield* harness.offerAndWait(frame);
16588 + }
16589 + yield* Queue.take(harness.continuationReceipts);
16590 + yield* startTurn(2, true);
16591 + yield* harness.offerAndWait(
16592 + makeResultFrame({ uuid: "00000000-0000-4000-8000-000000016106", result: "Noted." }),
16593 + );
16594 + yield* Queue.take(harness.terminalReceipts);
16595 +
16596 + // Its shell finishes and Claude resumes it under a new native run.
16597 + for (const frame of [
16598 + system({
16599 + subtype: "task_notification",
16600 + task_id: "b455x9pq5",
16601 + tool_use_id: OWN_SHELL,
16602 + status: "completed",
16603 + summary: "Background command completed (exit code 0)",
16604 + output_file: "/tmp/b455x9pq5.output",
16605 + }),
16606 + roster([]),
16607 + roster([agentEntry("run-2")]),
16608 + makeSubagentTaskStartedFrame({
16609 + taskId: TASK_ID,
16610 + toolUseId: LAUNCH,
16611 + uuid: "00000000-0000-4000-8000-000000016107",
16612 + }),
16613 + ]) {
16614 + yield* harness.offerAndWait(frame);
16615 + }
16616 + // Events reach the app only through a run, and the launching run ended
16617 + // with the interim completion.
16618 + assert.equal(harness.continuationRequests.length, 2);
16619 +
16620 + yield* Queue.take(harness.continuationReceipts);
16621 + yield* startTurn(3, true);
16622 + // Claude does not wake the root for this, so the root must not stay busy.
16623 + assert.equal((yield* Queue.take(harness.terminalReceipts)).status, "completed");
16624 + yield* startTurn(4, false);
16625 + yield* harness.offerAndWait(
16626 + makeResultFrame({ uuid: "00000000-0000-4000-8000-000000016110", result: "PONG" }),
16627 + );
16628 + assert.equal((yield* Queue.take(harness.terminalReceipts)).status, "completed");
16629 + for (const frame of [
16630 + ...makeSubagentAssistantFrames({
16631 + parentToolUseId: LAUNCH,
16632 + uuid: "00000000-0000-4000-8000-000000016108",
16633 + bashToolUseId: RESUMED_BASH,
16634 + }),
16635 + shellStarted("beyhxkdpc", RESUMED_BASH),
16636 + roster([agentEntry("run-2"), shellEntry("beyhxkdpc")]),
16637 + ]) {
16638 + yield* harness.offerAndWait(frame);
16639 + }
16640 + // Events are ordered: once this roster is recorded, so is every earlier event.
16641 + yield* harness.until(() =>
16642 + harness.events.some(
16643 + (event) =>
16644 + event.type === "provider_thread.updated" &&
16645 + event.providerThread.pendingBackgroundTasks?.some(
16646 + (task) => task.taskId === "beyhxkdpc",
16647 + ) === true,
16648 + ),
16649 + );
16650 + const resumed = subagentUpdates().at(-1);
16651 + assert.equal(resumed?.status, "running");
16652 + assert.isNull(resumed?.completedAt);
16653 + assert.equal(resumed?.runId, "run-attempt-claude-self-resume-3");
16654 + const routing = subagentRouting(harness.events, [RESUMED_BASH]);
16655 + assert.deepEqual(
16656 + [...(routing.toolThreadIds.get(RESUMED_BASH) ?? [])],
16657 + [routing.childThreadId],
16658 + );
16659 +
16660 + yield* harness.offerAndWait(
16661 + makeSubagentNotificationFrame({
16662 + taskId: TASK_ID,
16663 + toolUseId: LAUNCH,
16664 + summary: "DONE",
16665 + uuid: "00000000-0000-4000-8000-000000016109",
16666 + }),
16667 + );
16668 + yield* harness.until(() => subagentUpdates().at(-1)?.result === "DONE");
16669 + assert.equal(subagentUpdates().at(-1)?.status, "completed");
16670 + }).pipe(
16671 + Effect.provide(
16672 + Layer.mergeAll(
16673 + IdAllocator.layer,
16674 + McpProviderSessions.layer,
16675 + NodeServices.layer,
16676 + NodeCrypto.layer,
16677 + ),
16678 + ),
16679 + ),
16680 + ),
16681 + );
16682 +
16683 it.effect("keeps a nested subagent's launch in order while the root turn is idle", () =>
16684 Effect.scoped(
16685 Effect.gen(function* () {
apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
+30 -19
@@ -9234,31 +9234,41 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
9234 message.type === "system" &&
9235 message.subtype === "task_started" &&
9236 (yield* Ref.get(sessionSubagentsByTaskId)).has(message.task_id);
9237 + // A completed subagent that Claude resumes on its own (under its launch
9238 + // call, unlike SendMessage) has no live run left to show it while the
9239 + // root is idle; only a continuation does.
9240 + let isResumedSubagentTaskStarted = false;
9241 if (
9242 isKnownSubagentTaskStarted &&
9243 message.type === "system" &&
9244 message.subtype === "task_started"
9245 ) {
9246 const now = yield* DateTime.now;
9243 - yield* Ref.update(sessionSubagentsByTaskId, (current) => {
9244 - const registered = current.get(message.task_id);
9245 - if (registered === undefined || registered.task.status === "running") {
9246 - return current;
9247 - }
9248 - const { progress: _staleProgress, ...priorTask } = registered.task;
9249 - return new Map(current).set(message.task_id, {
9250 - ...registered,
9251 - confirmedOutcome: undefined,
9252 - task: {
9253 - ...priorTask,
9254 - status: "running",
9255 - result: null,
9256 - startedAt: now,
9257 - completedAt: null,
9258 - updatedAt: now,
9259 - },
9260 - });
9261 - });
9247 + isResumedSubagentTaskStarted = yield* Ref.modify(
9248 + sessionSubagentsByTaskId,
9249 + (current) => {
9250 + const registered = current.get(message.task_id);
9251 + if (registered === undefined || registered.task.status === "running") {
9252 + return [false, current] as const;
9253 + }
9254 + const { progress: _staleProgress, ...priorTask } = registered.task;
9255 + return [
9256 + registered.runToolUseId === message.tool_use_id,
9257 + new Map(current).set(message.task_id, {
9258 + ...registered,
9259 + confirmedOutcome: undefined,
9260 + task: {
9261 + ...priorTask,
9262 + status: "running",
9263 + result: null,
9264 + startedAt: now,
9265 + completedAt: null,
9266 + updatedAt: now,
9267 + },
9268 + }),
9269 + ] as const;
9270 + },
9271 + );
9272 }
9273 const isWakeTurnStart = isClaudeTurnStartMessage(message);
9274 const isWakeEvidence =
@@ -9373,6 +9383,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
9383 parentToolUseIdFromSdkMessage(message) === null;
9384 if (
9385 !isPendingSubagentNotification &&
9386 + !isResumedSubagentTaskStarted &&
9387 !isNativeOpaqueWakeFrame &&
9388 !isWakeTurnStart &&
9389 message.type !== "result"