diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts index 3ab716b2afdb..95432c40e688 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts @@ -3664,6 +3664,64 @@ describe("ClaudeAdapterV2 background wake turns", () => { }); const makeWakeHarness = makeWakeHarnessWithOptions(); + it.effect("resumes the session a /clear selected after the Claude process is replaced", () => + Effect.gen(function* () { + const harness = yield* makeWakeHarnessWithOptions({ + freshQueueOnReopen: true, + close: (queue) => Queue.shutdown(queue), + }); + const turn = (ordinal: number, providerThread: OrchestrationV2ProviderThread) => + makeClaudeTestTurnInput({ + threadId: harness.threadId, + providerThread, + now: DateTime.makeUnsafe(0), + attemptId: RunAttemptId.make(`clear-session-${ordinal}`), + text: ordinal === 1 ? "/clear" : "Continue the cleared conversation", + attachments: [], + providerTurnOrdinal: ordinal, + }); + yield* harness.runtime.startTurn(turn(1, harness.providerThread)); + // Claude Code reports the session /clear started in its next init frame. + yield* harness.offerAndWait( + claudeSdkFrame({ + type: "system", + subtype: "init", + session_id: "cleared-native-session", + uuid: "00000000-0000-4000-8000-000000000501", + }), + ); + yield* harness.offerAndWait(turnOneResult); + yield* Queue.take(harness.terminalReceipts); + const latest = (): OrchestrationV2ProviderThread => { + const event = harness.events.findLast( + (candidate) => candidate.type === "provider_thread.updated", + ); + return event?.type === "provider_thread.updated" + ? event.providerThread + : harness.providerThread; + }; + assert.equal(latest().nativeThreadRef?.nativeId, "cleared-native-session"); + yield* harness.runtime.interruptTurn({ + providerThread: latest(), + providerTurnId: lastProviderTurn(harness.events).id, + requestRuntimeRestart: true, + }); + yield* harness.runtime.startTurn(turn(2, latest())); + assert.equal(harness.processQueues.length, 2); + assert.equal(harness.getOpenedOptions()?.resume, "cleared-native-session"); + }).pipe( + Effect.scoped, + Effect.provide( + Layer.mergeAll( + IdAllocator.layer, + McpProviderSessions.layer, + NodeServices.layer, + NodeCrypto.layer, + ), + ), + ), + ); + it.effect.each(["release-after", "cancel-after", "release-before", "resume-pending"] as const)( "keeps attachment reservations across compaction: %s boundary", (outcome) => diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index 6fe2003fd8c4..3e10e0990679 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -5846,6 +5846,8 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( ); const absorbedWakes = yield* Ref.make(new Set()); const heldProposedPlansByToolUseId = new Map(); + // /clear moves a live process to a new native session; persist that one so a reopen resumes it. + const clearedNativeSessions = new Map(); const runtimeContext = yield* Effect.context(); const runPromise = Effect.runPromiseWith(runtimeContext); @@ -5867,6 +5869,23 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( }, }; } + const nativeSessionId = clearedNativeSessions.get( + event.providerThread.nativeThreadRef?.nativeId ?? "", + ); + if (nativeSessionId !== undefined) { + event = { + ...event, + providerThread: { + ...event.providerThread, + nativeThreadRef: { + driver: CLAUDE_PROVIDER, + nativeId: nativeSessionId, + strength: "strong", + }, + nativeConversationHeadRef: null, + }, + }; + } } return Queue.offer(events, event).pipe(Effect.asVoid); }; @@ -11999,6 +12018,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( path, }); const closedExistingNativeThreadId = existing !== null ? existing.nativeThreadId : null; + clearedNativeSessions.delete(nativeThreadId); if (existing !== null) { yield* existing.query.close.pipe(Effect.ignore); if (existing.nativeThreadId !== nativeThreadId) { @@ -12159,6 +12179,14 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( context.capabilities = new Set(message.capabilities ?? []); context.claudeCodeVersion = message.claude_code_version; } + if ( + message.type === "system" && + message.subtype === "init" && + message.session_id.length > 0 && + message.session_id !== context.nativeThreadId + ) { + clearedNativeSessions.set(context.nativeThreadId, message.session_id); + } if ( message.type === "system" && (message.subtype === "init" || message.subtype === "status") && @@ -12903,7 +12931,11 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( const closeLiveQueryForNativeThread = Effect.fnUntraced(function* (nativeThreadId: string) { const existing = yield* Ref.get(queryContext); - if (existing === null || existing.nativeThreadId !== nativeThreadId) { + if ( + existing === null || + (existing.nativeThreadId !== nativeThreadId && + clearedNativeSessions.get(existing.nativeThreadId) !== nativeThreadId) + ) { return; } @@ -12925,7 +12957,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( ); if (ownedLiveQuery) { yield* finalizeActiveTurnAfterQueryExit(existing); - yield* endSubagentCallsOfClosedQuery(nativeThreadId, "interrupted"); + yield* endSubagentCallsOfClosedQuery(existing.nativeThreadId, "interrupted"); } else { yield* endSubagentsOfReplacedQuery(existing); }