From 709170a2d829e36e62087ad4f7bc27d45c25e4ea Mon Sep 17 00:00:00 2001 From: Bil0000 <62337003+Bil0000@users.noreply.github.com> Date: Thu, 19 Nov 2026 04:02:50 +0100 Subject: [PATCH 1/4] fix(server): a background subagent can delegate after its parent's turn ends A Claude background Workflow kept running after the parent turn settled. Its agents called delegate_task and got parent_not_active, so they fell back to shelling out, and the delegated work never showed as a subagent. delegate_task now attaches to the latest settled run while a pending background subagent of the caller's provider instance is still live, at MCP admission and in the orchestrator decider. A late subagent card no longer stretches the settled turn's "Worked for" duration. Rebased from pingdotgg/t3code#23553. Co-authored-by: Julius Marminge --- apps/server/src/mcp/OrchestratorMcpService.ts | 27 +- ...skCancelNativeSubagent.integration.test.ts | 366 ++++++++++++++++++ apps/server/src/mcp/threadAccess.ts | 6 +- .../src/orchestration-v2/Orchestrator.ts | 22 +- .../chat/MessagesTimeline.logic.test.ts | 33 +- .../components/chat/MessagesTimeline.logic.ts | 12 +- .../orchestrationV2PendingBackgroundWork.ts | 12 + 7 files changed, 461 insertions(+), 17 deletions(-) diff --git a/apps/server/src/mcp/OrchestratorMcpService.ts b/apps/server/src/mcp/OrchestratorMcpService.ts index 8dcd025c82481..3f1c51581c21d 100644 --- a/apps/server/src/mcp/OrchestratorMcpService.ts +++ b/apps/server/src/mcp/OrchestratorMcpService.ts @@ -1471,6 +1471,27 @@ const make = Effect.gen(function* () { : Effect.void; }; + // A background subagent keeps calling tools after the run that started it settles. Its + // delegations join that latest run, whose completion cohort wakes the thread once they finish. + const backgroundSubagentRun = Effect.fn("OrchestratorMcpService.backgroundSubagentRun")( + function* (scope: McpInvocationScope, threadId: ThreadId) { + const shell = yield* threadManagement + .getThreadShell(threadId) + .pipe(Effect.mapError(threadManagementFailure)); + if ( + shell?.activeRunId !== null || + shell.latestRunId === null || + !isLiveCallerShell(shell, scope.thread?.providerInstanceId) + ) { + return undefined; + } + const { runs } = yield* loadThreadRecords(threadId, ["runs"], { + runIds: [shell.latestRunId], + }); + return runs[0]; + }, + ); + const loadReadableThread = Effect.fn("OrchestratorMcpService.loadReadableThread")(function* ( scope: McpInvocationScope, threadId: ThreadId, @@ -2703,9 +2724,9 @@ const make = Effect.gen(function* () { "A local task runs in this thread's project. Omit target.projectId, or pass target.environmentId to run it in that environment's project.", ); } - const parentRun = parent.runs - .filter(ThreadManagementService.isActiveRun) - .toSorted((left, right) => right.ordinal - left.ordinal)[0]; + const parentRun = + ThreadManagementService.latestActiveRun(parent) ?? + (yield* backgroundSubagentRun(scope, parent.thread.id)); if ( parentRun === undefined || parentRun.rootNodeId === null || diff --git a/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts b/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts index bbc3fbf06940d..a19808bb39673 100644 --- a/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts +++ b/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts @@ -17,6 +17,7 @@ import { ThreadId, TurnItemId, type OrchestrationV2DomainEvent, + type ServerProvider, } from "@t3tools/contracts"; import * as DateTime from "effect/DateTime"; import * as Effect from "effect/Effect"; @@ -57,6 +58,134 @@ const layerOrchestratorService = OrchestratorMcpService.layer.pipe( const driver = ProviderDriverKind.make("claudeAgent"); const instanceId = ProviderInstanceId.make("claudeAgent"); const modelSelection = { instanceId, model: "claude-test" }; +const provider: ServerProvider = { + instanceId, + driver, + enabled: true, + installed: true, + version: "test", + status: "ready", + auth: { status: "authenticated" }, + checkedAt: "2026-10-22T00:00:00.000Z", + models: [ + { slug: modelSelection.model, name: modelSelection.model, isCustom: false, capabilities: null }, + ], + slashCommands: [], + skills: [], +}; + +const makeHarness = Effect.fn(function* (name: string) { + const cwd = yield* checkpointWorkspace(name); + const turns: Array<{ + readonly turn: ProviderAdapter.ProviderAdapterV2TurnInput; + readonly events: Queue.Queue; + }> = []; + const adapter: ProviderAdapter.ProviderAdapterV2["Service"] = { + instanceId, + driver, + getCapabilities: () => Effect.succeed(ClaudeProviderCapabilitiesV2), + planSelectionTransition: () => Effect.succeed({ type: "apply_on_next_turn" }), + openSession: (input) => + Effect.gen(function* () { + const now = yield* DateTime.now; + const events = yield* Queue.unbounded(); + return { + instanceId, + driver, + providerSessionId: input.providerSessionId, + providerSession: { + id: input.providerSessionId, + driver, + providerInstanceId: instanceId, + status: "ready", + cwd, + model: modelSelection.model, + capabilities: ClaudeProviderCapabilitiesV2, + createdAt: now, + updatedAt: now, + lastError: null, + }, + events: Stream.fromQueue(events), + ensureThread: ({ threadId }) => + Effect.succeed({ + id: ProviderThreadId.make(`provider-thread:${threadId}`), + driver, + providerInstanceId: instanceId, + providerSessionId: input.providerSessionId, + appThreadId: threadId, + ownerNodeId: null, + nativeThreadRef: { driver, nativeId: `native:${threadId}`, strength: "strong" }, + nativeConversationHeadRef: null, + status: "idle", + firstRunOrdinal: null, + lastRunOrdinal: null, + handoffIds: [], + forkedFrom: null, + createdAt: now, + updatedAt: now, + }), + resumeThread: ({ providerThread }) => Effect.succeed(providerThread), + startTurn: (turn) => + Effect.gen(function* () { + turns.push({ turn, events }); + yield* Queue.offer(events, { + type: "provider_turn.updated", + driver, + providerTurn: { + id: ProviderTurnId.make(`provider-turn:${turn.attemptId}`), + providerThreadId: turn.providerThread.id, + nodeId: turn.rootNodeId, + runAttemptId: turn.attemptId, + nativeTurnRef: null, + ordinal: turn.providerTurnOrdinal, + status: "running", + startedAt: now, + completedAt: null, + }, + }); + }), + steerTurn: () => Effect.die("unused"), + interruptTurn: () => Effect.void, + respondToRuntimeRequest: () => Effect.die("unused"), + readThreadSnapshot: () => Effect.die("unused"), + rollbackThread: () => Effect.die("unused"), + forkThread: () => Effect.die("unused"), + }; + }), + }; + const layerAdapters = ProviderAdapterRegistry.layerSingle(adapter); + const layerOrchestrator = ProviderReplayHarness.layerWithRegistry({ name }, layerAdapters, { + runEffectWorker: false, + }); + const layerOrchestration = Layer.merge( + layerOrchestrator, + ThreadManagementService.layer.pipe( + Layer.provide(layerOrchestrator), + Layer.provide(ServerSettings.layerTest()), + Layer.provide(CommandReceiptStore.layer.pipe(Layer.provide(SqlitePersistence.layerMemory))), + ), + ); + const layerTest = layerOrchestratorService.pipe( + Layer.provideMerge(layerOrchestration), + Layer.provide( + Layer.mergeAll( + layerAdapters, + Layer.mock(ProviderRegistry.ProviderRegistry)({ + getProviders: Effect.succeed([provider]), + refreshInstance: () => Effect.succeed([provider]), + }), + Layer.mock(ProjectService.ProjectService)({}), + Layer.mock(SecretRequests.SecretRequests)({}), + Layer.mock(RemoteDelegation.RemoteDelegation)({}), + ServerSettings.layerTest(), + Layer.mock(ScheduledTaskService.ScheduledTaskService)({}), + NodeServices.layer, + NodeCrypto.layer, + ), + ), + ); + return { cwd, turns, layerTest }; +}); // Cancellation races with turn completion and checkpoint capture; "recorded" restarts before the Stop outbox runs. const cancelBackgroundOnlyTask = ( @@ -694,3 +823,240 @@ it.effect("a refused descendant stop does not settle or dispose its parent task" it.effect("task_cancel stops a remote descendant without reacquiring its parent lock", () => cancelBackgroundOnlyTask("command", { remote: true }), ); + +// The root Claude turn ends while a background native subagent it started still +// runs and delegates. +it.effect("a native background subagent delegates after its parent's run completes", () => + Effect.scoped( + Effect.gen(function* () { + const { cwd, turns, layerTest } = yield* makeHarness("native-subagent-delegates"); + + yield* Effect.gen(function* () { + const orchestrator = yield* Orchestrator.OrchestratorV2; + const worker = yield* EffectWorker.OrchestrationEffectWorkerV2; + const service = yield* OrchestratorMcpService.OrchestratorMcpService; + const parentThreadId = ThreadId.make("thread:native-delegate-parent"); + const watch = (predicate: (event: OrchestrationV2DomainEvent) => boolean) => + orchestrator.streamDomainEvents.pipe( + Stream.filter(predicate), + Stream.take(1), + Stream.runDrain, + Effect.forkScoped, + ); + const turnRunning = () => + watch( + (event) => event.type === "provider-turn.updated" && event.payload.status === "running", + ); + yield* orchestrator.dispatch({ + type: "thread.create", + commandId: CommandId.make("create-parent"), + threadId: parentThreadId, + projectId: ProjectId.make("project:native-delegate"), + title: "Parent", + modelSelection, + runtimeMode: "full-access", + interactionMode: "default", + branch: null, + worktreePath: cwd, + createdBy: "user", + creationSource: "web", + }); + const parentRunning = yield* turnRunning(); + yield* orchestrator.dispatch({ + type: "message.dispatch", + commandId: CommandId.make("start-parent"), + threadId: parentThreadId, + messageId: MessageId.make("message:start-parent"), + text: "Start a background agent", + attachments: [], + dispatchMode: { type: "start_immediately" }, + createdBy: "user", + creationSource: "web", + }); + yield* worker.drain(); + yield* Fiber.join(parentRunning); + const root = turns[0]!; + const parentRun = (yield* orchestrator.getThreadProjection(parentThreadId)).runs[0]!; + const rootTurn = (yield* orchestrator.getThreadProjection(parentThreadId)) + .providerTurns[0]!; + + const now = yield* DateTime.now; + const subagentId = NodeId.make("node:native-subagent"); + const native = { + threadId: parentThreadId, + runId: parentRun.id, + origin: "provider_native", + driver, + providerInstanceId: instanceId, + providerThreadId: rootTurn.providerThreadId, + childThreadId: null, + prompt: "Sleep, then delegate", + title: null, + status: "running", + result: null, + startedAt: now, + completedAt: null, + updatedAt: now, + } as const; + const waiting = yield* watch( + (event) => + event.type === "run.updated" && + event.payload.id === parentRun.id && + event.payload.status === "waiting", + ); + for (const event of [ + { + type: "node.updated", + driver, + node: { + id: subagentId, + threadId: parentThreadId, + runId: parentRun.id, + parentNodeId: root.turn.rootNodeId, + rootNodeId: root.turn.rootNodeId, + kind: "subagent", + status: "running", + countsForRun: false, + providerThreadId: rootTurn.providerThreadId, + providerTurnId: rootTurn.id, + nativeItemRef: null, + runtimeRequestId: null, + checkpointScopeId: null, + startedAt: now, + completedAt: null, + }, + }, + { + type: "subagent.updated", + driver, + subagent: { + ...native, + id: subagentId, + parentNodeId: root.turn.rootNodeId, + createdBy: "agent", + nativeTaskRef: null, + model: null, + }, + }, + { + type: "turn_item.updated", + driver, + turnItem: { + ...native, + id: TurnItemId.make("turn-item:native-subagent"), + nodeId: subagentId, + providerTurnId: rootTurn.id, + nativeItemRef: null, + parentItemId: null, + ordinal: 1, + type: "subagent", + subagentId, + }, + }, + { + type: "provider_turn.updated", + driver, + providerTurn: { ...rootTurn, status: "completed", completedAt: now }, + }, + { + type: "turn.terminal", + driver, + providerThreadId: rootTurn.providerThreadId, + providerTurnId: rootTurn.id, + runOrdinal: root.turn.runOrdinal, + status: "completed", + failure: null, + threadDisposition: "reusable", + }, + ] satisfies ReadonlyArray) { + yield* Queue.offer(root.events, event); + } + yield* Fiber.join(waiting); + yield* worker.drain(); + + const settled = yield* orchestrator.getThreadShell(parentThreadId); + assert.equal(settled?.activeRunId, null); + assert.equal( + (yield* orchestrator.getThreadProjection(parentThreadId)).runs[0]?.status, + "completed", + ); + assert.equal(settled?.pendingBackgroundTasks?.[0]?.kind, "subagent"); + + const scope: McpInvocationScope = { + environmentId: EnvironmentId.make("environment:native-delegate"), + requestNamespace: "provider-session:native-delegate", + thread: { + threadId: parentThreadId, + providerSessionId: "provider-session:native-delegate", + providerInstanceId: instanceId, + }, + client: undefined, + capabilities: new Set(["orchestration"]), + issuedAt: 1, + }; + const childRunning = yield* turnRunning(); + const delegated = yield* service.delegateTask(scope, { + task: "Reply with exactly OK.", + mode: "async", + clientRequestId: "delegate-from-native-subagent", + }); + assert.equal(delegated.status, "starting"); + yield* worker.drain(); + yield* Fiber.join(childRunning); + + const task = (yield* orchestrator.getThreadProjection(parentThreadId)).subagents.find( + (entry) => entry.origin === "app_owned", + )!; + assert.equal(task.runId, parentRun.id); + assert.equal(task.parentNodeId, parentRun.rootNodeId); + + // The settled run's cohort still claims the result to wake the parent. + const child = turns.find((entry) => entry.turn.threadId === task.childThreadId)!; + const childTurn = (yield* orchestrator.getThreadProjection(task.childThreadId!)) + .providerTurns[0]!; + const finished = yield* DateTime.now; + const childWaiting = yield* watch( + (event) => + event.type === "run.updated" && + event.threadId === task.childThreadId && + event.payload.status === "waiting", + ); + const taskCompleted = yield* watch( + (event) => + event.type === "subagent.updated" && + event.payload.id === task.id && + event.payload.status === "completed", + ); + for (const event of [ + { + type: "provider_turn.updated", + driver, + providerTurn: { ...childTurn, status: "completed", completedAt: finished }, + }, + { + type: "turn.terminal", + driver, + providerThreadId: childTurn.providerThreadId, + providerTurnId: childTurn.id, + runOrdinal: child.turn.runOrdinal, + status: "completed", + failure: null, + threadDisposition: "reusable", + }, + ] satisfies ReadonlyArray) { + yield* Queue.offer(child.events, event); + } + yield* Fiber.join(childWaiting); + yield* worker.drain(); + yield* Fiber.join(taskCompleted); + yield* worker.drain(); + const after = yield* orchestrator.getThreadProjection(parentThreadId); + assert.equal( + after.subagents.find((entry) => entry.id === task.id)?.completionDelivery?.state, + "claimed", + ); + assert.deepEqual(after.runs[0]?.delegatedCompletion?.delivery?.taskIds, [task.id]); + }).pipe(Effect.provide(layerTest)); + }), + ), +); diff --git a/apps/server/src/mcp/threadAccess.ts b/apps/server/src/mcp/threadAccess.ts index f387f481e24a6..d21495f0ff7c7 100644 --- a/apps/server/src/mcp/threadAccess.ts +++ b/apps/server/src/mcp/threadAccess.ts @@ -19,6 +19,7 @@ import { threadLinkCandidates, threadLinkRefs, } from "@t3tools/shared/threadLinks"; +import { hasPendingBackgroundSubagent } from "@t3tools/shared/orchestrationV2PendingBackgroundWork"; import * as SecureRandom from "effect/crypto/SecureRandom"; import * as Effect from "effect/Effect"; @@ -199,10 +200,7 @@ export const isLiveCallerShell = ( shell.archivedAt === null && shell.providerInstanceId === providerInstanceId && (shell.activeRunId !== null || - (shell.pendingBackgroundTasks?.some( - (task) => task.kind === "subagent" && task.providerInstanceId === providerInstanceId, - ) ?? - false)); + hasPendingBackgroundSubagent(shell.pendingBackgroundTasks, providerInstanceId)); /** Thread callers need a live run or its background subagent in an unarchived thread. OAuth clients rely on their session and ceiling. */ export function assertLiveCaller({ caller, scope }: Caller) { diff --git a/apps/server/src/orchestration-v2/Orchestrator.ts b/apps/server/src/orchestration-v2/Orchestrator.ts index a95481da7dfd6..d0d38cdc1ee2a 100644 --- a/apps/server/src/orchestration-v2/Orchestrator.ts +++ b/apps/server/src/orchestration-v2/Orchestrator.ts @@ -92,6 +92,7 @@ import { recordThreadOpen } from "@t3tools/shared/paletteSearch"; import { backgroundWorkHoldsCompletion, derivePendingBackgroundWork, + hasPendingBackgroundSubagent, pendingBackgroundTurnItems, } from "@t3tools/shared/orchestrationV2PendingBackgroundWork"; import * as Context from "effect/Context"; @@ -9481,6 +9482,22 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio yield* Ref.update(effects, (existing) => [...existing, pendingEffect]); }); + // A native background subagent keeps working, and delegating, after the latest run settles. + const backgroundSubagentOutlivesRun = (run: OrchestrationV2Run) => + projectionStore.getThreadShell(run.threadId).pipe( + Effect.map( + (shell) => + shell !== null && + shell.archivedAt === null && + shell.activeRunId === null && + shell.latestRunId === run.id && + hasPendingBackgroundSubagent(shell.pendingBackgroundTasks, run.providerInstanceId), + ), + Effect.mapError( + (cause) => new OrchestratorProjectionError({ threadId: run.threadId, cause }), + ), + ); + const dispatchDelegatedTaskRequest = Effect.fn("orchestrationV2.dispatch.delegatedTaskRequest")( function* ( command: Extract, @@ -9497,7 +9514,10 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio const parentRun = parentProjection.runs.find( (candidate) => candidate.id === command.parentRunId, ); - if (parentRun === undefined || !isActiveRun(parentRun)) { + if ( + parentRun === undefined || + !(isActiveRun(parentRun) || (yield* backgroundSubagentOutlivesRun(parentRun))) + ) { return yield* new OrchestratorDispatchError({ commandId: command.commandId, commandType: command.type, diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts index f834c7cc355b9..81be304c272bb 100644 --- a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts +++ b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts @@ -35,6 +35,7 @@ import { isTimelineMinimapTurnVisible, resolveAssistantMessageCopyState, type MessagesTimelineRow, + type TimelineLatestRun, workEntryDisplayLabel, } from "./MessagesTimeline.logic"; import { workEntryIconName } from "./TimelineWorkEntryRow.logic"; @@ -4816,7 +4817,16 @@ describe("live subagents after their parent turn settles", () => { prompt: `Inspect ${id}`, result: null, }); - const rowsFor = (children: ReadonlyArray) => + const rowsFor = ( + children: ReadonlyArray, + afterReply: ReadonlyArray = [], + latestRun: TimelineLatestRun = { + runId, + status: "completed", + startedAt: DateTime.formatIso(at(0)), + completedAt: DateTime.formatIso(at(8)), + }, + ) => deriveMessagesTimelineRows({ timelineEntries: deriveTimelineEntriesFromVisibleTurnItems({ visibleTurnItems: ( @@ -4856,16 +4866,12 @@ describe("live subagents after their parent turn settles", () => { text: "Both children are running.", streaming: false, }, + ...afterReply, ] satisfies OrchestrationV2TurnItem[] ).map(projected), optimisticMessages: [], }), - latestRun: { - runId, - status: "completed", - startedAt: DateTime.formatIso(at(0)), - completedAt: DateTime.formatIso(at(8)), - }, + latestRun, isWorking: false, turnDiffSummaries: [], supportsConversationRollback: false, @@ -4884,6 +4890,19 @@ describe("live subagents after their parent turn settles", () => { }, ); + it("keeps the turn's duration when a background child delegates after it settles", () => { + // The child's completion woke a later run, so this run's duration comes from its entries. + const rows = rowsFor([], [child("late", 50, "completed")], { + runId: RunId.make("wake-run"), + status: "completed", + startedAt: DateTime.formatIso(at(55)), + completedAt: DateTime.formatIso(at(58)), + }); + expect(rows.find((row) => row.kind === "turn-fold")).toMatchObject({ + label: "Worked for 8s", + }); + }); + it("keeps a launch batch visible while any member is still running", () => { const rows = rowsFor([child("done", 3, "completed"), child("live", 4, "running")]); expect(rows.map((row) => row.id)).toEqual(["user", `turn-fold:${runId}`, "done", "assistant"]); diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.ts b/apps/web/src/components/chat/MessagesTimeline.logic.ts index 8d282aff42689..3916f5dc336ea 100644 --- a/apps/web/src/components/chat/MessagesTimeline.logic.ts +++ b/apps/web/src/components/chat/MessagesTimeline.logic.ts @@ -1236,8 +1236,16 @@ function deriveTurnFolds(input: { const isLatestInterruptedTurn = input.latestRun?.runId === runId && input.latestRun.status === "interrupted"; // A turn cut short by a steer leaves trailing work entries behind its - // terminal message — take whichever ended last. - const lastEntryEnd = timelineEntryEnd(lastEntry); + // terminal message — take whichever ended last. A subagent card after it was + // spawned by background work once the turn settled, so it adds no turn time. + const lastTurnEntry = + group.entries.findLast( + (entry, index) => + index <= terminalEntryIndex || + entry.kind !== "event" || + entry.projectedItem.item.type !== "subagent", + ) ?? lastEntry; + const lastEntryEnd = timelineEntryEnd(lastTurnEntry); const elapsedMs = input.latestRun?.runId === runId && input.latestRun.startedAt && input.latestRun.completedAt ? computeElapsedMs(input.latestRun.startedAt, input.latestRun.completedAt) diff --git a/packages/shared/src/orchestrationV2PendingBackgroundWork.ts b/packages/shared/src/orchestrationV2PendingBackgroundWork.ts index 3b25db88acecd..8928d30cba0bb 100644 --- a/packages/shared/src/orchestrationV2PendingBackgroundWork.ts +++ b/packages/shared/src/orchestrationV2PendingBackgroundWork.ts @@ -87,6 +87,18 @@ export function deriveBlockedOnThreadWait(input: { return hasWait; } +/** A provider instance's background subagent outlives its run and still calls tools. */ +export function hasPendingBackgroundSubagent( + tasks: ReadonlyArray | undefined, + providerInstanceId: OrchestrationV2ProviderThread["providerInstanceId"] | undefined, +): boolean { + return ( + tasks?.some( + (task) => task.kind === "subagent" && task.providerInstanceId === providerInstanceId, + ) ?? false + ); +} + export function backgroundWorkHoldsCompletion( tasks: ReadonlyArray>, ): boolean { From 25bbf79d992351160698aa3bd58739ba54f2c83d Mon Sep 17 00:00:00 2001 From: Bil0000 <62337003+Bil0000@users.noreply.github.com> Date: Thu, 19 Nov 2026 04:51:32 +0100 Subject: [PATCH 2/4] fix(web): a late subagent card no longer stretches a steer's "Continued for" time Also read the event cursor before forking the watcher in the native background subagent test, so the watcher cannot miss an early event. --- ...skCancelNativeSubagent.integration.test.ts | 16 +++++++++----- .../chat/MessagesTimeline.logic.test.ts | 8 +++++++ .../components/chat/MessagesTimeline.logic.ts | 22 ++++++++++++------- 3 files changed, 33 insertions(+), 13 deletions(-) diff --git a/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts b/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts index a19808bb39673..c9dc3c16bb32c 100644 --- a/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts +++ b/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts @@ -835,13 +835,19 @@ it.effect("a native background subagent delegates after its parent's run complet const orchestrator = yield* Orchestrator.OrchestratorV2; const worker = yield* EffectWorker.OrchestrationEffectWorkerV2; const service = yield* OrchestratorMcpService.OrchestratorMcpService; + const eventSink = yield* EventSink.EventSinkV2; const parentThreadId = ThreadId.make("thread:native-delegate-parent"); const watch = (predicate: (event: OrchestrationV2DomainEvent) => boolean) => - orchestrator.streamDomainEvents.pipe( - Stream.filter(predicate), - Stream.take(1), - Stream.runDrain, - Effect.forkScoped, + eventSink.latestSequence().pipe( + Effect.flatMap((afterSequence) => + eventSink.stream({ afterSequence }).pipe( + Stream.map((stored) => stored.event), + Stream.filter(predicate), + Stream.take(1), + Stream.runDrain, + Effect.forkScoped, + ), + ), ); const turnRunning = () => watch( diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts index 81be304c272bb..5dfa187d779f1 100644 --- a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts +++ b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts @@ -1603,6 +1603,12 @@ describe("deriveMessagesTimelineRows", () => { message("steer", 10, "user", "steer"), work("work-after-steer", 15), message("final", 30, "assistant"), + { + kind: "event", + id: "late-subagent", + createdAt: time(50), + projectedItem: { item: { type: "subagent", status: "completed", runId } } as never, + }, ], latestRun: { runId, status: "completed", startedAt: time(0), completedAt: time(30) }, isWorking: false, @@ -1619,6 +1625,7 @@ describe("deriveMessagesTimelineRows", () => { "steer", `turn-fold:${segmentKey}`, "final", + "late-subagent", ]); expect(collapsed[1]).toMatchObject({ label: "Worked for 30s" }); expect(collapsed[3]).toMatchObject({ label: "Continued for 20s", createdAt: time(10) }); @@ -1630,6 +1637,7 @@ describe("deriveMessagesTimelineRows", () => { `turn-fold:${segmentKey}`, "work-after-steer", "final", + "late-subagent", ]); }); diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.ts b/apps/web/src/components/chat/MessagesTimeline.logic.ts index 3916f5dc336ea..5e3e26bf4f389 100644 --- a/apps/web/src/components/chat/MessagesTimeline.logic.ts +++ b/apps/web/src/components/chat/MessagesTimeline.logic.ts @@ -1238,13 +1238,17 @@ function deriveTurnFolds(input: { // A turn cut short by a steer leaves trailing work entries behind its // terminal message — take whichever ended last. A subagent card after it was // spawned by background work once the turn settled, so it adds no turn time. + const lateSubagentIds = new Set( + group.entries.flatMap((entry, index) => + index > terminalEntryIndex && + entry.kind === "event" && + entry.projectedItem.item.type === "subagent" + ? [entry.id] + : [], + ), + ); const lastTurnEntry = - group.entries.findLast( - (entry, index) => - index <= terminalEntryIndex || - entry.kind !== "event" || - entry.projectedItem.item.type !== "subagent", - ) ?? lastEntry; + group.entries.findLast((entry) => !lateSubagentIds.has(entry.id)) ?? lastEntry; const lastEntryEnd = timelineEntryEnd(lastTurnEntry); const elapsedMs = input.latestRun?.runId === runId && input.latestRun.startedAt && input.latestRun.completedAt @@ -1284,8 +1288,10 @@ function deriveTurnFolds(input: { if (anchorEntry === undefined || !hidesNonCompactionWork(entries)) continue; const segmentMs = computeElapsedMs( steer.createdAt, - entries.map(timelineEntryEnd).reduce(maxIsoTimestamp, null) ?? - steer.createdAt, + entries + .filter((entry) => !lateSubagentIds.has(entry.id)) + .map(timelineEntryEnd) + .reduce(maxIsoTimestamp, null) ?? steer.createdAt, ); foldsByAnchorEntryId.set(anchorEntry.id, { runId: RunId.make(`${runId}:steer:${steer.id}`), From 317d227fc4a9184a89145b28380db0ea281d4604 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Thu, 19 Nov 2026 05:03:38 +0000 Subject: [PATCH 3/4] test(server): share the fake Claude adapter across native subagent tests Co-Authored-By: Claude Opus 5.5 --- ...skCancelNativeSubagent.integration.test.ts | 97 +++---------------- 1 file changed, 13 insertions(+), 84 deletions(-) diff --git a/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts b/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts index c9dc3c16bb32c..2af173775a8e6 100644 --- a/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts +++ b/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts @@ -74,12 +74,12 @@ const provider: ServerProvider = { skills: [], }; -const makeHarness = Effect.fn(function* (name: string) { - const cwd = yield* checkpointWorkspace(name); +const makeFakeAdapter = (cwd: string) => { const turns: Array<{ readonly turn: ProviderAdapter.ProviderAdapterV2TurnInput; readonly events: Queue.Queue; }> = []; + const interrupted: Array | undefined> = []; const adapter: ProviderAdapter.ProviderAdapterV2["Service"] = { instanceId, driver, @@ -145,7 +145,10 @@ const makeHarness = Effect.fn(function* (name: string) { }); }), steerTurn: () => Effect.die("unused"), - interruptTurn: () => Effect.void, + interruptTurn: ({ providerThread }) => + Effect.sync(() => { + interrupted.push(providerThread.pendingBackgroundTasks?.map((t) => t.taskId)); + }), respondToRuntimeRequest: () => Effect.die("unused"), readThreadSnapshot: () => Effect.die("unused"), rollbackThread: () => Effect.die("unused"), @@ -153,6 +156,12 @@ const makeHarness = Effect.fn(function* (name: string) { }; }), }; + return { adapter, turns, interrupted }; +}; + +const makeHarness = Effect.fn(function* (name: string) { + const cwd = yield* checkpointWorkspace(name); + const { adapter, turns } = makeFakeAdapter(cwd); const layerAdapters = ProviderAdapterRegistry.layerSingle(adapter); const layerOrchestrator = ProviderReplayHarness.layerWithRegistry({ name }, layerAdapters, { runEffectWorker: false, @@ -201,87 +210,7 @@ const cancelBackgroundOnlyTask = ( Effect.scoped( Effect.gen(function* () { const cwd = yield* checkpointWorkspace(`task-cancel-background-${background}`); - const turns: Array<{ - readonly turn: ProviderAdapter.ProviderAdapterV2TurnInput; - readonly events: Queue.Queue; - }> = []; - const interrupted: Array | undefined> = []; - const adapter: ProviderAdapter.ProviderAdapterV2["Service"] = { - instanceId, - driver, - getCapabilities: () => Effect.succeed(ClaudeProviderCapabilitiesV2), - planSelectionTransition: () => Effect.succeed({ type: "apply_on_next_turn" }), - openSession: (input) => - Effect.gen(function* () { - const now = yield* DateTime.now; - const events = yield* Queue.unbounded(); - return { - instanceId, - driver, - providerSessionId: input.providerSessionId, - providerSession: { - id: input.providerSessionId, - driver, - providerInstanceId: instanceId, - status: "ready", - cwd, - model: modelSelection.model, - capabilities: ClaudeProviderCapabilitiesV2, - createdAt: now, - updatedAt: now, - lastError: null, - }, - events: Stream.fromQueue(events), - ensureThread: ({ threadId }) => - Effect.succeed({ - id: ProviderThreadId.make(`provider-thread:${threadId}`), - driver, - providerInstanceId: instanceId, - providerSessionId: input.providerSessionId, - appThreadId: threadId, - ownerNodeId: null, - nativeThreadRef: { driver, nativeId: `native:${threadId}`, strength: "strong" }, - nativeConversationHeadRef: null, - status: "idle", - firstRunOrdinal: null, - lastRunOrdinal: null, - handoffIds: [], - forkedFrom: null, - createdAt: now, - updatedAt: now, - }), - resumeThread: ({ providerThread }) => Effect.succeed(providerThread), - startTurn: (turn) => - Effect.gen(function* () { - turns.push({ turn, events }); - yield* Queue.offer(events, { - type: "provider_turn.updated", - driver, - providerTurn: { - id: ProviderTurnId.make(`provider-turn:${turn.attemptId}`), - providerThreadId: turn.providerThread.id, - nodeId: turn.rootNodeId, - runAttemptId: turn.attemptId, - nativeTurnRef: null, - ordinal: turn.providerTurnOrdinal, - status: "running", - startedAt: now, - completedAt: null, - }, - }); - }), - steerTurn: () => Effect.die("unused"), - interruptTurn: ({ providerThread }) => - Effect.sync(() => { - interrupted.push(providerThread.pendingBackgroundTasks?.map((t) => t.taskId)); - }), - respondToRuntimeRequest: () => Effect.die("unused"), - readThreadSnapshot: () => Effect.die("unused"), - rollbackThread: () => Effect.die("unused"), - forkThread: () => Effect.die("unused"), - }; - }), - }; + const { adapter, turns, interrupted } = makeFakeAdapter(cwd); const layerAdapters = ProviderAdapterRegistry.layerSingle(adapter); const fs = yield* FileSystem.FileSystem; const path = yield* Path.Path; From d7106920d5e197172065120645d844b1eb2d73b1 Mon Sep 17 00:00:00 2001 From: Bil0000 <62337003+Bil0000@users.noreply.github.com> Date: Thu, 19 Nov 2026 14:31:36 +0100 Subject: [PATCH 4/4] test: cover late delegation and late subagent timing inside existing cases The native background subagent delegation runs as one more case of the task-cancel harness, which already settles a turn while a native subagent runs. The timeline fold timing is covered by the existing steer test with a later wake run. This drops the separate fake adapter and the duplicate setup. --- ...skCancelNativeSubagent.integration.test.ts | 480 ++++-------------- .../chat/MessagesTimeline.logic.test.ts | 41 +- 2 files changed, 120 insertions(+), 401 deletions(-) diff --git a/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts b/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts index 2af173775a8e6..aff11dacad26e 100644 --- a/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts +++ b/apps/server/src/mcp/TaskCancelNativeSubagent.integration.test.ts @@ -58,143 +58,15 @@ const layerOrchestratorService = OrchestratorMcpService.layer.pipe( const driver = ProviderDriverKind.make("claudeAgent"); const instanceId = ProviderInstanceId.make("claudeAgent"); const modelSelection = { instanceId, model: "claude-test" }; -const provider: ServerProvider = { +const provider = { instanceId, driver, enabled: true, installed: true, - version: "test", status: "ready", auth: { status: "authenticated" }, - checkedAt: "2026-10-22T00:00:00.000Z", - models: [ - { slug: modelSelection.model, name: modelSelection.model, isCustom: false, capabilities: null }, - ], - slashCommands: [], - skills: [], -}; - -const makeFakeAdapter = (cwd: string) => { - const turns: Array<{ - readonly turn: ProviderAdapter.ProviderAdapterV2TurnInput; - readonly events: Queue.Queue; - }> = []; - const interrupted: Array | undefined> = []; - const adapter: ProviderAdapter.ProviderAdapterV2["Service"] = { - instanceId, - driver, - getCapabilities: () => Effect.succeed(ClaudeProviderCapabilitiesV2), - planSelectionTransition: () => Effect.succeed({ type: "apply_on_next_turn" }), - openSession: (input) => - Effect.gen(function* () { - const now = yield* DateTime.now; - const events = yield* Queue.unbounded(); - return { - instanceId, - driver, - providerSessionId: input.providerSessionId, - providerSession: { - id: input.providerSessionId, - driver, - providerInstanceId: instanceId, - status: "ready", - cwd, - model: modelSelection.model, - capabilities: ClaudeProviderCapabilitiesV2, - createdAt: now, - updatedAt: now, - lastError: null, - }, - events: Stream.fromQueue(events), - ensureThread: ({ threadId }) => - Effect.succeed({ - id: ProviderThreadId.make(`provider-thread:${threadId}`), - driver, - providerInstanceId: instanceId, - providerSessionId: input.providerSessionId, - appThreadId: threadId, - ownerNodeId: null, - nativeThreadRef: { driver, nativeId: `native:${threadId}`, strength: "strong" }, - nativeConversationHeadRef: null, - status: "idle", - firstRunOrdinal: null, - lastRunOrdinal: null, - handoffIds: [], - forkedFrom: null, - createdAt: now, - updatedAt: now, - }), - resumeThread: ({ providerThread }) => Effect.succeed(providerThread), - startTurn: (turn) => - Effect.gen(function* () { - turns.push({ turn, events }); - yield* Queue.offer(events, { - type: "provider_turn.updated", - driver, - providerTurn: { - id: ProviderTurnId.make(`provider-turn:${turn.attemptId}`), - providerThreadId: turn.providerThread.id, - nodeId: turn.rootNodeId, - runAttemptId: turn.attemptId, - nativeTurnRef: null, - ordinal: turn.providerTurnOrdinal, - status: "running", - startedAt: now, - completedAt: null, - }, - }); - }), - steerTurn: () => Effect.die("unused"), - interruptTurn: ({ providerThread }) => - Effect.sync(() => { - interrupted.push(providerThread.pendingBackgroundTasks?.map((t) => t.taskId)); - }), - respondToRuntimeRequest: () => Effect.die("unused"), - readThreadSnapshot: () => Effect.die("unused"), - rollbackThread: () => Effect.die("unused"), - forkThread: () => Effect.die("unused"), - }; - }), - }; - return { adapter, turns, interrupted }; -}; - -const makeHarness = Effect.fn(function* (name: string) { - const cwd = yield* checkpointWorkspace(name); - const { adapter, turns } = makeFakeAdapter(cwd); - const layerAdapters = ProviderAdapterRegistry.layerSingle(adapter); - const layerOrchestrator = ProviderReplayHarness.layerWithRegistry({ name }, layerAdapters, { - runEffectWorker: false, - }); - const layerOrchestration = Layer.merge( - layerOrchestrator, - ThreadManagementService.layer.pipe( - Layer.provide(layerOrchestrator), - Layer.provide(ServerSettings.layerTest()), - Layer.provide(CommandReceiptStore.layer.pipe(Layer.provide(SqlitePersistence.layerMemory))), - ), - ); - const layerTest = layerOrchestratorService.pipe( - Layer.provideMerge(layerOrchestration), - Layer.provide( - Layer.mergeAll( - layerAdapters, - Layer.mock(ProviderRegistry.ProviderRegistry)({ - getProviders: Effect.succeed([provider]), - refreshInstance: () => Effect.succeed([provider]), - }), - Layer.mock(ProjectService.ProjectService)({}), - Layer.mock(SecretRequests.SecretRequests)({}), - Layer.mock(RemoteDelegation.RemoteDelegation)({}), - ServerSettings.layerTest(), - Layer.mock(ScheduledTaskService.ScheduledTaskService)({}), - NodeServices.layer, - NodeCrypto.layer, - ), - ), - ); - return { cwd, turns, layerTest }; -}); + models: [{ slug: modelSelection.model, name: modelSelection.model, isCustom: false }], +} as unknown as ServerProvider; // Cancellation races with turn completion and checkpoint capture; "recorded" restarts before the Stop outbox runs. const cancelBackgroundOnlyTask = ( @@ -204,13 +76,100 @@ const cancelBackgroundOnlyTask = ( remote = false, }: { readonly remote?: boolean; - readonly cancelAt?: "settled" | "checkpoint" | "turn" | "recorded" | "monitor" | "refused"; + readonly cancelAt?: + | "settled" + | "checkpoint" + | "turn" + | "recorded" + | "monitor" + | "refused" + | "delegate"; } = {}, ) => Effect.scoped( Effect.gen(function* () { const cwd = yield* checkpointWorkspace(`task-cancel-background-${background}`); - const { adapter, turns, interrupted } = makeFakeAdapter(cwd); + const turns: Array<{ + readonly turn: ProviderAdapter.ProviderAdapterV2TurnInput; + readonly events: Queue.Queue; + }> = []; + const interrupted: Array | undefined> = []; + const adapter: ProviderAdapter.ProviderAdapterV2["Service"] = { + instanceId, + driver, + getCapabilities: () => Effect.succeed(ClaudeProviderCapabilitiesV2), + planSelectionTransition: () => Effect.succeed({ type: "apply_on_next_turn" }), + openSession: (input) => + Effect.gen(function* () { + const now = yield* DateTime.now; + const events = yield* Queue.unbounded(); + return { + instanceId, + driver, + providerSessionId: input.providerSessionId, + providerSession: { + id: input.providerSessionId, + driver, + providerInstanceId: instanceId, + status: "ready", + cwd, + model: modelSelection.model, + capabilities: ClaudeProviderCapabilitiesV2, + createdAt: now, + updatedAt: now, + lastError: null, + }, + events: Stream.fromQueue(events), + ensureThread: ({ threadId }) => + Effect.succeed({ + id: ProviderThreadId.make(`provider-thread:${threadId}`), + driver, + providerInstanceId: instanceId, + providerSessionId: input.providerSessionId, + appThreadId: threadId, + ownerNodeId: null, + nativeThreadRef: { driver, nativeId: `native:${threadId}`, strength: "strong" }, + nativeConversationHeadRef: null, + status: "idle", + firstRunOrdinal: null, + lastRunOrdinal: null, + handoffIds: [], + forkedFrom: null, + createdAt: now, + updatedAt: now, + }), + resumeThread: ({ providerThread }) => Effect.succeed(providerThread), + startTurn: (turn) => + Effect.gen(function* () { + turns.push({ turn, events }); + yield* Queue.offer(events, { + type: "provider_turn.updated", + driver, + providerTurn: { + id: ProviderTurnId.make(`provider-turn:${turn.attemptId}`), + providerThreadId: turn.providerThread.id, + nodeId: turn.rootNodeId, + runAttemptId: turn.attemptId, + nativeTurnRef: null, + ordinal: turn.providerTurnOrdinal, + status: "running", + startedAt: now, + completedAt: null, + }, + }); + }), + steerTurn: () => Effect.die("unused"), + interruptTurn: ({ providerThread }) => + Effect.sync(() => { + interrupted.push(providerThread.pendingBackgroundTasks?.map((t) => t.taskId)); + }), + respondToRuntimeRequest: () => Effect.die("unused"), + readThreadSnapshot: () => Effect.die("unused"), + rollbackThread: () => Effect.die("unused"), + forkThread: () => Effect.die("unused"), + }; + }), + }; const layerAdapters = ProviderAdapterRegistry.layerSingle(adapter); const fs = yield* FileSystem.FileSystem; const path = yield* Path.Path; @@ -272,7 +231,9 @@ const cancelBackgroundOnlyTask = ( Layer.provide( Layer.mergeAll( layerAdapters, - Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }), + Layer.mock(ProviderRegistry.ProviderRegistry)({ + getProviders: Effect.succeed([provider]), + }), Layer.mock(ProjectService.ProjectService)({}), Layer.mock(SecretRequests.SecretRequests)({}), Layer.mock(RemoteDelegation.RemoteDelegation)({}), @@ -587,6 +548,16 @@ const cancelBackgroundOnlyTask = ( capabilities: new Set(["orchestration"]), issuedAt: 1, }; + if (cancelAt === "delegate") { + // The child's run settled while its native subagent still runs, and that subagent delegates. + const childScope: McpInvocationScope = { + ...scope, + thread: { ...scope.thread!, threadId: task.childThreadId! }, + }; + const delegated = yield* service.delegateTask(childScope, { task: "Reply OK." }); + assert.equal(delegated.status, "starting"); + return undefined; + } const before = yield* service.taskStatus(scope, task.id); assert.equal(before.status, "running"); assert.equal(before.workState, turnSettled ? "waiting_for_children" : "working"); @@ -753,245 +724,6 @@ it.effect("task_cancel stops a remote descendant without reacquiring its parent cancelBackgroundOnlyTask("command", { remote: true }), ); -// The root Claude turn ends while a background native subagent it started still -// runs and delegates. it.effect("a native background subagent delegates after its parent's run completes", () => - Effect.scoped( - Effect.gen(function* () { - const { cwd, turns, layerTest } = yield* makeHarness("native-subagent-delegates"); - - yield* Effect.gen(function* () { - const orchestrator = yield* Orchestrator.OrchestratorV2; - const worker = yield* EffectWorker.OrchestrationEffectWorkerV2; - const service = yield* OrchestratorMcpService.OrchestratorMcpService; - const eventSink = yield* EventSink.EventSinkV2; - const parentThreadId = ThreadId.make("thread:native-delegate-parent"); - const watch = (predicate: (event: OrchestrationV2DomainEvent) => boolean) => - eventSink.latestSequence().pipe( - Effect.flatMap((afterSequence) => - eventSink.stream({ afterSequence }).pipe( - Stream.map((stored) => stored.event), - Stream.filter(predicate), - Stream.take(1), - Stream.runDrain, - Effect.forkScoped, - ), - ), - ); - const turnRunning = () => - watch( - (event) => event.type === "provider-turn.updated" && event.payload.status === "running", - ); - yield* orchestrator.dispatch({ - type: "thread.create", - commandId: CommandId.make("create-parent"), - threadId: parentThreadId, - projectId: ProjectId.make("project:native-delegate"), - title: "Parent", - modelSelection, - runtimeMode: "full-access", - interactionMode: "default", - branch: null, - worktreePath: cwd, - createdBy: "user", - creationSource: "web", - }); - const parentRunning = yield* turnRunning(); - yield* orchestrator.dispatch({ - type: "message.dispatch", - commandId: CommandId.make("start-parent"), - threadId: parentThreadId, - messageId: MessageId.make("message:start-parent"), - text: "Start a background agent", - attachments: [], - dispatchMode: { type: "start_immediately" }, - createdBy: "user", - creationSource: "web", - }); - yield* worker.drain(); - yield* Fiber.join(parentRunning); - const root = turns[0]!; - const parentRun = (yield* orchestrator.getThreadProjection(parentThreadId)).runs[0]!; - const rootTurn = (yield* orchestrator.getThreadProjection(parentThreadId)) - .providerTurns[0]!; - - const now = yield* DateTime.now; - const subagentId = NodeId.make("node:native-subagent"); - const native = { - threadId: parentThreadId, - runId: parentRun.id, - origin: "provider_native", - driver, - providerInstanceId: instanceId, - providerThreadId: rootTurn.providerThreadId, - childThreadId: null, - prompt: "Sleep, then delegate", - title: null, - status: "running", - result: null, - startedAt: now, - completedAt: null, - updatedAt: now, - } as const; - const waiting = yield* watch( - (event) => - event.type === "run.updated" && - event.payload.id === parentRun.id && - event.payload.status === "waiting", - ); - for (const event of [ - { - type: "node.updated", - driver, - node: { - id: subagentId, - threadId: parentThreadId, - runId: parentRun.id, - parentNodeId: root.turn.rootNodeId, - rootNodeId: root.turn.rootNodeId, - kind: "subagent", - status: "running", - countsForRun: false, - providerThreadId: rootTurn.providerThreadId, - providerTurnId: rootTurn.id, - nativeItemRef: null, - runtimeRequestId: null, - checkpointScopeId: null, - startedAt: now, - completedAt: null, - }, - }, - { - type: "subagent.updated", - driver, - subagent: { - ...native, - id: subagentId, - parentNodeId: root.turn.rootNodeId, - createdBy: "agent", - nativeTaskRef: null, - model: null, - }, - }, - { - type: "turn_item.updated", - driver, - turnItem: { - ...native, - id: TurnItemId.make("turn-item:native-subagent"), - nodeId: subagentId, - providerTurnId: rootTurn.id, - nativeItemRef: null, - parentItemId: null, - ordinal: 1, - type: "subagent", - subagentId, - }, - }, - { - type: "provider_turn.updated", - driver, - providerTurn: { ...rootTurn, status: "completed", completedAt: now }, - }, - { - type: "turn.terminal", - driver, - providerThreadId: rootTurn.providerThreadId, - providerTurnId: rootTurn.id, - runOrdinal: root.turn.runOrdinal, - status: "completed", - failure: null, - threadDisposition: "reusable", - }, - ] satisfies ReadonlyArray) { - yield* Queue.offer(root.events, event); - } - yield* Fiber.join(waiting); - yield* worker.drain(); - - const settled = yield* orchestrator.getThreadShell(parentThreadId); - assert.equal(settled?.activeRunId, null); - assert.equal( - (yield* orchestrator.getThreadProjection(parentThreadId)).runs[0]?.status, - "completed", - ); - assert.equal(settled?.pendingBackgroundTasks?.[0]?.kind, "subagent"); - - const scope: McpInvocationScope = { - environmentId: EnvironmentId.make("environment:native-delegate"), - requestNamespace: "provider-session:native-delegate", - thread: { - threadId: parentThreadId, - providerSessionId: "provider-session:native-delegate", - providerInstanceId: instanceId, - }, - client: undefined, - capabilities: new Set(["orchestration"]), - issuedAt: 1, - }; - const childRunning = yield* turnRunning(); - const delegated = yield* service.delegateTask(scope, { - task: "Reply with exactly OK.", - mode: "async", - clientRequestId: "delegate-from-native-subagent", - }); - assert.equal(delegated.status, "starting"); - yield* worker.drain(); - yield* Fiber.join(childRunning); - - const task = (yield* orchestrator.getThreadProjection(parentThreadId)).subagents.find( - (entry) => entry.origin === "app_owned", - )!; - assert.equal(task.runId, parentRun.id); - assert.equal(task.parentNodeId, parentRun.rootNodeId); - - // The settled run's cohort still claims the result to wake the parent. - const child = turns.find((entry) => entry.turn.threadId === task.childThreadId)!; - const childTurn = (yield* orchestrator.getThreadProjection(task.childThreadId!)) - .providerTurns[0]!; - const finished = yield* DateTime.now; - const childWaiting = yield* watch( - (event) => - event.type === "run.updated" && - event.threadId === task.childThreadId && - event.payload.status === "waiting", - ); - const taskCompleted = yield* watch( - (event) => - event.type === "subagent.updated" && - event.payload.id === task.id && - event.payload.status === "completed", - ); - for (const event of [ - { - type: "provider_turn.updated", - driver, - providerTurn: { ...childTurn, status: "completed", completedAt: finished }, - }, - { - type: "turn.terminal", - driver, - providerThreadId: childTurn.providerThreadId, - providerTurnId: childTurn.id, - runOrdinal: child.turn.runOrdinal, - status: "completed", - failure: null, - threadDisposition: "reusable", - }, - ] satisfies ReadonlyArray) { - yield* Queue.offer(child.events, event); - } - yield* Fiber.join(childWaiting); - yield* worker.drain(); - yield* Fiber.join(taskCompleted); - yield* worker.drain(); - const after = yield* orchestrator.getThreadProjection(parentThreadId); - assert.equal( - after.subagents.find((entry) => entry.id === task.id)?.completionDelivery?.state, - "claimed", - ); - assert.deepEqual(after.runs[0]?.delegatedCompletion?.delivery?.taskIds, [task.id]); - }).pipe(Effect.provide(layerTest)); - }), - ), + cancelBackgroundOnlyTask("subagent", { cancelAt: "delegate" }), ); diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts index 5dfa187d779f1..d83fdc92f111b 100644 --- a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts +++ b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts @@ -35,7 +35,6 @@ import { isTimelineMinimapTurnVisible, resolveAssistantMessageCopyState, type MessagesTimelineRow, - type TimelineLatestRun, workEntryDisplayLabel, } from "./MessagesTimeline.logic"; import { workEntryIconName } from "./TimelineWorkEntryRow.logic"; @@ -1610,7 +1609,13 @@ describe("deriveMessagesTimelineRows", () => { projectedItem: { item: { type: "subagent", status: "completed", runId } } as never, }, ], - latestRun: { runId, status: "completed", startedAt: time(0), completedAt: time(30) }, + // A later wake run is the latest, so this turn's times come from its entries. + latestRun: { + runId: RunId.make("wake-run"), + status: "completed", + startedAt: time(55), + completedAt: time(58), + }, isWorking: false, expandedRunIds, turnDiffSummaries: [], @@ -4825,16 +4830,7 @@ describe("live subagents after their parent turn settles", () => { prompt: `Inspect ${id}`, result: null, }); - const rowsFor = ( - children: ReadonlyArray, - afterReply: ReadonlyArray = [], - latestRun: TimelineLatestRun = { - runId, - status: "completed", - startedAt: DateTime.formatIso(at(0)), - completedAt: DateTime.formatIso(at(8)), - }, - ) => + const rowsFor = (children: ReadonlyArray) => deriveMessagesTimelineRows({ timelineEntries: deriveTimelineEntriesFromVisibleTurnItems({ visibleTurnItems: ( @@ -4874,12 +4870,16 @@ describe("live subagents after their parent turn settles", () => { text: "Both children are running.", streaming: false, }, - ...afterReply, ] satisfies OrchestrationV2TurnItem[] ).map(projected), optimisticMessages: [], }), - latestRun, + latestRun: { + runId, + status: "completed", + startedAt: DateTime.formatIso(at(0)), + completedAt: DateTime.formatIso(at(8)), + }, isWorking: false, turnDiffSummaries: [], supportsConversationRollback: false, @@ -4898,19 +4898,6 @@ describe("live subagents after their parent turn settles", () => { }, ); - it("keeps the turn's duration when a background child delegates after it settles", () => { - // The child's completion woke a later run, so this run's duration comes from its entries. - const rows = rowsFor([], [child("late", 50, "completed")], { - runId: RunId.make("wake-run"), - status: "completed", - startedAt: DateTime.formatIso(at(55)), - completedAt: DateTime.formatIso(at(58)), - }); - expect(rows.find((row) => row.kind === "turn-fold")).toMatchObject({ - label: "Worked for 8s", - }); - }); - it("keeps a launch batch visible while any member is still running", () => { const rows = rowsFor([child("done", 3, "completed"), child("live", 4, "running")]); expect(rows.map((row) => row.id)).toEqual(["user", `turn-fold:${runId}`, "done", "assistant"]);