Skip to content

Commit 4b1426f

Browse files
AdEx-Partners-DEclaudejuliusmarminge
authored
fix(server): a Claude wake run settles when Claude never opens the wake turn (pingdotgg#19196)
Co-authored-by: Claude Opus 5.5 <[email protected]> Co-authored-by: Julius Marminge <[email protected]>
1 parent 6f89154 commit 4b1426f

2 files changed

Lines changed: 252 additions & 7 deletions

File tree

‎apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts‎

Lines changed: 204 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -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* () {

‎apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts‎

Lines changed: 48 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -287,6 +287,9 @@ const CLAUDE_SCRIPT_EXTENSIONS = [".js", ".mjs", ".tsx", ".ts", ".jsx"];
287287
// The SDK puts no deadline on control requests. The CLI answers
288288
// mcp_set_servers once each server connected or hit its own 30 s timeout.
289289
const CLAUDE_MCP_REGISTRATION_TIMEOUT = "90 seconds";
290+
// Claude can consume a subagent result before the launching turn ends, leaving
291+
// its notification with no native wake turn to answer the continuation.
292+
const CLAUDE_WAKE_TURN_START_DEADLINE = "2 minutes";
290293
// Claude Code flushes transcript writes every 100 ms, so a workflow member's
291294
// reply can land after the progress frame that settles it. Its transcript
292295
// stays the source of its answer this long after it settles.
@@ -2241,6 +2244,14 @@ function isClaudeTurnStartMessage(message: SDKMessage): boolean {
22412244
return message.type === "system" && message.subtype === "init";
22422245
}
22432246

2247+
function isClaudeRootTurnFrame(message: SDKMessage): boolean {
2248+
return (
2249+
isClaudeTurnStartMessage(message) ||
2250+
((message.type === "user" || message.type === "assistant" || message.type === "stream_event") &&
2251+
message.parent_tool_use_id == null)
2252+
);
2253+
}
2254+
22442255
function claudePendingBackgroundTasksFromRoster(
22452256
roster: ReadonlyMap<string, OrchestrationV2PendingBackgroundTask>,
22462257
): ReadonlyArray<OrchestrationV2PendingBackgroundTask> {
@@ -3212,6 +3223,7 @@ interface ActiveClaudeTurnContext {
32123223
readonly promptUuid: string | null;
32133224
promptEcho: "pending" | "confirmed";
32143225
promptStarted: boolean;
3226+
nativeWakeStarted: boolean;
32153227
gatedFramesBeforeEcho: number;
32163228
readonly heldRootFrames: Array<SDKMessage>;
32173229
}
@@ -8309,6 +8321,13 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
83098321
const message = input.message;
83108322
const context = yield* Ref.get(activeTurn);
83118323
const liveQuery = yield* Ref.get(queryContext);
8324+
if (
8325+
context?.promptUuid === null &&
8326+
liveQuery?.query === input.query &&
8327+
isClaudeRootTurnFrame(message)
8328+
) {
8329+
context.nativeWakeStarted = true;
8330+
}
83128331
if (
83138332
context === null ||
83148333
context.promptUuid === null ||
@@ -9092,6 +9111,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
90929111
promptUuid,
90939112
promptEcho: isClaudeProviderContinuationTurn(turnInput) ? "confirmed" : "pending",
90949113
promptStarted: false,
9114+
nativeWakeStarted: false,
90959115
gatedFramesBeforeEcho: 0,
90969116
heldRootFrames: [],
90979117
};
@@ -9208,15 +9228,36 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
92089228
yield* handleSdkMessage({ query: querySession.query, message: lastResult });
92099229
return;
92109230
}
9211-
const hasNativeWakeFrame = drained.some(
9212-
(entry) =>
9213-
entry.type === "user" ||
9214-
entry.type === "assistant" ||
9215-
isClaudeTurnStartMessage(entry),
9216-
);
9217-
if (hasOpaqueTaskNotification && !hasNativeWakeFrame) {
9231+
if (hasOpaqueTaskNotification && !context.nativeWakeStarted) {
92189232
const completedAt = yield* DateTime.now;
92199233
yield* finalizeActiveTurn({ context, status: "completed", completedAt });
9234+
} else if (!context.nativeWakeStarted) {
9235+
yield* Effect.sleep(CLAUDE_WAKE_TURN_START_DEADLINE).pipe(
9236+
Effect.andThen(
9237+
sdkMessageLock.withPermits(1)(
9238+
Effect.gen(function* () {
9239+
if (
9240+
(yield* Ref.get(activeTurn)) !== context ||
9241+
(yield* Ref.get(queryContext)) !== querySession ||
9242+
querySession.stopping ||
9243+
context.nativeWakeStarted ||
9244+
(yield* Ref.get(interruptedTurns)).has(context.providerTurnId)
9245+
)
9246+
return;
9247+
yield* Effect.logWarning(
9248+
"orchestration-v2.claude-wake-turn-never-opened",
9249+
{
9250+
providerTurnId: context.providerTurnId,
9251+
nativeThreadId,
9252+
},
9253+
);
9254+
const completedAt = yield* DateTime.now;
9255+
yield* finalizeActiveTurn({ context, status: "completed", completedAt });
9256+
}),
9257+
),
9258+
),
9259+
Effect.forkIn(sessionScope),
9260+
);
92209261
}
92219262
}),
92229263
);

0 commit comments

Comments
 (0)