Skip to content
TypeScript

fix(claude): a background-task wake run no longer hangs after a user turn absorbed its wake (#28010)

maria692dd9ce6f91
diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
index 23f61197a56..796e3655de7 100644
--- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
@@ -11432,6 +11432,86 @@ describe("ClaudeAdapterV2 background wake turns", () => {
),
);
+ it.effect("settles a continuation whose wake turn a user turn absorbed", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const harness = yield* makeWakeHarness;
+ const now = yield* DateTime.now;
+
+ yield* harness.runtime.startTurn(
+ makeClaudeTestTurnInput({
+ threadId: harness.threadId,
+ providerThread: harness.providerThread,
+ now,
+ attemptId: RunAttemptId.make("attempt-claude-wake-absorbed-1"),
+ text: "Run the build in the background.",
+ attachments: [],
+ }),
+ );
+ yield* Queue.offer(harness.sdkMessages, wakeTaskStarted);
+ yield* Queue.offer(harness.sdkMessages, wakeNotification);
+ yield* Queue.offer(harness.sdkMessages, turnOneResult);
+ yield* harness.awaitTerminal(1);
+ yield* harness.offerAndWait(wakeTurnInit);
+ yield* harness.offerAndWait(wakeAssistant);
+ yield* harness.awaitContinuation(1);
+
+ // Claude folds this prompt into the wake turn it already opened, so one result ends both.
+ yield* harness.runtime.startTurn(
+ makeClaudeTestTurnInput({
+ threadId: harness.threadId,
+ providerThread: harness.providerThread,
+ now,
+ attemptId: RunAttemptId.make("attempt-claude-wake-absorbed-2"),
+ text: "Any update on the pull request?",
+ attachments: [],
+ providerTurnOrdinal: 2,
+ }),
+ );
+ yield* harness.until(() => harness.offeredMessages.length === 2);
+ yield* Queue.offer(
+ harness.sdkMessages,
+ makeResultFrame({
+ uuid: "00000000-0000-4000-8000-000000000140",
+ result: "Checks passed and the pull request is up to date.",
+ }),
+ );
+ yield* harness.awaitTerminal(2);
+
+ yield* harness.runtime.startTurn(
+ makeClaudeTestTurnInput({
+ threadId: harness.threadId,
+ providerThread: harness.providerThread,
+ now,
+ attemptId: RunAttemptId.make("attempt-claude-wake-absorbed-3"),
+ text: "Background task completed.",
+ attachments: [],
+ providerTurnOrdinal: 3,
+ messageCreatedBy: "agent",
+ messageCreationSource: "provider",
+ }),
+ );
+ yield* harness.awaitTerminal(3);
+ assert.equal(harness.terminalEvents()[2]?.status, "completed");
+ assert.isTrue(
+ harness.events.some(
+ (event) =>
+ event.type === "message.updated" && event.message.text === WAKE_ASSISTANT_TEXT,
+ ),
+ );
+ }).pipe(
+ Effect.provide(
+ Layer.mergeAll(
+ IdAllocator.layer,
+ McpProviderSessions.layer,
+ NodeServices.layer,
+ NodeCrypto.layer,
+ ),
+ ),
+ ),
+ ),
+ );
+
it.effect("ignores a zero-turn task-notification origin result during a normal user turn", () =>
Effect.scoped(
Effect.gen(function* () {
diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
index 049d2e2cf0e..6458137a10c 100644
--- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
@@ -5031,6 +5031,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
}
});
const requestedContinuations = yield* Ref.make(new Set<string>());
+ const absorbedWakes = yield* Ref.make(new Set<string>());
const heldProposedPlansByToolUseId = new Map<string, string>();
const runtimeContext = yield* Effect.context<never>();
const runPromise = Effect.runPromiseWith(runtimeContext);
@@ -5466,6 +5467,14 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
yield* endClaudeMonitorTasks((_taskId, task) => task.nativeThreadId === nativeThreadId);
});
+ const forgetAbsorbedWake = (nativeThreadId: string) =>
+ Ref.update(absorbedWakes, (current) => {
+ if (!current.has(nativeThreadId)) return current;
+ const updated = new Set(current);
+ updated.delete(nativeThreadId);
+ return updated;
+ });
+
const clearWakeStateForNativeThread =
/* Provider events include streaming deltas; avoid a span for each update. */
Effect.fnUntraced(function* (nativeThreadId: string) {
@@ -5486,8 +5495,18 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
updated.delete(nativeThreadId);
return updated;
});
+ yield* forgetAbsorbedWake(nativeThreadId);
});
+ // Claude runs one root turn at a time, so a user turn's result also ends a wake turn it
+ // folded in. The continuation replays that wake's buffered frames but gets no result of its own.
+ const markAbsorbedWake = Effect.fnUntraced(function* (nativeThreadId: string) {
+ const messages = (yield* Ref.get(wakeBuffers)).get(nativeThreadId)?.messages ?? [];
+ const lastResult = messages.findLastIndex((entry) => entry.type === "result");
+ if (!messages.slice(lastResult + 1).some(isClaudeRootTurnFrame)) return;
+ yield* Ref.update(absorbedWakes, (current) => new Set(current).add(nativeThreadId));
+ });
+
// The SDK emits no initial roster; reset roster and wake eligibility when opening a live query.
const resetBackgroundTaskStateForNativeThreadProcess = Effect.fnUntraced(function* (
nativeThreadId: string,
@@ -8070,6 +8089,9 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
if (message.type === "result") {
bufferedResultArrivals.set(message, yield* DateTime.now);
}
+ if (isClaudeRootTurnFrame(message)) {
+ yield* forgetAbsorbedWake(wakeInput.nativeThreadId);
+ }
yield* Ref.update(wakeBuffers, (current) => {
const existing = current.get(wakeInput.nativeThreadId);
const updated = new Map(current);
@@ -9496,6 +9518,9 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
next.delete(context.providerTurnId);
return next;
});
+ if (!isClaudeProviderContinuationTurn(context.input)) {
+ yield* markAbsorbedWake(liveQuery.nativeThreadId);
+ }
const usageLimited =
context.authenticationFailureMessage === undefined &&
(context.rejectedRateLimitTypes.size > 0 ||
@@ -10793,6 +10818,8 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
updated.delete(nativeThreadId);
return updated;
});
+ const wakeAbsorbed = (yield* Ref.get(absorbedWakes)).has(nativeThreadId);
+ yield* forgetAbsorbedWake(nativeThreadId);
if (drained.length === 0) {
const completedAt = yield* DateTime.now;
yield* finalizeActiveTurn({ context, status: "completed", completedAt });
@@ -10861,7 +10888,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
yield* handleSdkMessage({ query: querySession.query, message: lastResult });
return;
}
- if (hasOpaqueTaskNotification && !context.nativeWakeStarted) {
+ if (wakeAbsorbed || (hasOpaqueTaskNotification && !context.nativeWakeStarted)) {
const completedAt = yield* DateTime.now;
yield* finalizeActiveTurn({ context, status: "completed", completedAt });
} else if (!context.nativeWakeStarted) {