diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts index faddf5fa837b2..eb89eb8bf57a7 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts @@ -17074,7 +17074,7 @@ describe("ClaudeAdapterV2 background wake turns", () => { ), ); - it.effect.each(["none", "before", "after", "sibling"] as const)( + it.effect.each(["none", "before", "after", "sibling", "never opens", "active wake"] as const)( "keeps an exited background command on the roster until its wake run starts (empty level %s notification)", (emptyLevel) => Effect.gen(function* () { @@ -17125,6 +17125,15 @@ describe("ClaudeAdapterV2 background wake turns", () => { yield* harness.offerAndWait(emptyRoster); yield* harness.offerAndWait(wakeNotification); if (emptyLevel === "after") yield* harness.offerAndWait(emptyRoster); + if (emptyLevel === "never opens") { + yield* TestClock.adjust("2 minutes"); + assert.deepEqual( + providerThreadRosterEvents(harness.events).at(-1)?.providerThread + .pendingBackgroundTasks, + [], + ); + return; + } // Query replacement reads the internal roster, which the exit already cleared. assert.isFalse(yield* harness.hasPendingBackgroundWork); yield* harness.offerAndWait(wakeTurnInit); @@ -17142,8 +17151,18 @@ describe("ClaudeAdapterV2 background wake turns", () => { }), ); yield* harness.offerAndWait(wakeAssistant); + if (emptyLevel === "active wake") { + const rosterCount = providerThreadRosterEvents(harness.events).length; + yield* TestClock.adjust("2 minutes"); + assert.lengthOf(providerThreadRosterEvents(harness.events), rosterCount); + } yield* harness.offerAndWait(wakeResult); yield* harness.awaitTerminal(2); + if (emptyLevel === "active wake") { + const rosterCount = providerThreadRosterEvents(harness.events).length; + yield* TestClock.adjust("2 minutes"); + assert.lengthOf(providerThreadRosterEvents(harness.events), rosterCount); + } const wakeStart = harness.events.findIndex( (event) => diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index 46441a539c0ad..9da33e7a1fada 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -6803,11 +6803,13 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( return tasks; }); + const owedWakeDeadlines = new Map>(); + const emitProviderThreadRoster = Effect.fnUntraced(function* (input: { readonly nativeThreadId: string; readonly providerThread: OrchestrationV2ProviderThread; readonly status?: OrchestrationV2ProviderThread["status"]; - }) { + }): Effect.fn.Return { const roster = rosterForNativeThread( yield* Ref.get(pendingBackgroundTasksByNativeThread), input.nativeThreadId, @@ -6817,6 +6819,61 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( input.nativeThreadId, ); const owedWakeTasks = yield* owedWakeTasksForNativeThread(input.nativeThreadId); + const deadlines = + owedWakeDeadlines.get(input.nativeThreadId) ?? new Map(); + for (const taskId of deadlines.keys()) { + if (!owedWakeTasks.some((task) => task.taskId === taskId)) deadlines.delete(taskId); + } + if (owedWakeTasks.length === 0) owedWakeDeadlines.delete(input.nativeThreadId); + else owedWakeDeadlines.set(input.nativeThreadId, deadlines); + for (const task of owedWakeTasks) { + if (deadlines.has(task.taskId)) continue; + const token = Symbol(task.taskId); + deadlines.set(task.taskId, token); + yield* Effect.sleep(CLAUDE_WAKE_TURN_START_DEADLINE).pipe( + Effect.andThen( + sdkMessageLock.withPermits(1)( + Effect.gen(function* () { + if (owedWakeDeadlines.get(input.nativeThreadId)?.get(task.taskId) !== token) + return false; + const previous = (yield* Ref.get(lastProviderThreadByNativeThread)).get( + input.nativeThreadId, + ); + const currentRoster = rosterForNativeThread( + yield* Ref.get(pendingBackgroundTasksByNativeThread), + input.nativeThreadId, + ); + if ( + previous === undefined || + currentRoster.has(task.taskId) || + !previous.pendingBackgroundTasks?.some( + (pending) => pending.taskId === task.taskId, + ) + ) { + deadlines.delete(task.taskId); + return false; + } + if ((yield* Ref.get(activeTurn)) !== null) return true; + deadlines.delete(task.taskId); + // A missing native wake must not hold the completed thread indefinitely. + yield* rememberProviderThread({ + ...previous, + pendingBackgroundTasks: (previous.pendingBackgroundTasks ?? []).filter( + (pending) => pending.taskId !== task.taskId, + ), + }); + yield* emitProviderThreadRoster({ + nativeThreadId: input.nativeThreadId, + providerThread: previous, + }); + return false; + }), + ), + ), + Effect.repeat({ while: (active) => active }), + Effect.forkIn(sessionScope), + ); + } const now = yield* DateTime.now; const providerThread: OrchestrationV2ProviderThread = { ...input.providerThread,