@@ -9571,6 +9571,210 @@ describe("ClaudeAdapterV2 background wake turns", () => {
95719571 ),
95729572 );
95739573
9574+ const startSubagentWakeWithoutWakeTurn = (
9575+ options?: Parameters<typeof makeWakeHarnessWithOptions>[0],
9576+ bufferedFrames: ReadonlyArray<SDKMessage> = [],
9577+ ) =>
9578+ Effect.gen(function* () {
9579+ const TASK_ID = "task-wake-never-opened";
9580+ const TOOL_USE_ID = "toolu-wake-never-opened";
9581+ const harness = yield* makeWakeHarnessWithOptions(options);
9582+ const now = yield* DateTime.now;
9583+ yield* harness.runtime.startTurn(
9584+ makeClaudeTestTurnInput({
9585+ threadId: harness.threadId,
9586+ providerThread: harness.providerThread,
9587+ now,
9588+ attemptId: RunAttemptId.make("attempt-claude-wake-never-opened-1"),
9589+ text: "Audit in the background.",
9590+ attachments: [],
9591+ }),
9592+ );
9593+ for (const frame of [
9594+ makeSubagentTaskStartedFrame({
9595+ taskId: TASK_ID,
9596+ toolUseId: TOOL_USE_ID,
9597+ uuid: "00000000-0000-4000-8000-000000000981",
9598+ }),
9599+ makeResultFrame({
9600+ uuid: "00000000-0000-4000-8000-000000000982",
9601+ result: "Auditing in the background.",
9602+ }),
9603+ ]) {
9604+ yield* harness.offerAndWait(frame);
9605+ }
9606+ assert.equal((yield* Queue.take(harness.terminalReceipts)).status, "completed");
9607+ yield* harness.offerAndWait(
9608+ makeSubagentNotificationFrame({
9609+ taskId: TASK_ID,
9610+ toolUseId: TOOL_USE_ID,
9611+ summary: "Audit done.",
9612+ uuid: "00000000-0000-4000-8000-000000000983",
9613+ }),
9614+ );
9615+ yield* Queue.take(harness.continuationReceipts);
9616+ for (const frame of bufferedFrames) {
9617+ yield* harness.offerAndWait(frame);
9618+ }
9619+ yield* harness.runtime.startTurn(
9620+ makeClaudeTestTurnInput({
9621+ threadId: harness.threadId,
9622+ providerThread: harness.providerThread,
9623+ now,
9624+ attemptId: RunAttemptId.make("attempt-claude-wake-never-opened-2"),
9625+ text: "Background task completed.",
9626+ attachments: [],
9627+ providerTurnOrdinal: 2,
9628+ messageCreatedBy: "agent",
9629+ messageCreationSource: "provider",
9630+ }),
9631+ );
9632+ assert.lengthOf(harness.terminalEvents(), 1);
9633+ return harness;
9634+ });
9635+
9636+ it.effect("settles a subagent wake run although a subagent reports progress meanwhile", () =>
9637+ Effect.scoped(
9638+ Effect.gen(function* () {
9639+ const harness = yield* startSubagentWakeWithoutWakeTurn();
9640+
9641+ yield* TestClock.adjust("1 minute");
9642+ assert.lengthOf(harness.terminalEvents(), 1);
9643+ yield* harness.offerAndWait(
9644+ claudeSdkFrame({
9645+ type: "system",
9646+ subtype: "task_progress",
9647+ task_id: "task-still-running-elsewhere",
9648+ description: "Reading more files",
9649+ uuid: "00000000-0000-4000-8000-000000000984",
9650+ session_id: WAKE_NATIVE_SESSION,
9651+ }),
9652+ );
9653+ yield* TestClock.adjust("1 minute");
9654+ assert.lengthOf(harness.terminalEvents(), 2);
9655+ assert.equal((yield* Queue.take(harness.terminalReceipts)).status, "completed");
9656+ assert.lengthOf(harness.offeredMessages, 1);
9657+ }).pipe(
9658+ Effect.provide(
9659+ Layer.mergeAll(IdAllocator.layer, McpProviderSessions.layer, NodeServices.layer),
9660+ ),
9661+ ),
9662+ ),
9663+ );
9664+
9665+ it.effect("settles a subagent wake run with only subagent messages buffered", () =>
9666+ Effect.scoped(
9667+ Effect.gen(function* () {
9668+ const harness = yield* startSubagentWakeWithoutWakeTurn(undefined, [
9669+ ...makeSubagentAssistantFrames({
9670+ parentToolUseId: "toolu-wake-never-opened",
9671+ text: "Audit done.",
9672+ uuid: "00000000-0000-4000-8000-000000000985",
9673+ }),
9674+ makeSubagentToolResultFrame({
9675+ parentToolUseId: "toolu-wake-never-opened",
9676+ toolUseId: "toolu-wake-child-bash",
9677+ uuid: "00000000-0000-4000-8000-000000000986",
9678+ }),
9679+ ]);
9680+
9681+ yield* TestClock.adjust("2 minutes");
9682+ assert.lengthOf(harness.terminalEvents(), 2);
9683+ assert.equal((yield* Queue.take(harness.terminalReceipts)).status, "completed");
9684+ }).pipe(
9685+ Effect.provide(
9686+ Layer.mergeAll(IdAllocator.layer, McpProviderSessions.layer, NodeServices.layer),
9687+ ),
9688+ ),
9689+ ),
9690+ );
9691+
9692+ it.effect("keeps a subagent wake run open while Claude works on the wake turn", () =>
9693+ Effect.scoped(
9694+ Effect.gen(function* () {
9695+ const harness = yield* startSubagentWakeWithoutWakeTurn();
9696+
9697+ yield* harness.offerAndWait(wakeTurnInit);
9698+ yield* TestClock.adjust("2 minutes");
9699+ assert.lengthOf(harness.terminalEvents(), 1);
9700+
9701+ yield* harness.offerAndWait(wakeResult);
9702+ assert.equal((yield* Queue.take(harness.terminalReceipts)).status, "completed");
9703+ }).pipe(
9704+ Effect.provide(
9705+ Layer.mergeAll(IdAllocator.layer, McpProviderSessions.layer, NodeServices.layer),
9706+ ),
9707+ ),
9708+ ),
9709+ );
9710+
9711+ it.effect("keeps a subagent wake run open when root output starts streaming", () =>
9712+ Effect.scoped(
9713+ Effect.gen(function* () {
9714+ const harness = yield* startSubagentWakeWithoutWakeTurn();
9715+ yield* harness.offerAndWait(
9716+ claudeSdkFrame({
9717+ type: "stream_event",
9718+ event: {
9719+ type: "content_block_delta",
9720+ index: 0,
9721+ delta: { type: "text_delta", text: "Working" },
9722+ },
9723+ parent_tool_use_id: null,
9724+ uuid: "00000000-0000-4000-8000-000000000987",
9725+ session_id: WAKE_NATIVE_SESSION,
9726+ }),
9727+ );
9728+
9729+ yield* TestClock.adjust("2 minutes");
9730+ assert.lengthOf(harness.terminalEvents(), 1);
9731+ yield* harness.offerAndWait(wakeResult);
9732+ assert.equal((yield* Queue.take(harness.terminalReceipts)).status, "completed");
9733+ }).pipe(
9734+ Effect.provide(
9735+ Layer.mergeAll(IdAllocator.layer, McpProviderSessions.layer, NodeServices.layer),
9736+ ),
9737+ ),
9738+ ),
9739+ );
9740+
9741+ it.effect("does not complete a subagent wake run while Stop is pending", () =>
9742+ Effect.scoped(
9743+ Effect.gen(function* () {
9744+ const stopRequested = yield* Deferred.make<void>();
9745+ const releaseStop = yield* Deferred.make<void>();
9746+ const harness = yield* startSubagentWakeWithoutWakeTurn({
9747+ interrupt: Deferred.succeed(stopRequested, undefined).pipe(
9748+ Effect.andThen(Deferred.await(releaseStop)),
9749+ ),
9750+ close: Queue.shutdown,
9751+ });
9752+ const stop = yield* harness.runtime
9753+ .interruptTurn({
9754+ providerThread: harness.providerThread,
9755+ providerTurnId: (yield* IdAllocator.IdAllocatorV2).derive.providerTurn({
9756+ driver: ClaudeAdapterV2.CLAUDE_PROVIDER,
9757+ nativeTurnId: "turn:attempt-claude-wake-never-opened-2",
9758+ }),
9759+ })
9760+ .pipe(Effect.forkScoped);
9761+ yield* Deferred.await(stopRequested);
9762+
9763+ yield* TestClock.adjust("2 minutes");
9764+ assert.lengthOf(harness.terminalEvents(), 1);
9765+
9766+ yield* Deferred.succeed(releaseStop, undefined);
9767+ yield* Fiber.join(stop);
9768+ assert.equal((yield* Queue.take(harness.terminalReceipts)).status, "interrupted");
9769+ assert.lengthOf(harness.terminalEvents(), 2);
9770+ }).pipe(
9771+ Effect.provide(
9772+ Layer.mergeAll(IdAllocator.layer, McpProviderSessions.layer, NodeServices.layer),
9773+ ),
9774+ ),
9775+ ),
9776+ );
9777+
95749778 it.effect("keeps a nested subagent's launch in order while the root turn is idle", () =>
95759779 Effect.scoped(
95769780 Effect.gen(function* () {
0 commit comments