From 99a636576ec4aae2ed9166c05f41339398f408fd Mon Sep 17 00:00:00 2001 From: declandarcy Date: Wed, 18 Nov 2026 11:52:43 -0800 Subject: [PATCH 1/9] fix(server): steers no longer abort Claude's auto-compaction Claude steers go out with priority "now", which aborts a running auto-compaction. Claude then retries the compaction, and the next message from a subagent or another thread aborts it again. A busy orchestrator thread could loop like this for minutes. A steer that arrives while Claude compacts is now accepted and held. It is sent once the compaction succeeds or fails. If the user stops the turn first, the steer is cancelled with the existing undelivered-steer notice. steerTurn still returns right away, so a held steer never blocks the thread's Stop effect. Co-Authored-By: Claude Opus 5.5 --- .../Adapters/ClaudeAdapterV2.test.ts | 107 ++++++++++++++++++ .../Adapters/ClaudeAdapterV2.ts | 81 ++++++++++--- 2 files changed, 175 insertions(+), 13 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts index b5cd8624ecda4..42905579fbbdb 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts @@ -11047,6 +11047,113 @@ describe("ClaudeAdapterV2 background wake turns", () => { ), ); + it.effect.each(["boundary", "failed", "interrupt"] as const)( + "holds a steer until Claude's auto-compaction settles: %s", + (outcome) => + Effect.gen(function* () { + const harness = yield* makeWakeHarnessWithOptions({ + close: (sdkMessages) => Queue.shutdown(sdkMessages), + }); + const idAllocator = yield* IdAllocator.IdAllocatorV2; + const input = makeClaudeTestTurnInput({ + threadId: harness.threadId, + providerThread: harness.providerThread, + now: yield* DateTime.now, + attemptId: RunAttemptId.make(`claude-held-steer-${outcome}`), + text: "Keep orchestrating.", + attachments: [], + }); + yield* harness.runtime.startTurn(input); + const providerTurnId = idAllocator.derive.providerTurn({ + driver: ClaudeAdapterV2.CLAUDE_PROVIDER, + nativeTurnId: `turn:${input.attemptId}`, + }); + yield* harness.offerAndWait( + claudeSdkFrame({ + type: "system", + subtype: "status", + status: "compacting", + uuid: "00000000-0000-4000-8000-000000038701", + session_id: WAKE_NATIVE_SESSION, + }), + ); + // A "now" steer would abort the compaction, so it waits without blocking Stop. + yield* harness.runtime.steerTurn({ + threadId: harness.threadId, + runId: input.runId, + providerThread: harness.providerThread, + providerTurnId, + message: { + createdBy: "agent", + creationSource: "mcp", + messageId: MessageId.make("held-steer"), + text: "Subagent finished.", + attachments: [], + }, + }); + assert.lengthOf(harness.offeredMessages, 1); + + if (outcome === "interrupt") { + yield* harness.runtime.interruptTurn({ + providerThread: harness.providerThread, + providerTurnId, + }); + assert.equal((yield* Queue.take(harness.terminalReceipts)).status, "interrupted"); + assert.lengthOf(harness.offeredMessages, 1); + assert.deepEqual( + harness.events.flatMap((event) => + event.type === "steer.updated" ? [event.status] : [], + ), + ["pending", "cancelled"], + ); + assert.isTrue( + harness.events.some( + (event) => + event.type === "turn_item.updated" && + event.turnItem.type === "system_notice" && + event.turnItem.message?.includes("Subagent finished.") === true, + ), + ); + return; + } + yield* harness.offerAndWait( + outcome === "boundary" + ? claudeSdkFrame({ + type: "system", + subtype: "compact_boundary", + compact_metadata: { trigger: "auto", pre_tokens: 3000, post_tokens: 600 }, + uuid: "00000000-0000-4000-8000-000000038702", + session_id: WAKE_NATIVE_SESSION, + }) + : claudeSdkFrame({ + type: "system", + subtype: "status", + status: null, + compact_result: "failed", + compact_error: "Compaction failed.", + uuid: "00000000-0000-4000-8000-000000038702", + session_id: WAKE_NATIVE_SESSION, + }), + ); + assert.lengthOf(harness.offeredMessages, 2); + assert.equal(harness.offeredMessages[1]?.priority, "now"); + assert.include( + JSON.stringify(harness.offeredMessages[1]?.message.content), + "Subagent finished.", + ); + }).pipe( + Effect.scoped, + Effect.provide( + Layer.mergeAll( + IdAllocator.layer, + McpProviderSessions.layer, + NodeServices.layer, + NodeCrypto.layer, + ), + ), + ), + ); + it.effect("names the notebook a Claude NotebookEdit changed", () => Effect.gen(function* () { const harness = yield* makeWakeHarness; diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index 1941620cd8b01..7dfbbc73d83ec 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -157,6 +157,7 @@ import * as Path from "effect/Path"; import * as Queue from "effect/Queue"; import * as Ref from "effect/Ref"; import * as Schema from "effect/Schema"; +import * as Scope from "effect/Scope"; import * as Semaphore from "effect/Semaphore"; import * as Stream from "effect/Stream"; import * as ChildProcess from "effect/process/ChildProcess"; @@ -5095,6 +5096,13 @@ interface ActiveClaudeTurnContext { >; // Claude may settle a turn with a result that echoes only a steer's uuid. readonly steerUuids: Set; + // A "now" steer aborts a running compaction, which Claude then restarts, so steers that + // arrive mid-compaction wait here, also in pendingSteers, until it settles. + readonly heldSteers: Array<{ + readonly uuid: string; + readonly offer: Effect.Effect; + readonly release: Effect.Effect; + }>; // Claude can run another model than requested, such as when an organization disallows it. executedModel: string | undefined; } @@ -9236,6 +9244,26 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( } }); + const offerHeldSteers = Effect.fnUntraced(function* (context: ActiveClaudeTurnContext) { + for (const { uuid, offer } of context.heldSteers.splice(0)) { + yield* offer.pipe( + Effect.catch((cause) => { + const steer = context.pendingSteers.get(uuid); + context.pendingSteers.delete(uuid); + return Effect.logWarning("orchestration-v2.claude-held-steer-offer-failed", { + cause, + }).pipe( + Effect.andThen( + steer === undefined + ? Effect.void + : emitSteerStatus(context, steer.messageId, "cancelled"), + ), + ); + }), + ); + } + }); + const finalizeActiveTurn = Effect.fnUntraced(function* (requested: { readonly context: ActiveClaudeTurnContext; readonly status: Extract< @@ -9263,14 +9291,17 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( if (input.status === "completed" && input.context.appContextOffered !== undefined) { deliveredAppContext.set(input.context.nativeThreadId, input.context.appContextOffered); } - // A turn that completes has taken in every steer; one that stops drops them unread. + // A turn that completes has taken in every offered steer; one that stops drops them unread. + const heldSteers = input.context.heldSteers.splice(0); + const heldSteerUuids = new Set(heldSteers.map((steer) => steer.uuid)); + for (const steer of heldSteers) yield* steer.release; const droppedSteers = [...input.context.pendingSteers]; input.context.pendingSteers.clear(); - for (const [, { messageId }] of droppedSteers) { + for (const [uuid, { messageId }] of droppedSteers) { yield* emitSteerStatus( input.context, messageId, - input.status === "completed" ? "completed" : "cancelled", + input.status === "completed" && !heldSteerUuids.has(uuid) ? "completed" : "cancelled", ); } if (input.context.compaction?.status === "running") { @@ -9412,8 +9443,9 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( if (input.status === "interrupted") { for (const [uuid, { text, liveQuery }] of droppedSteers) { - // Only a CLI proven to echo prompt uuids can leave a steer unconfirmed. + // Only a CLI proven to echo prompt uuids can leave an offered steer unconfirmed. if ( + !heldSteerUuids.has(uuid) && liveQuery.promptEchoMode !== "early" && liveQuery.promptEchoMode !== "result_only" ) { @@ -10944,9 +10976,8 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( (message.status === null && message.permissionMode === undefined)) ) { // The CLI reports a compaction it aborted for our interrupt as failed. - const failed = - message.compact_result === "failed" && - !(yield* Ref.get(interruptedTurns)).has(context.providerTurnId); + const interrupted = (yield* Ref.get(interruptedTurns)).has(context.providerTurnId); + const failed = message.compact_result === "failed" && !interrupted; if (message.compact_result !== undefined) { context.compactionFailure = failed ? { message: message.compact_error } : null; } @@ -10981,6 +11012,8 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( if (budget !== undefined) budget.compacting = null; } } + // Stop settles held steers with the turn instead. + if (!interrupted) yield* offerHeldSteers(context); } // Every trigger discards the conversation, so reset whatever the trigger is. @@ -11082,6 +11115,9 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( }, }); context.compaction = null; + if (!(yield* Ref.get(interruptedTurns)).has(context.providerTurnId)) { + yield* offerHeldSteers(context); + } return; } @@ -13333,6 +13369,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( heldRootFrames: [], pendingSteers: new Map(), steerUuids: new Set(), + heldSteers: [], executedModel: undefined, }; const attachTurn = Effect.gen(function* () { @@ -13773,6 +13810,12 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( }), ), ); + // A held steer keeps its reservation past this call. + const reservationScope = yield* Scope.make(); + let held = false; + yield* Effect.addFinalizer((exit) => + held ? Effect.void : Scope.close(reservationScope, exit), + ); const pdfReservation = yield* reserveClaudePdfBudget( pdfBudgets.get(existing.nativeThreadId) ?? makeClaudeAttachmentBudget({ @@ -13780,7 +13823,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( bytesUsed: CLAUDE_ATTACHMENT_MAX_BYTES, }), persistAttachmentBudget(existing.nativeThreadId), - ); + ).pipe(Scope.provide(reservationScope)); // A selection sent with the steer applies to the running turn when the live process can switch to it. const steerSelection = turnInput.modelSelection === undefined @@ -13855,6 +13898,11 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( detail: `Claude provider turn ${turnInput.providerTurnId} ended before the steer was sent.`, }); } + const offer = Effect.uninterruptibleMask((restore) => + restore(existing.query.offer(userMessage, commitOffer)).pipe( + Effect.tap(() => Effect.sync(commitOffer)), + ), + ); // Register before offering: Claude can start the steer and end the turn before offer returns. const messageId = turnInput.message.messageId; currentTurn.steerUuids.add(steerUuid); @@ -13863,17 +13911,24 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( text: turnInput.message.text, liveQuery: existing, }); + // Returns without waiting: a running steer effect would block this thread's Stop. + if (currentTurn.compaction?.status === "running") { + held = true; + const release = Scope.close(reservationScope, Exit.void); + currentTurn.heldSteers.push({ + uuid: steerUuid, + offer: offer.pipe(Effect.ensuring(release)), + release, + }); + } yield* Ref.update(steeredTurns, (current) => { const next = new Set(current); next.add(turnInput.providerTurnId); return next; }); yield* emitSteerStatus(currentTurn, messageId, "pending"); - yield* Effect.uninterruptibleMask((restore) => - restore(existing.query.offer(userMessage, commitOffer)).pipe( - Effect.tap(() => Effect.sync(commitOffer)), - ), - ).pipe( + if (held) return; + yield* offer.pipe( Effect.onError(() => currentTurn.pendingSteers.delete(steerUuid) ? emitSteerStatus(currentTurn, messageId, "completed") From 61ec311d4b06f768ea68a09d78d90ba5a4270f06 Mon Sep 17 00:00:00 2001 From: declandarcy Date: Wed, 18 Nov 2026 12:34:36 -0800 Subject: [PATCH 2/9] fix(server): Claude composers steer instead of queueing during auto-compaction With steers now held until a running auto-compaction settles, a Claude steer leaves the compaction intact. Claude declares activeSteeringDuringCompaction, so the web and mobile composers steer a message sent mid-compaction into the same turn instead of queueing it until the whole turn ends. Co-Authored-By: Claude Opus 5.5 --- apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts | 2 ++ docs/user/providers-claude.md | 4 +++- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index 7dfbbc73d83ec..630e457cf667e 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -536,6 +536,8 @@ export const ClaudeProviderCapabilitiesV2 = { supportsInterrupt: true, supportsActiveSteering: true, activeSteeringInterruptsTools: true, + // Steers wait for a running auto-compaction instead of aborting it. + activeSteeringDuringCompaction: true, supportsSteeringByInterruptRestart: false, supportsQueuedMessages: true, terminalStatusQuality: "strong", diff --git a/docs/user/providers-claude.md b/docs/user/providers-claude.md index 5d4295a942638..4094ef1ed8a44 100644 --- a/docs/user/providers-claude.md +++ b/docs/user/providers-claude.md @@ -56,7 +56,9 @@ Set **Auto-compact after** in the Claude provider settings to an integer between window. Leave it empty for Claude Code's default. You can also send `/compact` in an existing conversation. Claude Code also -compacts automatically. To see context usage, see +compacts automatically. A message steered into a turn while Claude compacts +automatically waits for the compaction to finish, then reaches the same turn. +To see context usage, see [commands and skills](./composer.md#commands-and-skills). When you return to a large thread after Claude's prompt cache expires, a From ab5ce8fb027c58ea37742182e63543391ba9179a Mon Sep 17 00:00:00 2001 From: declandarcy Date: Wed, 18 Nov 2026 12:49:53 -0800 Subject: [PATCH 3/9] fix(server): held Claude steers keep their order and reservations Releasing held steers took them all off the turn before offering any. A steer that arrived mid-release then saw no compaction and overtook the rest, and a release interrupted mid-drain left the untaken steers' PDF reservations with no owner, so a later PDF fell back to a text path. Held steers now leave the turn one at a time as they are offered. Steers that arrive while a release drains queue behind it, and finalization releases whatever is still held. Co-Authored-By: Claude Opus 5.5 --- .../Adapters/ClaudeAdapterV2.test.ts | 146 ++++++++++++++++++ .../Adapters/ClaudeAdapterV2.ts | 28 +++- 2 files changed, 171 insertions(+), 3 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts index 42905579fbbdb..6af41d3f34aa0 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts @@ -11154,6 +11154,152 @@ describe("ClaudeAdapterV2 background wake turns", () => { ), ); + it.effect.each(["newer steer", "query close"] as const)( + "releases held steers in order and leaves none unreleased: %s mid-release", + (outcome) => + Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const idAllocator = yield* IdAllocator.IdAllocatorV2; + const sending = yield* Deferred.make(); + const resume = yield* Deferred.make(); + let closing = false; + const harness = yield* makeWakeHarnessWithOptions({ + close: (sdkMessages) => Queue.shutdown(sdkMessages), + // Pauses A mid-offer, then interrupts B as a closing query would. + offer: (message) => { + const text = JSON.stringify(message.message.content); + if (text.includes("Steer A")) { + return Deferred.succeed(sending, undefined).pipe( + Effect.andThen(Deferred.await(resume)), + ); + } + return closing && text.includes("Steer B") ? Effect.interrupt : Effect.void; + }, + }); + const document = ChatFileAttachment.make({ + type: "file", + id: ChatAttachmentId.make("held-steer-document"), + name: "held.pdf", + mimeType: "application/pdf", + sizeBytes: 19 * 1024 * 1024, + }); + const pages = Buffer.from( + `%PDF-1.7\n1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj\n2 0 obj << /Type /Pages /Count 60 >> endobj\n${Array.from({ length: 60 }, (_, i) => `${i + 3} 0 obj << /Type /Page /Parent 2 0 R >> endobj`).join("\n")}\n`, + ); + yield* fileSystem.writeFile( + path.join(harness.attachmentsDir, attachmentRelativePath(document)!), + Buffer.concat([ + pages, + Buffer.alloc(document.sizeBytes - pages.length - 5, 32), + Buffer.from("%%EOF"), + ]), + ); + const input = makeClaudeTestTurnInput({ + threadId: harness.threadId, + providerThread: harness.providerThread, + now: yield* DateTime.now, + attemptId: RunAttemptId.make(`claude-held-release-${outcome}`), + text: "Keep orchestrating.", + attachments: [], + }); + yield* harness.runtime.startTurn(input); + const providerTurnId = idAllocator.derive.providerTurn({ + driver: ClaudeAdapterV2.CLAUDE_PROVIDER, + nativeTurnId: `turn:${input.attemptId}`, + }); + const steer = (name: string, attachments: ReadonlyArray = []) => + harness.runtime.steerTurn({ + threadId: harness.threadId, + runId: input.runId, + providerThread: harness.providerThread, + providerTurnId, + message: { + createdBy: "agent", + creationSource: "mcp", + messageId: MessageId.make(`held-${name}`), + text: `Steer ${name}.`, + attachments, + }, + }); + yield* harness.offerAndWait( + claudeSdkFrame({ + type: "system", + subtype: "status", + status: "compacting", + uuid: "00000000-0000-4000-8000-000000038711", + session_id: WAKE_NATIVE_SESSION, + }), + ); + yield* steer("A"); + yield* steer("B"); + if (outcome === "query close") yield* steer("C", [document]); + const releasing = yield* harness + .offerAndWait( + claudeSdkFrame({ + type: "system", + subtype: "status", + status: null, + compact_result: "success", + uuid: "00000000-0000-4000-8000-000000038712", + session_id: WAKE_NATIVE_SESSION, + }), + ) + .pipe(Effect.forkScoped); + yield* Deferred.await(sending); + + if (outcome === "newer steer") { + yield* steer("C"); + yield* Deferred.succeed(resume, undefined); + yield* Fiber.join(releasing); + assert.deepEqual( + harness.offeredMessages + .slice(1) + .map((message) => /Steer (\w)\./.exec(JSON.stringify(message.message.content))?.[1]), + ["A", "B", "C"], + ); + return; + } + + // The query closes while B is offered, which interrupts the release mid-drain. + closing = true; + yield* Deferred.succeed(resume, undefined); + yield* Queue.take(harness.terminalReceipts); + // The undelivered PDF's pages are free again, so a new turn can send it natively. + const before = harness.offeredMessages.length; + yield* harness.runtime.startTurn( + makeClaudeTestTurnInput({ + threadId: harness.threadId, + providerThread: harness.providerThread, + now: yield* DateTime.now, + attemptId: RunAttemptId.make("claude-held-release-after-stop"), + text: "Read this PDF.", + attachments: [document], + providerTurnOrdinal: 2, + nativeThreadHasTurns: true, + }), + ); + const documents = harness.offeredMessages + .slice(before) + .flatMap((message) => + Array.isArray(message.message.content) + ? message.message.content.filter((block) => block.type === "document") + : [], + ); + assert.lengthOf(documents, 1); + }).pipe( + Effect.scoped, + Effect.provide( + Layer.mergeAll( + IdAllocator.layer, + McpProviderSessions.layer, + NodeServices.layer, + NodeCrypto.layer, + ), + ), + ), + ); + it.effect("names the notebook a Claude NotebookEdit changed", () => Effect.gen(function* () { const harness = yield* makeWakeHarness; diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index 630e457cf667e..86cd4141693ae 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -5099,12 +5099,15 @@ interface ActiveClaudeTurnContext { // Claude may settle a turn with a result that echoes only a steer's uuid. readonly steerUuids: Set; // A "now" steer aborts a running compaction, which Claude then restarts, so steers that - // arrive mid-compaction wait here, also in pendingSteers, until it settles. + // arrive mid-compaction wait here, also in pendingSteers, until it settles. Finalization + // releases what is still here; an entry taken for offering releases itself. readonly heldSteers: Array<{ readonly uuid: string; readonly offer: Effect.Effect; readonly release: Effect.Effect; }>; + // Set while held steers are offered, so later steers queue behind them. + releasingHeldSteers: boolean; // Claude can run another model than requested, such as when an organization disallows it. executedModel: string | undefined; } @@ -9246,9 +9249,27 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( } }); + // Taking the next steer and clearing the flag happen together, so none is left behind. + const takeHeldSteer = (context: ActiveClaudeTurnContext) => { + const next = context.steersClosed ? undefined : context.heldSteers.shift(); + context.releasingHeldSteers = next !== undefined; + return next; + }; + const offerHeldSteers = Effect.fnUntraced(function* (context: ActiveClaudeTurnContext) { - for (const { uuid, offer } of context.heldSteers.splice(0)) { + if (context.releasingHeldSteers) return; + for ( + let next = takeHeldSteer(context); + next !== undefined; + next = takeHeldSteer(context) + ) { + const { uuid, offer } = next; yield* offer.pipe( + Effect.onInterrupt(() => + Effect.sync(() => { + context.releasingHeldSteers = false; + }), + ), Effect.catch((cause) => { const steer = context.pendingSteers.get(uuid); context.pendingSteers.delete(uuid); @@ -13372,6 +13393,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( pendingSteers: new Map(), steerUuids: new Set(), heldSteers: [], + releasingHeldSteers: false, executedModel: undefined, }; const attachTurn = Effect.gen(function* () { @@ -13914,7 +13936,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( liveQuery: existing, }); // Returns without waiting: a running steer effect would block this thread's Stop. - if (currentTurn.compaction?.status === "running") { + if (currentTurn.compaction?.status === "running" || currentTurn.releasingHeldSteers) { held = true; const release = Scope.close(reservationScope, Exit.void); currentTurn.heldSteers.push({ From f4117c0d18f90e717fb6a8cc00bb32294f3f2c79 Mon Sep 17 00:00:00 2001 From: declandarcy Date: Wed, 18 Nov 2026 12:56:19 -0800 Subject: [PATCH 4/9] fix(server): a held steer dropped with its turn always gets a notice A held steer cancelled because its turn failed, such as when the Claude process exits mid-compaction, was dropped without a notice, and Stop told the user Claude might not have read a steer that was never sent. Held steers now always get a "Steer not sent" notice that says the turn ended during compaction. Offered steers keep the Stop-only notice. Co-Authored-By: Claude Opus 5.5 --- .../Adapters/ClaudeAdapterV2.test.ts | 35 +++++--- .../Adapters/ClaudeAdapterV2.ts | 85 ++++++++++--------- 2 files changed, 65 insertions(+), 55 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts index 6af41d3f34aa0..0c086f20fbb00 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts @@ -11047,7 +11047,7 @@ describe("ClaudeAdapterV2 background wake turns", () => { ), ); - it.effect.each(["boundary", "failed", "interrupt"] as const)( + it.effect.each(["boundary", "failed", "interrupt", "query exit"] as const)( "holds a steer until Claude's auto-compaction settles: %s", (outcome) => Effect.gen(function* () { @@ -11093,12 +11093,19 @@ describe("ClaudeAdapterV2 background wake turns", () => { }); assert.lengthOf(harness.offeredMessages, 1); - if (outcome === "interrupt") { - yield* harness.runtime.interruptTurn({ - providerThread: harness.providerThread, - providerTurnId, - }); - assert.equal((yield* Queue.take(harness.terminalReceipts)).status, "interrupted"); + if (outcome === "interrupt" || outcome === "query exit") { + if (outcome === "interrupt") { + yield* harness.runtime.interruptTurn({ + providerThread: harness.providerThread, + providerTurnId, + }); + } else { + yield* Queue.shutdown(harness.sdkMessages); + } + assert.equal( + (yield* Queue.take(harness.terminalReceipts)).status, + outcome === "interrupt" ? "interrupted" : "failed", + ); assert.lengthOf(harness.offeredMessages, 1); assert.deepEqual( harness.events.flatMap((event) => @@ -11106,14 +11113,14 @@ describe("ClaudeAdapterV2 background wake turns", () => { ), ["pending", "cancelled"], ); - assert.isTrue( - harness.events.some( - (event) => - event.type === "turn_item.updated" && - event.turnItem.type === "system_notice" && - event.turnItem.message?.includes("Subagent finished.") === true, - ), + const notices = harness.events.flatMap((event) => + event.type === "turn_item.updated" && event.turnItem.type === "system_notice" + ? [event.turnItem] + : [], ); + const notice = notices.find((item) => item.message?.includes("Subagent finished.")); + assert.equal(notice?.title, "Steer not sent"); + assert.notInclude(notice?.message ?? "", "Stop"); return; } yield* harness.offerAndWait( diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index 86cd4141693ae..05b83edbf8b9b 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -9464,48 +9464,51 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( }); } - if (input.status === "interrupted") { - for (const [uuid, { text, liveQuery }] of droppedSteers) { - // Only a CLI proven to echo prompt uuids can leave an offered steer unconfirmed. - if ( - !heldSteerUuids.has(uuid) && - liveQuery.promptEchoMode !== "early" && - liveQuery.promptEchoMode !== "result_only" - ) { - continue; - } - const nativeItemId = `unread-steer:${uuid}`; - const notice = `Claude did not confirm reading your steer before Stop. It may not have been delivered. Resend it if needed: "${text}"`; - yield* emitProviderEvent({ - type: "turn_item.updated", - driver: CLAUDE_PROVIDER, - turnItem: { - id: idAllocator.derive.turnItemFromProviderItem({ - driver: CLAUDE_PROVIDER, - nativeItemId, - }), - threadId: input.context.input.threadId, - runId: input.context.input.runId, - nodeId: input.context.input.rootNodeId, - providerThreadId: input.context.input.providerThread.id, - providerTurnId: input.context.providerTurnId, - nativeItemRef: { - driver: CLAUDE_PROVIDER, - nativeId: nativeItemId, - strength: "weak", - }, - parentItemId: null, - ordinal: yield* resolveItemOrdinal(input.context, nativeItemId), - type: "system_notice", - status: "completed", - title: "Steer delivery not confirmed", - message: notice, - startedAt: input.completedAt, - completedAt: input.completedAt, - updatedAt: input.completedAt, - }, - }); + for (const [uuid, { text, liveQuery }] of droppedSteers) { + const held = heldSteerUuids.has(uuid); + // A held steer was never sent, whatever ended the turn. An offered one can be unread + // only after Stop, and only a CLI proven to echo prompt uuids can show it. + if ( + !held && + (input.status !== "interrupted" || + (liveQuery.promptEchoMode !== "early" && + liveQuery.promptEchoMode !== "result_only")) + ) { + continue; } + const nativeItemId = `unread-steer:${uuid}`; + const notice = held + ? `The turn ended while Claude was compacting, so this steer was not sent. Resend it if needed: "${text}"` + : `Claude did not confirm reading your steer before Stop. It may not have been delivered. Resend it if needed: "${text}"`; + yield* emitProviderEvent({ + type: "turn_item.updated", + driver: CLAUDE_PROVIDER, + turnItem: { + id: idAllocator.derive.turnItemFromProviderItem({ + driver: CLAUDE_PROVIDER, + nativeItemId, + }), + threadId: input.context.input.threadId, + runId: input.context.input.runId, + nodeId: input.context.input.rootNodeId, + providerThreadId: input.context.input.providerThread.id, + providerTurnId: input.context.providerTurnId, + nativeItemRef: { + driver: CLAUDE_PROVIDER, + nativeId: nativeItemId, + strength: "weak", + }, + parentItemId: null, + ordinal: yield* resolveItemOrdinal(input.context, nativeItemId), + type: "system_notice", + status: "completed", + title: held ? "Steer not sent" : "Steer delivery not confirmed", + message: notice, + startedAt: input.completedAt, + completedAt: input.completedAt, + updatedAt: input.completedAt, + }, + }); } const threadDisposition = input.threadDisposition ?? "reusable"; From 5880839eaddf8794a72ad080250fc264ba68cbeb Mon Sep 17 00:00:00 2001 From: declandarcy Date: Wed, 18 Nov 2026 13:37:57 -0800 Subject: [PATCH 5/9] fix(server): held Claude steers stop at Stop and resend compacted notes A Stop that lands while one held steer is offered no longer lets the next one through: the release checks for Stop before taking each steer and leaves the rest for finalization to cancel. A held steer now picks its app notes when it is sent, so a note the compaction dropped from history is sent again instead of being recorded as delivered. Co-Authored-By: Claude Opus 5.5 --- .../Adapters/ClaudeAdapterV2.test.ts | 62 +++++++++++---- .../Adapters/ClaudeAdapterV2.ts | 76 +++++++++++-------- 2 files changed, 92 insertions(+), 46 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts index 0c086f20fbb00..50adc281d49c1 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts @@ -11055,14 +11055,18 @@ describe("ClaudeAdapterV2 background wake turns", () => { close: (sdkMessages) => Queue.shutdown(sdkMessages), }); const idAllocator = yield* IdAllocator.IdAllocatorV2; - const input = makeClaudeTestTurnInput({ - threadId: harness.threadId, - providerThread: harness.providerThread, - now: yield* DateTime.now, - attemptId: RunAttemptId.make(`claude-held-steer-${outcome}`), - text: "Keep orchestrating.", - attachments: [], - }); + const appContext = [{ key: "mcp_app_item-1", text: "Created Jira issue PROJ-42" }]; + const input = { + ...makeClaudeTestTurnInput({ + threadId: harness.threadId, + providerThread: harness.providerThread, + now: yield* DateTime.now, + attemptId: RunAttemptId.make(`claude-held-steer-${outcome}`), + text: "Keep orchestrating.", + attachments: [], + }), + appContext, + }; yield* harness.runtime.startTurn(input); const providerTurnId = idAllocator.derive.providerTurn({ driver: ClaudeAdapterV2.CLAUDE_PROVIDER, @@ -11090,6 +11094,7 @@ describe("ClaudeAdapterV2 background wake turns", () => { text: "Subagent finished.", attachments: [], }, + appContext, }); assert.lengthOf(harness.offeredMessages, 1); @@ -11144,10 +11149,10 @@ describe("ClaudeAdapterV2 background wake turns", () => { ); assert.lengthOf(harness.offeredMessages, 2); assert.equal(harness.offeredMessages[1]?.priority, "now"); - assert.include( - JSON.stringify(harness.offeredMessages[1]?.message.content), - "Subagent finished.", - ); + const sent = JSON.stringify(harness.offeredMessages[1]?.message.content); + assert.include(sent, "Subagent finished."); + // The boundary drops the root prompt's note from history; a failed compaction keeps it. + (outcome === "boundary" ? assert.include : assert.notInclude)(sent, "PROJ-42"); }).pipe( Effect.scoped, Effect.provide( @@ -11161,7 +11166,7 @@ describe("ClaudeAdapterV2 background wake turns", () => { ), ); - it.effect.each(["newer steer", "query close"] as const)( + it.effect.each(["newer steer", "stop", "query close"] as const)( "releases held steers in order and leaves none unreleased: %s mid-release", (outcome) => Effect.gen(function* () { @@ -11170,9 +11175,15 @@ describe("ClaudeAdapterV2 background wake turns", () => { const idAllocator = yield* IdAllocator.IdAllocatorV2; const sending = yield* Deferred.make(); const resume = yield* Deferred.make(); + const interrupting = yield* Deferred.make(); + const interrupted = yield* Deferred.make(); let closing = false; const harness = yield* makeWakeHarnessWithOptions({ close: (sdkMessages) => Queue.shutdown(sdkMessages), + // Holds Stop between marking the turn interrupted and the CLI confirming it. + interrupt: Deferred.succeed(interrupting, undefined).pipe( + Effect.andThen(Deferred.await(interrupted)), + ), // Pauses A mid-offer, then interrupts B as a closing query would. offer: (message) => { const text = JSON.stringify(message.message.content); @@ -11268,6 +11279,31 @@ describe("ClaudeAdapterV2 background wake turns", () => { return; } + if (outcome === "stop") { + const stopping = yield* harness.runtime + .interruptTurn({ providerThread: harness.providerThread, providerTurnId }) + .pipe(Effect.forkScoped); + yield* Deferred.await(interrupting); + yield* Deferred.succeed(resume, undefined); + yield* Fiber.join(releasing); + // B would reach the prompt queue after Stop and start a turn nobody asked for. + assert.lengthOf(harness.offeredMessages, 2); + yield* Deferred.succeed(interrupted, undefined); + yield* Fiber.join(stopping); + assert.equal((yield* Queue.take(harness.terminalReceipts)).status, "interrupted"); + assert.include( + harness.events.flatMap((event) => + event.type === "turn_item.updated" && + event.turnItem.type === "system_notice" && + event.turnItem.title === "Steer not sent" + ? [event.turnItem.message] + : [], + )[0], + "Steer B.", + ); + return; + } + // The query closes while B is offered, which interrupts the release mid-drain. closing = true; yield* Deferred.succeed(resume, undefined); diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index 05b83edbf8b9b..b0ec5c8a24d1d 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -9250,18 +9250,25 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( }); // Taking the next steer and clearing the flag happen together, so none is left behind. - const takeHeldSteer = (context: ActiveClaudeTurnContext) => { - const next = context.steersClosed ? undefined : context.heldSteers.shift(); - context.releasingHeldSteers = next !== undefined; - return next; - }; + // After Stop the rest stay held for finalization to cancel. + const takeHeldSteer = (context: ActiveClaudeTurnContext) => + Ref.get(interruptedTurns).pipe( + Effect.map((interrupted) => { + const next = + context.steersClosed || interrupted.has(context.providerTurnId) + ? undefined + : context.heldSteers.shift(); + context.releasingHeldSteers = next !== undefined; + return next; + }), + ); const offerHeldSteers = Effect.fnUntraced(function* (context: ActiveClaudeTurnContext) { if (context.releasingHeldSteers) return; for ( - let next = takeHeldSteer(context); + let next = yield* takeHeldSteer(context); next !== undefined; - next = takeHeldSteer(context) + next = yield* takeHeldSteer(context) ) { const { uuid, offer } = next; yield* offer.pipe( @@ -13886,27 +13893,6 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.provideService(Path.Path, path), ); - // Notes this turn's prompt or an earlier steer already carried are not sent again. - const appContext = turnInput.appContext ?? []; - const seenAppContext = - currentTurn.appContextOffered ?? deliveredAppContext.get(existing.nativeThreadId); - const userMessage = withClaudeAppContext( - steerMessage, - appContext.filter((entry) => seenAppContext?.get(entry.key) !== entry.text), - pdfReservation, - ); - // `offer` may call this twice; a second call must not restore notes compaction cleared. - let offerCommitted = false; - const commitOffer = () => { - if (offerCommitted) return; - offerCommitted = true; - pdfReservation.commit(); - if (userMessage !== steerMessage) { - currentTurn.appContextOffered = new Map( - appContext.map((entry) => [entry.key, entry.text]), - ); - } - }; yield* backgroundForegroundSubagents(existing, backgroundDeadline); if (liveSteerSelection !== undefined) { yield* applySelectionLive(existing, liveSteerSelection); @@ -13925,11 +13911,35 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( detail: `Claude provider turn ${turnInput.providerTurnId} ended before the steer was sent.`, }); } - const offer = Effect.uninterruptibleMask((restore) => - restore(existing.query.offer(userMessage, commitOffer)).pipe( - Effect.tap(() => Effect.sync(commitOffer)), - ), - ); + // Notes this turn's prompt or an earlier steer already carried are not sent again. + // A held steer checks when it is sent, since compaction forgets what was carried. + const appContext = turnInput.appContext ?? []; + const offer = Effect.suspend(() => { + const seenAppContext = + currentTurn.appContextOffered ?? deliveredAppContext.get(existing.nativeThreadId); + const userMessage = withClaudeAppContext( + steerMessage, + appContext.filter((entry) => seenAppContext?.get(entry.key) !== entry.text), + pdfReservation, + ); + // `offer` may call this twice; a second call must not restore notes compaction cleared. + let offerCommitted = false; + const commitOffer = () => { + if (offerCommitted) return; + offerCommitted = true; + pdfReservation.commit(); + if (userMessage !== steerMessage) { + currentTurn.appContextOffered = new Map( + appContext.map((entry) => [entry.key, entry.text]), + ); + } + }; + return Effect.uninterruptibleMask((restore) => + restore(existing.query.offer(userMessage, commitOffer)).pipe( + Effect.tap(() => Effect.sync(commitOffer)), + ), + ); + }); // Register before offering: Claude can start the steer and end the turn before offer returns. const messageId = turnInput.message.messageId; currentTurn.steerUuids.add(steerUuid); From 05fa8d1c00f0f1d1950c38cd4656c3a8c6693a6f Mon Sep 17 00:00:00 2001 From: declandarcy Date: Wed, 18 Nov 2026 15:30:39 -0800 Subject: [PATCH 6/9] fix(server): a held Claude steer is acknowledged only once Claude has it A steer held during compaction made its effect succeed at once, so a delegated completion was marked delivered before Claude received it, and a steer whose turn ended first was dropped. steerTurn now hands back the held steer's delivery. The effect worker settles it when the steer is sent or declined, reusing the existing acceptance and follow-up paths, so the thread's Stop is still not blocked. A declined steer waits for its run to settle and comes back as a follow-up; when Stop reached the run, the orchestrator marks it cancelled and posts a "Steer not sent" notice. Fixes #25796 Co-Authored-By: Claude Opus 5.5 --- .../Adapters/ClaudeAdapterV2.test.ts | 80 ++++++--- .../Adapters/ClaudeAdapterV2.ts | 160 +++++++++++------- .../src/orchestration-v2/EffectWorker.ts | 91 ++++++---- .../src/orchestration-v2/Orchestrator.ts | 67 +++++++- .../ProviderTurnControlService.ts | 107 ++++++++---- .../SteeringCompletion.integration.test.ts | 97 +++++++++++ docs/user/providers-claude.md | 4 +- .../src/server/ProviderAdapter.ts | 10 +- 8 files changed, 458 insertions(+), 158 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts index 50adc281d49c1..5634745a699cc 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts @@ -3706,9 +3706,11 @@ describe("ClaudeAdapterV2 background wake turns", () => { processQueues.push(sdkMessages); return { messages, - offer: (message) => + // Like the real runner, reports the message queued before the rest of the write. + offer: (message, onQueued) => Effect.sync(() => { offeredMessages.push(message); + onQueued?.(); }).pipe( Effect.andThen(changes.notify), Effect.andThen(options?.offer?.(message) ?? Effect.void), @@ -11082,7 +11084,7 @@ describe("ClaudeAdapterV2 background wake turns", () => { }), ); // A "now" steer would abort the compaction, so it waits without blocking Stop. - yield* harness.runtime.steerTurn({ + const held = yield* harness.runtime.steerTurn({ threadId: harness.threadId, runId: input.runId, providerThread: harness.providerThread, @@ -11097,6 +11099,10 @@ describe("ClaudeAdapterV2 background wake turns", () => { appContext, }); assert.lengthOf(harness.offeredMessages, 1); + assert.isDefined(held); + const delivery = yield* held!.delivered.pipe(Effect.exit, Effect.forkScoped); + const steerStatuses = () => + harness.events.flatMap((event) => (event.type === "steer.updated" ? [event.status] : [])); if (outcome === "interrupt" || outcome === "query exit") { if (outcome === "interrupt") { @@ -11112,20 +11118,22 @@ describe("ClaudeAdapterV2 background wake turns", () => { outcome === "interrupt" ? "interrupted" : "failed", ); assert.lengthOf(harness.offeredMessages, 1); - assert.deepEqual( - harness.events.flatMap((event) => - event.type === "steer.updated" ? [event.status] : [], - ), - ["pending", "cancelled"], - ); - const notices = harness.events.flatMap((event) => - event.type === "turn_item.updated" && event.turnItem.type === "system_notice" - ? [event.turnItem] - : [], - ); - const notice = notices.find((item) => item.message?.includes("Subagent finished.")); - assert.equal(notice?.title, "Steer not sent"); - assert.notInclude(notice?.message ?? "", "Stop"); + // Declined, it comes back as a follow-up, or the orchestrator reports it after Stop. + const exit = yield* Fiber.join(delivery); + const failure = Exit.isFailure(exit) + ? Option.getOrUndefined(Cause.findErrorOption(exit.cause)) + : undefined; + assert.equal(failure?._tag, "ProviderAdapterSteerDeclinedError"); + const notice = harness.events + .flatMap((event) => + event.type === "turn_item.updated" && event.turnItem.type === "system_notice" + ? [event.turnItem] + : [], + ) + .find((item) => item.message?.includes("Subagent finished.")); + // Pending while held; a declined hold leaves its outcome to the follow-up or Stop. + assert.deepEqual(steerStatuses(), ["pending"]); + assert.isUndefined(notice); return; } yield* harness.offerAndWait( @@ -11149,6 +11157,7 @@ describe("ClaudeAdapterV2 background wake turns", () => { ); assert.lengthOf(harness.offeredMessages, 2); assert.equal(harness.offeredMessages[1]?.priority, "now"); + assert.isTrue(Exit.isSuccess(yield* Fiber.join(delivery))); const sent = JSON.stringify(harness.offeredMessages[1]?.message.content); assert.include(sent, "Subagent finished."); // The boundary drops the root prompt's note from history; a failed compaction keeps it. @@ -11249,9 +11258,24 @@ describe("ClaudeAdapterV2 background wake turns", () => { session_id: WAKE_NATIVE_SESSION, }), ); - yield* steer("A"); - yield* steer("B"); - if (outcome === "query close") yield* steer("C", [document]); + const hold = (name: string, attachments: ReadonlyArray = []) => + steer(name, attachments).pipe( + Effect.flatMap((held) => { + assert.isDefined(held); + return held!.delivered.pipe(Effect.exit, Effect.forkScoped); + }), + ); + const outcomeOf = Effect.fnUntraced(function* ( + delivery: Fiber.Fiber>, + ) { + const exit = yield* Fiber.join(delivery); + return Exit.isSuccess(exit) + ? "delivered" + : Option.getOrUndefined(Cause.findErrorOption(exit.cause))?._tag; + }); + const heldA = yield* hold("A"); + const heldB = yield* hold("B"); + const heldC = outcome === "query close" ? yield* hold("C", [document]) : undefined; const releasing = yield* harness .offerAndWait( claudeSdkFrame({ @@ -11291,15 +11315,9 @@ describe("ClaudeAdapterV2 background wake turns", () => { yield* Deferred.succeed(interrupted, undefined); yield* Fiber.join(stopping); assert.equal((yield* Queue.take(harness.terminalReceipts)).status, "interrupted"); - assert.include( - harness.events.flatMap((event) => - event.type === "turn_item.updated" && - event.turnItem.type === "system_notice" && - event.turnItem.title === "Steer not sent" - ? [event.turnItem.message] - : [], - )[0], - "Steer B.", + assert.deepEqual( + [yield* outcomeOf(heldA), yield* outcomeOf(heldB)], + ["delivered", "ProviderAdapterSteerDeclinedError"], ); return; } @@ -11308,6 +11326,12 @@ describe("ClaudeAdapterV2 background wake turns", () => { closing = true; yield* Deferred.succeed(resume, undefined); yield* Queue.take(harness.terminalReceipts); + // B was already in Claude's queue when the close cut its offer short: declining it + // would send it twice. C never left the hold. + assert.deepEqual( + [yield* outcomeOf(heldA), yield* outcomeOf(heldB), yield* outcomeOf(heldC!)], + ["delivered", "delivered", "ProviderAdapterSteerDeclinedError"], + ); // The undelivered PDF's pages are free again, so a new turn can send it natively. const before = harness.offeredMessages.length; yield* harness.runtime.startTurn( diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index b0ec5c8a24d1d..0b5b559c25477 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -5100,11 +5100,14 @@ interface ActiveClaudeTurnContext { readonly steerUuids: Set; // A "now" steer aborts a running compaction, which Claude then restarts, so steers that // arrive mid-compaction wait here, also in pendingSteers, until it settles. Finalization - // releases what is still here; an entry taken for offering releases itself. + // releases and declines what is still here; an entry taken for offering releases itself. readonly heldSteers: Array<{ readonly uuid: string; readonly offer: Effect.Effect; readonly release: Effect.Effect; + readonly delivered: Deferred.Deferred; + // True once Claude's prompt queue holds it, even if the offer is then cut short. + readonly queued: () => boolean; }>; // Set while held steers are offered, so later steers queue behind them. releasingHeldSteers: boolean; @@ -9270,15 +9273,23 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( next !== undefined; next = yield* takeHeldSteer(context) ) { - const { uuid, offer } = next; - yield* offer.pipe( + const { uuid, offer, delivered, queued } = next; + const steer = context.pendingSteers.get(uuid); + // A queued steer is Claude's; only one never queued may be declined and sent again. + yield* Effect.uninterruptibleMask((restore) => + restore(offer).pipe(Effect.andThen(Deferred.succeed(delivered, undefined))), + ).pipe( Effect.onInterrupt(() => - Effect.sync(() => { + Effect.suspend(() => { context.releasingHeldSteers = false; + if (queued()) return Deferred.succeed(delivered, undefined); + // The query is closing; finalization declines it with the rest. + context.heldSteers.unshift(next); + return Effect.void; }), ), Effect.catch((cause) => { - const steer = context.pendingSteers.get(uuid); + if (queued()) return Deferred.succeed(delivered, undefined); context.pendingSteers.delete(uuid); return Effect.logWarning("orchestration-v2.claude-held-steer-offer-failed", { cause, @@ -9288,6 +9299,17 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( ? Effect.void : emitSteerStatus(context, steer.messageId, "cancelled"), ), + Effect.andThen( + Deferred.fail( + delivered, + new ProviderAdapter.ProviderAdapterSteerRunError({ + driver: CLAUDE_PROVIDER, + providerThreadId: context.input.providerThread.id, + providerTurnId: context.providerTurnId, + cause, + }), + ), + ), ); }), ); @@ -9322,16 +9344,30 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( deliveredAppContext.set(input.context.nativeThreadId, input.context.appContextOffered); } // A turn that completes has taken in every offered steer; one that stops drops them unread. + // Held steers were never sent: declined, they come back as follow-ups, which the + // orchestrator reports instead when Stop reached the run. const heldSteers = input.context.heldSteers.splice(0); const heldSteerUuids = new Set(heldSteers.map((steer) => steer.uuid)); - for (const steer of heldSteers) yield* steer.release; - const droppedSteers = [...input.context.pendingSteers]; + for (const steer of heldSteers) { + yield* steer.release; + yield* Deferred.fail( + steer.delivered, + new ProviderAdapter.ProviderAdapterSteerDeclinedError({ + driver: CLAUDE_PROVIDER, + providerThreadId: input.context.input.providerThread.id, + providerTurnId: input.context.providerTurnId, + }), + ); + } + const droppedSteers = [...input.context.pendingSteers].filter( + ([uuid]) => !heldSteerUuids.has(uuid), + ); input.context.pendingSteers.clear(); - for (const [uuid, { messageId }] of droppedSteers) { + for (const [, { messageId }] of droppedSteers) { yield* emitSteerStatus( input.context, messageId, - input.status === "completed" && !heldSteerUuids.has(uuid) ? "completed" : "cancelled", + input.status === "completed" ? "completed" : "cancelled", ); } if (input.context.compaction?.status === "running") { @@ -9471,51 +9507,47 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( }); } - for (const [uuid, { text, liveQuery }] of droppedSteers) { - const held = heldSteerUuids.has(uuid); - // A held steer was never sent, whatever ended the turn. An offered one can be unread - // only after Stop, and only a CLI proven to echo prompt uuids can show it. - if ( - !held && - (input.status !== "interrupted" || - (liveQuery.promptEchoMode !== "early" && - liveQuery.promptEchoMode !== "result_only")) - ) { - continue; - } - const nativeItemId = `unread-steer:${uuid}`; - const notice = held - ? `The turn ended while Claude was compacting, so this steer was not sent. Resend it if needed: "${text}"` - : `Claude did not confirm reading your steer before Stop. It may not have been delivered. Resend it if needed: "${text}"`; - yield* emitProviderEvent({ - type: "turn_item.updated", - driver: CLAUDE_PROVIDER, - turnItem: { - id: idAllocator.derive.turnItemFromProviderItem({ - driver: CLAUDE_PROVIDER, - nativeItemId, - }), - threadId: input.context.input.threadId, - runId: input.context.input.runId, - nodeId: input.context.input.rootNodeId, - providerThreadId: input.context.input.providerThread.id, - providerTurnId: input.context.providerTurnId, - nativeItemRef: { - driver: CLAUDE_PROVIDER, - nativeId: nativeItemId, - strength: "weak", + if (input.status === "interrupted") { + for (const [uuid, { text, liveQuery }] of droppedSteers) { + // Only a CLI proven to echo prompt uuids can leave a steer unconfirmed. + if ( + liveQuery.promptEchoMode !== "early" && + liveQuery.promptEchoMode !== "result_only" + ) { + continue; + } + const nativeItemId = `unread-steer:${uuid}`; + const notice = `Claude did not confirm reading your steer before Stop. It may not have been delivered. Resend it if needed: "${text}"`; + yield* emitProviderEvent({ + type: "turn_item.updated", + driver: CLAUDE_PROVIDER, + turnItem: { + id: idAllocator.derive.turnItemFromProviderItem({ + driver: CLAUDE_PROVIDER, + nativeItemId, + }), + threadId: input.context.input.threadId, + runId: input.context.input.runId, + nodeId: input.context.input.rootNodeId, + providerThreadId: input.context.input.providerThread.id, + providerTurnId: input.context.providerTurnId, + nativeItemRef: { + driver: CLAUDE_PROVIDER, + nativeId: nativeItemId, + strength: "weak", + }, + parentItemId: null, + ordinal: yield* resolveItemOrdinal(input.context, nativeItemId), + type: "system_notice", + status: "completed", + title: "Steer delivery not confirmed", + message: notice, + startedAt: input.completedAt, + completedAt: input.completedAt, + updatedAt: input.completedAt, }, - parentItemId: null, - ordinal: yield* resolveItemOrdinal(input.context, nativeItemId), - type: "system_notice", - status: "completed", - title: held ? "Steer not sent" : "Steer delivery not confirmed", - message: notice, - startedAt: input.completedAt, - completedAt: input.completedAt, - updatedAt: input.completedAt, - }, - }); + }); + } } const threadDisposition = input.threadDisposition ?? "reusable"; @@ -13914,6 +13946,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( // Notes this turn's prompt or an earlier steer already carried are not sent again. // A held steer checks when it is sent, since compaction forgets what was carried. const appContext = turnInput.appContext ?? []; + let queued = false; const offer = Effect.suspend(() => { const seenAppContext = currentTurn.appContextOffered ?? deliveredAppContext.get(existing.nativeThreadId); @@ -13927,6 +13960,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( const commitOffer = () => { if (offerCommitted) return; offerCommitted = true; + queued = true; pdfReservation.commit(); if (userMessage !== steerMessage) { currentTurn.appContextOffered = new Map( @@ -13948,23 +13982,29 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( text: turnInput.message.text, liveQuery: existing, }); + yield* Ref.update(steeredTurns, (current) => { + const next = new Set(current); + next.add(turnInput.providerTurnId); + return next; + }); + yield* emitSteerStatus(currentTurn, messageId, "pending"); // Returns without waiting: a running steer effect would block this thread's Stop. if (currentTurn.compaction?.status === "running" || currentTurn.releasingHeldSteers) { held = true; const release = Scope.close(reservationScope, Exit.void); + const delivered = yield* Deferred.make< + void, + ProviderAdapter.ProviderAdapterV2Error + >(); currentTurn.heldSteers.push({ uuid: steerUuid, offer: offer.pipe(Effect.ensuring(release)), release, + delivered, + queued: () => queued, }); + return { delivered: Deferred.await(delivered) }; } - yield* Ref.update(steeredTurns, (current) => { - const next = new Set(current); - next.add(turnInput.providerTurnId); - return next; - }); - yield* emitSteerStatus(currentTurn, messageId, "pending"); - if (held) return; yield* offer.pipe( Effect.onError(() => currentTurn.pendingSteers.delete(steerUuid) diff --git a/apps/server/src/orchestration-v2/EffectWorker.ts b/apps/server/src/orchestration-v2/EffectWorker.ts index c6aa09efd5e69..446db2bbb7a37 100644 --- a/apps/server/src/orchestration-v2/EffectWorker.ts +++ b/apps/server/src/orchestration-v2/EffectWorker.ts @@ -117,6 +117,7 @@ export const layerExecutor: Layer.Layer< const threads = yield* ThreadManagementService.ThreadManagementService; const projectionStore = yield* ProjectionStore.ProjectionStoreV2; const settings = yield* ServerSettings.ServerSettingsService; + const scope = yield* Effect.scope; const startRun = ( effect: EffectOutbox.OrchestrationEffectV2, runId: RunId, @@ -326,37 +327,51 @@ export const layerExecutor: Layer.Layer< ), ); } - case "provider-turn.steer": - return providerTurnControl - .steer({ - threadId: effect.threadId, - providerSessionId: effect.request.providerSessionId, - providerThreadId: effect.request.providerThreadId, - providerTurnId: effect.request.providerTurnId, - messageId: effect.request.messageId, - ...(effect.request.modelSelection === undefined - ? {} - : { modelSelection: effect.request.modelSelection }), - }) - .pipe( - Effect.tap(() => - Effect.gen(function* () { - if (effect.request.type !== "provider-turn.steer") return; - const messageId = effect.request.messageId; - const projection = yield* threads.getThreadRecords( - effect.threadId, - ["messages", "runs"], - { messageIds: [effect.request.messageId] }, - ); - const message = projection.messages.find((row) => row.id === messageId); - if (message?.delegatedCompletion === undefined) return; - yield* threads.dispatch({ - type: "notification.delivery.accept", - commandId: CommandId.make(`command:mailbox-accepted:${effect.id}`), - threadId: effect.threadId, - messageId: message.id, - }); - }), + case "provider-turn.steer": { + const settleSteer = ( + sent: Effect.Effect< + Effect.Success>, + ProviderTurnControlService.ProviderTurnControlError + >, + ): Effect.Effect => + sent.pipe( + Effect.tap((held) => + held !== undefined + ? // Returning frees this thread's later effects, such as Stop, while the + // provider holds the steer; its delivery settles the message afterwards. + settleSteer(held.delivered).pipe( + // No outbox row retries this, so retry what was not the provider's answer. + Effect.retry({ + while: (error) => !isProviderTurnControlError(error.cause), + schedule: Schedule.exponential("1 second"), + times: 4, + }), + Effect.catchCause((cause) => + Effect.logWarning( + "orchestration-v2.effect-worker.held-steer-settle-failed", + { effectId: effect.id }, + cause, + ), + ), + Effect.forkIn(scope), + ) + : Effect.gen(function* () { + if (effect.request.type !== "provider-turn.steer") return; + const messageId = effect.request.messageId; + const projection = yield* threads.getThreadRecords( + effect.threadId, + ["messages", "runs"], + { messageIds: [effect.request.messageId] }, + ); + const message = projection.messages.find((row) => row.id === messageId); + if (message?.delegatedCompletion === undefined) return; + yield* threads.dispatch({ + type: "notification.delivery.accept", + commandId: CommandId.make(`command:mailbox-accepted:${effect.id}`), + threadId: effect.threadId, + messageId: message.id, + }); + }), ), Effect.catch((error) => Effect.gen(function* () { @@ -450,7 +465,21 @@ export const layerExecutor: Layer.Layer< cause, }), ), + Effect.asVoid, ); + return settleSteer( + providerTurnControl.steer({ + threadId: effect.threadId, + providerSessionId: effect.request.providerSessionId, + providerThreadId: effect.request.providerThreadId, + providerTurnId: effect.request.providerTurnId, + messageId: effect.request.messageId, + ...(effect.request.modelSelection === undefined + ? {} + : { modelSelection: effect.request.modelSelection }), + }), + ); + } case "provider-turn.restart": return providerTurnControl .interruptAndAwaitTerminal({ diff --git a/apps/server/src/orchestration-v2/Orchestrator.ts b/apps/server/src/orchestration-v2/Orchestrator.ts index 6b1fe8567b8e6..c393413453f51 100644 --- a/apps/server/src/orchestration-v2/Orchestrator.ts +++ b/apps/server/src/orchestration-v2/Orchestrator.ts @@ -6844,23 +6844,74 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio ); if (command.steerFollowUpOfRunId !== undefined) { const source = projection.runs.find((run) => run.id === command.steerFollowUpOfRunId); - if ( + const message = projection.messages.find( + (candidate) => candidate.id === command.messageId && candidate.runId === source?.id, + ); + const discarded = source === undefined || command.dispatchMode.type !== "queue_after_active" || - !projection.messages.some( - (message) => message.id === command.messageId && message.runId === source.id, - ) || + message === undefined || projection.thread.archivedAt !== null || - projection.thread.deletedAt !== null || - (yield* stopReachedRun(command, command.threadId, source.id)) - ) { + projection.thread.deletedAt !== null; + if (discarded || (yield* stopReachedRun(command, command.threadId, source.id))) { + const now = yield* DateTime.now; + // The provider never took this steer and Stop cancels it, so say so where it was sent. + if (!discarded && source.rootNodeId !== null) { + const emitEvent = emit(events, command); + const item = projection.turnItems.find( + (candidate) => + candidate.id === idAllocator.derive.userTurnItem({ messageId: message.id }), + ); + if (item?.type === "user_message" && item.status !== "cancelled") { + yield* emitEvent({ + type: "turn-item.updated", + threadId: command.threadId, + runId: source.id, + nodeId: source.rootNodeId, + providerInstanceId: source.providerInstanceId, + occurredAt: now, + payload: { ...item, status: "cancelled", updatedAt: now }, + }); + } + if (message.delegatedCompletion === undefined && message.notification === undefined) { + yield* emitEvent({ + type: "turn-item.updated", + threadId: command.threadId, + runId: source.id, + nodeId: source.rootNodeId, + providerInstanceId: source.providerInstanceId, + occurredAt: now, + payload: { + id: idAllocator.derive.runSignalTurnItem({ + runId: source.id, + signal: `unsent-steer:${message.id}`, + }), + threadId: command.threadId, + runId: source.id, + nodeId: source.rootNodeId, + providerThreadId: source.providerThreadId, + providerTurnId: null, + nativeItemRef: null, + parentItemId: null, + ordinal: yield* nextTurnItemOrdinal(projection), + status: "completed", + title: "Steer not sent", + startedAt: now, + completedAt: now, + updatedAt: now, + type: "system_notice", + message: `The turn stopped before this steer was sent. Resend it if needed: "${message.text}"`, + }, + }); + } + } yield* emit( events, command, )({ type: "thread.metadata-updated", threadId: command.threadId, - occurredAt: yield* DateTime.now, + occurredAt: now, payload: projection.thread, }); return; diff --git a/apps/server/src/orchestration-v2/ProviderTurnControlService.ts b/apps/server/src/orchestration-v2/ProviderTurnControlService.ts index 25df164788e76..fd4985f28768d 100644 --- a/apps/server/src/orchestration-v2/ProviderTurnControlService.ts +++ b/apps/server/src/orchestration-v2/ProviderTurnControlService.ts @@ -14,6 +14,7 @@ import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; +import * as Schedule from "effect/Schedule"; import * as Schema from "effect/Schema"; import * as Stream from "effect/Stream"; @@ -72,7 +73,10 @@ export interface ProviderTurnControlServiceV2Shape { readonly providerTurnId: ProviderTurnId; readonly messageId: MessageId; readonly modelSelection?: ModelSelection; - }) => Effect.Effect; + }) => Effect.Effect< + void | { readonly delivered: Effect.Effect }, + ProviderTurnControlError + >; /** Best effort: a turn that ended or moved sessions picks the selection up when it next starts. */ readonly applyModelSelection: (input: { readonly threadId: ThreadId; @@ -451,34 +455,11 @@ export const layer: Layer.Layer< mcpAppModelContext, input.threadId, ); - yield* loaded.session.value - .steerTurn({ - threadId: input.threadId, - runId: run.id, - providerThread: loaded.providerThread, - providerTurnId: loaded.providerTurn.id, - ...(input.modelSelection === undefined - ? {} - : { modelSelection: input.modelSelection }), - ...(appContext.length === 0 ? {} : { appContext }), - message: { - messageId: message.id, - text: projectComposerContextForProvider({ - text: message.text, - records: message.context?.records ?? [], - }), - attachments: message.attachments, - createdBy: message.createdBy, - creationSource: message.creationSource, - ...(message.scheduledTaskId === undefined - ? {} - : { scheduledTaskId: message.scheduledTaskId }), - ...(message.senderThreadId === undefined - ? {} - : { senderThreadId: message.senderThreadId }), - }, - }) - .pipe( + // A held steer's later delivery fails the same ways an immediate one does. + const asControlError = ( + steer: Effect.Effect, + ) => + steer.pipe( Effect.catchTags({ ProviderAdapterSteerDeclinedError: (cause) => Effect.fail( @@ -508,7 +489,75 @@ export const layer: Layer.Layer< }); }), ), + Effect.mapError((cause) => + isProviderTurnControlError(cause) + ? cause + : new ProviderTurnControlError({ + threadId: input.threadId, + operation: "steer", + providerTurnId: input.providerTurnId, + cause, + }), + ), ); + const held = yield* asControlError( + loaded.session.value.steerTurn({ + threadId: input.threadId, + runId: run.id, + providerThread: loaded.providerThread, + providerTurnId: loaded.providerTurn.id, + ...(input.modelSelection === undefined + ? {} + : { modelSelection: input.modelSelection }), + ...(appContext.length === 0 ? {} : { appContext }), + message: { + messageId: message.id, + text: projectComposerContextForProvider({ + text: message.text, + records: message.context?.records ?? [], + }), + attachments: message.attachments, + createdBy: message.createdBy, + creationSource: message.creationSource, + ...(message.scheduledTaskId === undefined + ? {} + : { scheduledTaskId: message.scheduledTaskId }), + ...(message.senderThreadId === undefined + ? {} + : { senderThreadId: message.senderThreadId }), + }, + }), + ); + if (held === undefined) return; + // A held steer is declined as its turn ends; its follow-up needs that end persisted. + return { + delivered: asControlError(held.delivered).pipe( + Effect.catchIf( + (error) => error.steerDeclined === true, + (error) => + // The run must settle too: a mailbox follow-up is refused while it still runs. + awaitSettled(input.threadId, { + ...input, + ...(loaded.providerTurn.runAttemptId === null + ? {} + : { attemptId: loaded.providerTurn.runAttemptId }), + }).pipe( + // Only the provider's answer is final; a failed read is retried here. + Effect.retry({ schedule: Schedule.exponential("1 second"), times: 4 }), + Effect.mapError( + (cause) => + new ProviderTurnControlError({ + threadId: input.threadId, + operation: "steer", + providerTurnId: input.providerTurnId, + cause, + }), + ), + Effect.andThen(Effect.fail(error)), + ), + ), + ), + }; }, (effect, input) => effect.pipe( diff --git a/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts b/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts index 11b36aeb148eb..5078dc910d131 100644 --- a/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts +++ b/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts @@ -39,6 +39,7 @@ import * as SqlitePersistence from "../persistence/Sqlite.ts"; import * as CommandReceiptStore from "./CommandReceiptStore.ts"; import { checkpointWorkspace } from "@t3tools/provider-testing/replayWorkspace"; import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; +import { makeProviderFailure } from "@t3tools/provider-core/server/failure"; import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests"; const driver = ProviderDriverKind.make("codex"); @@ -54,6 +55,8 @@ it.effect.each( [true, "without native steering"], [true, "with interrupting native steering"], [true, "settled only"], + [true, "while held"], + [true, "while held through a failure"], [false, "during continuation"], ["question", "during delivery"], ] as const @@ -151,6 +154,22 @@ it.effect.each( Effect.gen(function* () { steerCalls += 1; if (timing === "after delivery" || timing === "during continuation") return; + // Held like a steer that waits out a compaction, then declined when the turn ends. + if (timing === "while held" || timing === "while held through a failure") { + return { + delivered: Deferred.await(rejectSteer).pipe( + Effect.andThen( + Effect.fail( + new ProviderAdapter.ProviderAdapterSteerDeclinedError({ + driver, + providerThreadId: turn.providerThread.id, + providerTurnId: turn.providerTurnId, + }), + ), + ), + ), + }; + } yield* Deferred.succeed(steerEntered, undefined); yield* Deferred.await(rejectSteer); return yield* new ProviderAdapter.ProviderAdapterSteerRunError({ @@ -324,6 +343,72 @@ it.effect.each( : {}), }); if (timing !== "before dispatch") yield* dispatchSteer; + if (timing === "while held" || timing === "while held through a failure") { + const failed = timing === "while held through a failure"; + // Subscribed before the worker runs: the follow-up commits as soon as the hold ends. + const followUp = yield* watch( + (event) => + event.type === "message.updated" && + event.payload.id === messageId && + event.payload.runId !== first.runId, + ); + yield* worker.drain(); + assert.equal(steerCalls, 1); + const holding = yield* orchestrator.getThreadProjection(threadId); + assert.equal(holding.subagents[0]?.completionDelivery?.state, "claimed"); + const turn = holding.providerTurns[0]!; + const status = failed ? "failed" : "completed"; + // Declined as the turn ends: before anything is persisted, or once a failed turn is + // persisted but its run has not settled yet. + if (!failed) yield* Deferred.succeed(rejectSteer, undefined); + const turnEnded = yield* watch( + (event) => event.type === "provider-turn.updated" && event.payload.status === status, + ); + const runSettled = yield* watch( + (event) => + event.type === "run.updated" && + event.payload.id === first.runId && + event.payload.status === (failed ? "failed" : "waiting"), + ); + yield* Queue.offer(events, { + type: "provider_turn.updated", + driver, + providerTurn: { ...turn, status, completedAt: yield* DateTime.now }, + }); + yield* Fiber.join(turnEnded); + if (failed) yield* Deferred.succeed(rejectSteer, undefined); + const ended = { + type: "turn.terminal", + driver, + providerThreadId: turn.providerThreadId, + providerTurnId: turn.id, + runOrdinal: first.runOrdinal, + threadDisposition: "reusable", + } as const; + yield* Queue.offer( + events, + failed + ? { + ...ended, + status: "failed", + failureItemOrdinal: 100, + failure: makeProviderFailure({ + message: "Claude exited.", + class: "transport_error", + }), + } + : { ...ended, status: "completed", failure: null }, + ); + yield* Fiber.join(runSettled); + yield* Fiber.join(followUp); + yield* worker.drain(); + yield* orchestrator.resumeQueuedRuns; + yield* worker.drain(); + assert.lengthOf(started, 2); + assert.equal(started[1]?.message.messageId, messageId); + assert.include(started[1]?.message.text ?? "", String(taskId)); + return; + } if (timing === "during continuation") { const projection = yield* orchestrator.getThreadProjection(threadId); const turn = projection.providerTurns[0]!; @@ -1549,6 +1634,18 @@ it.effect.each(declinedSteerTimings)( assert.equal(started.length, 1); if (timing === "stop-before-decline") { assert.isUndefined(queued); + // Stop cancelled a steer the provider never took; the thread says so. + assert.equal( + pending.turnItems.find( + (item) => item.type === "user_message" && item.messageId === messageId, + )?.status, + "cancelled", + ); + const notice = pending.turnItems.find( + (item) => item.type === "system_notice" && item.runId === first.runId, + ); + assert.equal(notice?.title, "Steer not sent"); + assert.include(notice?.type === "system_notice" ? notice.message : "", "follow up"); return; } assert.equal(queued?.status, "queued"); diff --git a/docs/user/providers-claude.md b/docs/user/providers-claude.md index 4094ef1ed8a44..9c73175d0f9f2 100644 --- a/docs/user/providers-claude.md +++ b/docs/user/providers-claude.md @@ -57,7 +57,9 @@ window. Leave it empty for Claude Code's default. You can also send `/compact` in an existing conversation. Claude Code also compacts automatically. A message steered into a turn while Claude compacts -automatically waits for the compaction to finish, then reaches the same turn. +automatically waits for the compaction to finish, then reaches the same turn. If +the turn ends first, the message starts the next turn instead, unless you stopped +the turn. To see context usage, see [commands and skills](./composer.md#commands-and-skills). diff --git a/packages/provider-core/src/server/ProviderAdapter.ts b/packages/provider-core/src/server/ProviderAdapter.ts index 62fe110dd5245..65b04df8fa729 100644 --- a/packages/provider-core/src/server/ProviderAdapter.ts +++ b/packages/provider-core/src/server/ProviderAdapter.ts @@ -591,6 +591,14 @@ export interface ProviderAdapterV2SteerInput { readonly appContext?: ProviderAdapterV2TurnInput["appContext"]; } +/** + * A steer the provider holds to send later, such as while it compacts. `delivered` succeeds once + * the provider has it, and fails with `ProviderAdapterSteerDeclinedError` if its turn ends first. + */ +export interface ProviderAdapterV2HeldSteer { + readonly delivered: Effect.Effect; +} + export interface ProviderAdapterV2InterruptInput { readonly providerThread: OrchestrationV2ProviderThread; readonly providerTurnId: ProviderTurnId; @@ -754,7 +762,7 @@ export interface ProviderAdapterV2SessionRuntime { ) => Effect.Effect; readonly steerTurn: ( input: ProviderAdapterV2SteerInput, - ) => Effect.Effect; + ) => Effect.Effect; /** Applies a thread's new selection to its running process where the provider can; otherwise it waits for the next turn. */ readonly applyModelSelection?: (input: { readonly providerThread: OrchestrationV2ProviderThread; From bba8c3c62f856b5f49e0d0e36b8ad3a13cdad887 Mon Sep 17 00:00:00 2001 From: declandarcy Date: Wed, 18 Nov 2026 16:01:17 -0800 Subject: [PATCH 7/9] fix(server): held Claude steers wait for the compaction boundary A successful compaction reports success before its boundary, and only the boundary clears the app notes the summary dropped. Held steers released on success were filtered against the old records, so a note the root prompt carried was not sent again. They now wait for the boundary, or for the next other frame from a CLI that sends none. A steer that arrives while earlier ones are still held always joins them, so it cannot be sent first. Co-Authored-By: Claude Opus 5.5 --- .../Adapters/ClaudeAdapterV2.test.ts | 245 ++++++++++-------- .../Adapters/ClaudeAdapterV2.ts | 27 +- 2 files changed, 163 insertions(+), 109 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts index 5634745a699cc..af3a02c5761bb 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts @@ -11049,42 +11049,112 @@ describe("ClaudeAdapterV2 background wake turns", () => { ), ); - it.effect.each(["boundary", "failed", "interrupt", "query exit"] as const)( - "holds a steer until Claude's auto-compaction settles: %s", - (outcome) => - Effect.gen(function* () { - const harness = yield* makeWakeHarnessWithOptions({ - close: (sdkMessages) => Queue.shutdown(sdkMessages), - }); - const idAllocator = yield* IdAllocator.IdAllocatorV2; - const appContext = [{ key: "mcp_app_item-1", text: "Created Jira issue PROJ-42" }]; - const input = { - ...makeClaudeTestTurnInput({ - threadId: harness.threadId, + it.effect.each([ + "boundary", + "success then boundary", + "failed", + "interrupt", + "query exit", + ] as const)("holds a steer until Claude's auto-compaction settles: %s", (outcome) => + Effect.gen(function* () { + const harness = yield* makeWakeHarnessWithOptions({ + close: (sdkMessages) => Queue.shutdown(sdkMessages), + }); + const idAllocator = yield* IdAllocator.IdAllocatorV2; + const appContext = [{ key: "mcp_app_item-1", text: "Created Jira issue PROJ-42" }]; + const input = { + ...makeClaudeTestTurnInput({ + threadId: harness.threadId, + providerThread: harness.providerThread, + now: yield* DateTime.now, + attemptId: RunAttemptId.make(`claude-held-steer-${outcome}`), + text: "Keep orchestrating.", + attachments: [], + }), + appContext, + }; + yield* harness.runtime.startTurn(input); + const providerTurnId = idAllocator.derive.providerTurn({ + driver: ClaudeAdapterV2.CLAUDE_PROVIDER, + nativeTurnId: `turn:${input.attemptId}`, + }); + yield* harness.offerAndWait( + claudeSdkFrame({ + type: "system", + subtype: "status", + status: "compacting", + uuid: "00000000-0000-4000-8000-000000038701", + session_id: WAKE_NATIVE_SESSION, + }), + ); + // A "now" steer would abort the compaction, so it waits without blocking Stop. + const held = yield* harness.runtime.steerTurn({ + threadId: harness.threadId, + runId: input.runId, + providerThread: harness.providerThread, + providerTurnId, + message: { + createdBy: "agent", + creationSource: "mcp", + messageId: MessageId.make("held-steer"), + text: "Subagent finished.", + attachments: [], + }, + appContext, + }); + assert.lengthOf(harness.offeredMessages, 1); + assert.isDefined(held); + const delivery = yield* held!.delivered.pipe(Effect.exit, Effect.forkScoped); + const steerStatuses = () => + harness.events.flatMap((event) => (event.type === "steer.updated" ? [event.status] : [])); + + if (outcome === "interrupt" || outcome === "query exit") { + if (outcome === "interrupt") { + yield* harness.runtime.interruptTurn({ providerThread: harness.providerThread, - now: yield* DateTime.now, - attemptId: RunAttemptId.make(`claude-held-steer-${outcome}`), - text: "Keep orchestrating.", - attachments: [], - }), - appContext, - }; - yield* harness.runtime.startTurn(input); - const providerTurnId = idAllocator.derive.providerTurn({ - driver: ClaudeAdapterV2.CLAUDE_PROVIDER, - nativeTurnId: `turn:${input.attemptId}`, - }); + providerTurnId, + }); + } else { + yield* Queue.shutdown(harness.sdkMessages); + } + assert.equal( + (yield* Queue.take(harness.terminalReceipts)).status, + outcome === "interrupt" ? "interrupted" : "failed", + ); + assert.lengthOf(harness.offeredMessages, 1); + // Declined, it comes back as a follow-up, or the orchestrator reports it after Stop. + const exit = yield* Fiber.join(delivery); + const failure = Exit.isFailure(exit) + ? Option.getOrUndefined(Cause.findErrorOption(exit.cause)) + : undefined; + assert.equal(failure?._tag, "ProviderAdapterSteerDeclinedError"); + const notice = harness.events + .flatMap((event) => + event.type === "turn_item.updated" && event.turnItem.type === "system_notice" + ? [event.turnItem] + : [], + ) + .find((item) => item.message?.includes("Subagent finished.")); + // Pending while held; a declined hold leaves its outcome to the follow-up or Stop. + assert.deepEqual(steerStatuses(), ["pending"]); + assert.isUndefined(notice); + return; + } + const boundary = outcome === "boundary" || outcome === "success then boundary"; + if (outcome === "success then boundary") { yield* harness.offerAndWait( claudeSdkFrame({ type: "system", subtype: "status", - status: "compacting", - uuid: "00000000-0000-4000-8000-000000038701", + status: null, + compact_result: "success", + uuid: "00000000-0000-4000-8000-000000038703", session_id: WAKE_NATIVE_SESSION, }), ); - // A "now" steer would abort the compaction, so it waits without blocking Stop. - const held = yield* harness.runtime.steerTurn({ + // Still held until the boundary clears the notes history lost; a newer steer + // joins it rather than going first. + yield* harness.runtime.steerTurn({ threadId: harness.threadId, runId: input.runId, providerThread: harness.providerThread, @@ -11092,87 +11162,51 @@ describe("ClaudeAdapterV2 background wake turns", () => { message: { createdBy: "agent", creationSource: "mcp", - messageId: MessageId.make("held-steer"), - text: "Subagent finished.", + messageId: MessageId.make("held-steer-later"), + text: "Second subagent finished.", attachments: [], }, - appContext, }); assert.lengthOf(harness.offeredMessages, 1); - assert.isDefined(held); - const delivery = yield* held!.delivered.pipe(Effect.exit, Effect.forkScoped); - const steerStatuses = () => - harness.events.flatMap((event) => (event.type === "steer.updated" ? [event.status] : [])); - - if (outcome === "interrupt" || outcome === "query exit") { - if (outcome === "interrupt") { - yield* harness.runtime.interruptTurn({ - providerThread: harness.providerThread, - providerTurnId, - }); - } else { - yield* Queue.shutdown(harness.sdkMessages); - } - assert.equal( - (yield* Queue.take(harness.terminalReceipts)).status, - outcome === "interrupt" ? "interrupted" : "failed", - ); - assert.lengthOf(harness.offeredMessages, 1); - // Declined, it comes back as a follow-up, or the orchestrator reports it after Stop. - const exit = yield* Fiber.join(delivery); - const failure = Exit.isFailure(exit) - ? Option.getOrUndefined(Cause.findErrorOption(exit.cause)) - : undefined; - assert.equal(failure?._tag, "ProviderAdapterSteerDeclinedError"); - const notice = harness.events - .flatMap((event) => - event.type === "turn_item.updated" && event.turnItem.type === "system_notice" - ? [event.turnItem] - : [], - ) - .find((item) => item.message?.includes("Subagent finished.")); - // Pending while held; a declined hold leaves its outcome to the follow-up or Stop. - assert.deepEqual(steerStatuses(), ["pending"]); - assert.isUndefined(notice); - return; - } - yield* harness.offerAndWait( - outcome === "boundary" - ? claudeSdkFrame({ - type: "system", - subtype: "compact_boundary", - compact_metadata: { trigger: "auto", pre_tokens: 3000, post_tokens: 600 }, - uuid: "00000000-0000-4000-8000-000000038702", - session_id: WAKE_NATIVE_SESSION, - }) - : claudeSdkFrame({ - type: "system", - subtype: "status", - status: null, - compact_result: "failed", - compact_error: "Compaction failed.", - uuid: "00000000-0000-4000-8000-000000038702", - session_id: WAKE_NATIVE_SESSION, - }), - ); - assert.lengthOf(harness.offeredMessages, 2); - assert.equal(harness.offeredMessages[1]?.priority, "now"); - assert.isTrue(Exit.isSuccess(yield* Fiber.join(delivery))); - const sent = JSON.stringify(harness.offeredMessages[1]?.message.content); - assert.include(sent, "Subagent finished."); - // The boundary drops the root prompt's note from history; a failed compaction keeps it. - (outcome === "boundary" ? assert.include : assert.notInclude)(sent, "PROJ-42"); - }).pipe( - Effect.scoped, - Effect.provide( - Layer.mergeAll( - IdAllocator.layer, - McpProviderSessions.layer, - NodeServices.layer, - NodeCrypto.layer, - ), + } + yield* harness.offerAndWait( + boundary + ? claudeSdkFrame({ + type: "system", + subtype: "compact_boundary", + compact_metadata: { trigger: "auto", pre_tokens: 3000, post_tokens: 600 }, + uuid: "00000000-0000-4000-8000-000000038702", + session_id: WAKE_NATIVE_SESSION, + }) + : claudeSdkFrame({ + type: "system", + subtype: "status", + status: null, + compact_result: "failed", + compact_error: "Compaction failed.", + uuid: "00000000-0000-4000-8000-000000038702", + session_id: WAKE_NATIVE_SESSION, + }), + ); + assert.lengthOf(harness.offeredMessages, outcome === "success then boundary" ? 3 : 2); + assert.equal(harness.offeredMessages[1]?.priority, "now"); + assert.isTrue(Exit.isSuccess(yield* Fiber.join(delivery))); + const sent = JSON.stringify(harness.offeredMessages[1]?.message.content); + assert.include(sent, "Subagent finished."); + assert.notInclude(sent, "Second subagent"); + // The boundary drops the root prompt's note from history; a failed compaction keeps it. + (boundary ? assert.include : assert.notInclude)(sent, "PROJ-42"); + }).pipe( + Effect.scoped, + Effect.provide( + Layer.mergeAll( + IdAllocator.layer, + McpProviderSessions.layer, + NodeServices.layer, + NodeCrypto.layer, ), ), + ), ); it.effect.each(["newer steer", "stop", "query close"] as const)( @@ -11280,9 +11314,8 @@ describe("ClaudeAdapterV2 background wake turns", () => { .offerAndWait( claudeSdkFrame({ type: "system", - subtype: "status", - status: null, - compact_result: "success", + subtype: "compact_boundary", + compact_metadata: { trigger: "auto", pre_tokens: 3000, post_tokens: 600 }, uuid: "00000000-0000-4000-8000-000000038712", session_id: WAKE_NATIVE_SESSION, }), diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index 0b5b559c25477..d28934b8a1d94 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -10808,6 +10808,18 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( return; } yield* trackClaudeGoal({ nativeThreadId: liveQuery.nativeThreadId, context, message }); + // A CLI that reports success but sends no boundary moves on to other frames. + if ( + context.compaction?.status === "completed" && + context.heldSteers.length > 0 && + !( + message.type === "system" && + (message.subtype === "compact_boundary" || message.subtype === "status") + ) && + !(yield* Ref.get(interruptedTurns)).has(context.providerTurnId) + ) { + yield* offerHeldSteers(context); + } if (message.type === "stream_event" && !message.parent_tool_use_id) { const event = message.event; @@ -11077,8 +11089,11 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( if (budget !== undefined) budget.compacting = null; } } - // Stop settles held steers with the turn instead. - if (!interrupted) yield* offerHeldSteers(context); + // Stop settles held steers with the turn instead. A success waits for its boundary, + // which clears the app notes history lost, so a held steer carries them again. + if (!interrupted && message.compact_result !== "success") { + yield* offerHeldSteers(context); + } } // Every trigger discards the conversation, so reset whatever the trigger is. @@ -13989,7 +14004,13 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( }); yield* emitSteerStatus(currentTurn, messageId, "pending"); // Returns without waiting: a running steer effect would block this thread's Stop. - if (currentTurn.compaction?.status === "running" || currentTurn.releasingHeldSteers) { + // A compaction that succeeded still holds steers until its boundary; one that arrives + // while earlier steers wait joins them, whatever the flags say mid-release. + if ( + currentTurn.compaction !== null || + currentTurn.releasingHeldSteers || + currentTurn.heldSteers.length > 0 + ) { held = true; const release = Scope.close(reservationScope, Exit.void); const delivered = yield* Deferred.make< From 26a2f80001fd1b2585a6cf657c998a49086e0a3b Mon Sep 17 00:00:00 2001 From: declandarcy Date: Wed, 18 Nov 2026 16:26:20 -0800 Subject: [PATCH 8/9] fix(server): a failed settlement read leaves a held steer retryable A declined held steer waits for its turn to settle before its follow-up. When that read failed, the error looked like the provider's final answer, so the worker neither retried nor sent the follow-up. It is now flagged settlementUnavailable, and the worker's settlement retry rereads state without resending the steer. Co-Authored-By: Claude Opus 5.5 --- .../src/orchestration-v2/EffectWorker.ts | 13 ++- .../ProviderTurnControlService.test.ts | 86 ++++++++++++++++++- .../ProviderTurnControlService.ts | 6 +- 3 files changed, 98 insertions(+), 7 deletions(-) diff --git a/apps/server/src/orchestration-v2/EffectWorker.ts b/apps/server/src/orchestration-v2/EffectWorker.ts index 446db2bbb7a37..613e1f3ceafc2 100644 --- a/apps/server/src/orchestration-v2/EffectWorker.ts +++ b/apps/server/src/orchestration-v2/EffectWorker.ts @@ -341,10 +341,17 @@ export const layerExecutor: Layer.Layer< // provider holds the steer; its delivery settles the message afterwards. settleSteer(held.delivered).pipe( // No outbox row retries this, so retry what was not the provider's answer. + // Settling again rereads state; it never resends the steer. Effect.retry({ - while: (error) => !isProviderTurnControlError(error.cause), - schedule: Schedule.exponential("1 second"), - times: 4, + while: (error) => + !isProviderTurnControlError(error.cause) || + error.cause.settlementUnavailable === true, + schedule: Schedule.exponential("1 second").pipe( + Schedule.modifyDelay(({ duration }) => + Effect.succeed(Duration.min(duration, Duration.seconds(30))), + ), + ), + times: 8, }), Effect.catchCause((cause) => Effect.logWarning( diff --git a/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts b/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts index 3b5beb4850e3c..e5285e31b6ec5 100644 --- a/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts +++ b/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts @@ -28,7 +28,7 @@ import { CodexProviderCapabilitiesV2 } from "./Adapters/CodexAdapterV2.ts"; import * as McpAppModelContext from "../mcpApps/McpAppModelContext.ts"; import * as EventSink from "./EventSink.ts"; import * as ProjectionStore from "./ProjectionStore.ts"; -import type * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; +import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; import * as ProviderSessionManager from "./ProviderSessionManager.ts"; import * as ProviderTurnControlService from "./ProviderTurnControlService.ts"; @@ -377,6 +377,90 @@ it.effect( }), ); +it.effect("keeps a held steer's failed settlement read apart from its decline", () => + Effect.gen(function* () { + const now = yield* DateTime.now; + const threadId = ThreadId.make("thread:held-steer-settle"); + const sessionId = ProviderSessionId.make("provider-session:held-steer-settle"); + const providerTurnId = ProviderTurnId.make("provider-turn:held-steer-settle"); + const attemptId = RunAttemptId.make("run-attempt:held-steer-settle"); + const providerThread = { + id: ProviderThreadId.make("provider-thread:held-steer-settle"), + driver, + providerInstanceId, + providerSessionId: sessionId, + } as OrchestrationV2ProviderThread; + const projection = makeProjection({ now, threadId, providerThread, providerTurnId, attemptId }); + const runtime = { + instanceId: providerInstanceId, + driver, + providerSessionId: sessionId, + steerTurn: (input: ProviderAdapter.ProviderAdapterV2SteerInput) => + Effect.succeed({ + delivered: Effect.fail( + new ProviderAdapter.ProviderAdapterSteerDeclinedError({ + driver, + providerThreadId: input.providerThread.id, + providerTurnId: input.providerTurnId, + }), + ), + }), + } as unknown as ProviderAdapter.ProviderAdapterV2SessionRuntime; + const layerControl = ProviderTurnControlService.layer.pipe( + Layer.provide( + Layer.mergeAll( + layerProjectionStore(() => + Effect.succeed({ + providerThread, + providerTurn: projection.providerTurns[0], + attempt: projection.attempts[0], + message: { + id: MessageId.make("message:held-steer-settle"), + text: "Subagent finished.", + attachments: [], + createdBy: "agent", + creationSource: "mcp", + } as unknown as NonNullable< + ProjectionStore.ProjectionProviderControlContext["message"] + >, + run: { + id: RunId.make("run:held-steer-settle"), + status: "running", + activeAttemptId: attemptId, + } as OrchestrationV2Run, + }), + ), + layerSessions(sessionId, runtime), + // The decline waits for the turn to settle, and that read fails. + Layer.mock(EventSink.EventSinkV2)({ + latestSequence: () => Effect.fail(new EventSink.EventSinkStreamError({ threadId })), + }), + Layer.mock(McpAppModelContext.McpAppModelContext)({ + forThread: () => Effect.succeed([]), + }), + ), + ), + ); + + const failure = yield* Effect.gen(function* () { + const control = yield* ProviderTurnControlService.ProviderTurnControlServiceV2; + const held = yield* control.steer({ + threadId, + providerSessionId: sessionId, + providerThreadId: providerThread.id, + providerTurnId, + messageId: MessageId.make("message:held-steer-settle"), + }); + assert.isDefined(held); + return yield* held!.delivered.pipe(Effect.flip); + }).pipe(Effect.provide(layerControl)); + + // Retryable: the worker settles again instead of treating it as the provider's answer. + assert.isTrue(failure.settlementUnavailable); + assert.isUndefined(failure.steerDeclined); + }), +); + it.effect("steers a running turn with the thread's MCP app model context", () => Effect.gen(function* () { const now = yield* DateTime.now; diff --git a/apps/server/src/orchestration-v2/ProviderTurnControlService.ts b/apps/server/src/orchestration-v2/ProviderTurnControlService.ts index fd4985f28768d..a1d5c636bdc0e 100644 --- a/apps/server/src/orchestration-v2/ProviderTurnControlService.ts +++ b/apps/server/src/orchestration-v2/ProviderTurnControlService.ts @@ -14,7 +14,6 @@ import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; -import * as Schedule from "effect/Schedule"; import * as Schema from "effect/Schema"; import * as Stream from "effect/Stream"; @@ -45,6 +44,8 @@ export class ProviderTurnControlError extends Schema.TaggedError new ProviderTurnControlError({ threadId: input.threadId, operation: "steer", providerTurnId: input.providerTurnId, + settlementUnavailable: true, cause, }), ), From 6aac75467a3a7138497e2b8fa6609dad632eee78 Mon Sep 17 00:00:00 2001 From: declandarcy Date: Thu, 19 Nov 2026 13:52:44 -0800 Subject: [PATCH 9/9] fix(server): Claude threads steer during auto-compaction instead of queueing #39018 sends Claude steers with priority "next", which waits out a running auto-compaction instead of aborting it. The held-steer machinery this branch added for "now" steers is no longer needed, so it is removed. What remains is declaring activeSteeringDuringCompaction, so the composers steer a message sent mid-compaction into the turn instead of queueing it until the turn ends. Co-Authored-By: Claude Opus 5.5 --- .../Adapters/ClaudeAdapterV2.test.ts | 355 +----------------- .../Adapters/ClaudeAdapterV2.ts | 2 + .../src/orchestration-v2/EffectWorker.ts | 98 ++--- .../src/orchestration-v2/Orchestrator.ts | 67 +--- .../ProviderTurnControlService.test.ts | 86 +---- .../ProviderTurnControlService.ts | 107 ++---- .../SteeringCompletion.integration.test.ts | 97 ----- docs/user/providers-claude.md | 5 +- .../src/server/ProviderAdapter.ts | 10 +- 9 files changed, 74 insertions(+), 753 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts index d09890dc03b27..0077d99f03f4e 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts @@ -3726,11 +3726,9 @@ describe("ClaudeAdapterV2 background wake turns", () => { processQueues.push(sdkMessages); return { messages, - // Like the real runner, reports the message queued before the rest of the write. - offer: (message, onQueued) => + offer: (message) => Effect.sync(() => { offeredMessages.push(message); - onQueued?.(); }).pipe( Effect.andThen(changes.notify), Effect.andThen(options?.offer?.(message) ?? Effect.void), @@ -11272,357 +11270,6 @@ describe("ClaudeAdapterV2 background wake turns", () => { ), ); - it.effect.each([ - "boundary", - "success then boundary", - "failed", - "interrupt", - "query exit", - ] as const)("holds a steer until Claude's auto-compaction settles: %s", (outcome) => - Effect.gen(function* () { - const harness = yield* makeWakeHarnessWithOptions({ - close: (sdkMessages) => Queue.shutdown(sdkMessages), - }); - const idAllocator = yield* IdAllocator.IdAllocatorV2; - const appContext = [{ key: "mcp_app_item-1", text: "Created Jira issue PROJ-42" }]; - const input = { - ...makeClaudeTestTurnInput({ - threadId: harness.threadId, - providerThread: harness.providerThread, - now: yield* DateTime.now, - attemptId: RunAttemptId.make(`claude-held-steer-${outcome}`), - text: "Keep orchestrating.", - attachments: [], - }), - appContext, - }; - yield* harness.runtime.startTurn(input); - const providerTurnId = idAllocator.derive.providerTurn({ - driver: ClaudeAdapterV2.CLAUDE_PROVIDER, - nativeTurnId: `turn:${input.attemptId}`, - }); - yield* harness.offerAndWait( - claudeSdkFrame({ - type: "system", - subtype: "status", - status: "compacting", - uuid: "00000000-0000-4000-8000-000000038701", - session_id: WAKE_NATIVE_SESSION, - }), - ); - // A "now" steer would abort the compaction, so it waits without blocking Stop. - const held = yield* harness.runtime.steerTurn({ - threadId: harness.threadId, - runId: input.runId, - providerThread: harness.providerThread, - providerTurnId, - message: { - createdBy: "agent", - creationSource: "mcp", - messageId: MessageId.make("held-steer"), - text: "Subagent finished.", - attachments: [], - }, - appContext, - }); - assert.lengthOf(harness.offeredMessages, 1); - assert.isDefined(held); - const delivery = yield* held!.delivered.pipe(Effect.exit, Effect.forkScoped); - const steerStatuses = () => - harness.events.flatMap((event) => (event.type === "steer.updated" ? [event.status] : [])); - - if (outcome === "interrupt" || outcome === "query exit") { - if (outcome === "interrupt") { - yield* harness.runtime.interruptTurn({ - providerThread: harness.providerThread, - providerTurnId, - }); - } else { - yield* Queue.shutdown(harness.sdkMessages); - } - assert.equal( - (yield* Queue.take(harness.terminalReceipts)).status, - outcome === "interrupt" ? "interrupted" : "failed", - ); - assert.lengthOf(harness.offeredMessages, 1); - // Declined, it comes back as a follow-up, or the orchestrator reports it after Stop. - const exit = yield* Fiber.join(delivery); - const failure = Exit.isFailure(exit) - ? Option.getOrUndefined(Cause.findErrorOption(exit.cause)) - : undefined; - assert.equal(failure?._tag, "ProviderAdapterSteerDeclinedError"); - const notice = harness.events - .flatMap((event) => - event.type === "turn_item.updated" && event.turnItem.type === "system_notice" - ? [event.turnItem] - : [], - ) - .find((item) => item.message?.includes("Subagent finished.")); - // Pending while held; a declined hold leaves its outcome to the follow-up or Stop. - assert.deepEqual(steerStatuses(), ["pending"]); - assert.isUndefined(notice); - return; - } - const boundary = outcome === "boundary" || outcome === "success then boundary"; - if (outcome === "success then boundary") { - yield* harness.offerAndWait( - claudeSdkFrame({ - type: "system", - subtype: "status", - status: null, - compact_result: "success", - uuid: "00000000-0000-4000-8000-000000038703", - session_id: WAKE_NATIVE_SESSION, - }), - ); - // Still held until the boundary clears the notes history lost; a newer steer - // joins it rather than going first. - yield* harness.runtime.steerTurn({ - threadId: harness.threadId, - runId: input.runId, - providerThread: harness.providerThread, - providerTurnId, - message: { - createdBy: "agent", - creationSource: "mcp", - messageId: MessageId.make("held-steer-later"), - text: "Second subagent finished.", - attachments: [], - }, - }); - assert.lengthOf(harness.offeredMessages, 1); - } - yield* harness.offerAndWait( - boundary - ? claudeSdkFrame({ - type: "system", - subtype: "compact_boundary", - compact_metadata: { trigger: "auto", pre_tokens: 3000, post_tokens: 600 }, - uuid: "00000000-0000-4000-8000-000000038702", - session_id: WAKE_NATIVE_SESSION, - }) - : claudeSdkFrame({ - type: "system", - subtype: "status", - status: null, - compact_result: "failed", - compact_error: "Compaction failed.", - uuid: "00000000-0000-4000-8000-000000038702", - session_id: WAKE_NATIVE_SESSION, - }), - ); - assert.lengthOf(harness.offeredMessages, outcome === "success then boundary" ? 3 : 2); - assert.equal(harness.offeredMessages[1]?.priority, "now"); - assert.isTrue(Exit.isSuccess(yield* Fiber.join(delivery))); - const sent = JSON.stringify(harness.offeredMessages[1]?.message.content); - assert.include(sent, "Subagent finished."); - assert.notInclude(sent, "Second subagent"); - // The boundary drops the root prompt's note from history; a failed compaction keeps it. - (boundary ? assert.include : assert.notInclude)(sent, "PROJ-42"); - }).pipe( - Effect.scoped, - Effect.provide( - Layer.mergeAll( - IdAllocator.layer, - McpProviderSessions.layer, - NodeServices.layer, - NodeCrypto.layer, - ), - ), - ), - ); - - it.effect.each(["newer steer", "stop", "query close"] as const)( - "releases held steers in order and leaves none unreleased: %s mid-release", - (outcome) => - Effect.gen(function* () { - const fileSystem = yield* FileSystem.FileSystem; - const path = yield* Path.Path; - const idAllocator = yield* IdAllocator.IdAllocatorV2; - const sending = yield* Deferred.make(); - const resume = yield* Deferred.make(); - const interrupting = yield* Deferred.make(); - const interrupted = yield* Deferred.make(); - let closing = false; - const harness = yield* makeWakeHarnessWithOptions({ - close: (sdkMessages) => Queue.shutdown(sdkMessages), - // Holds Stop between marking the turn interrupted and the CLI confirming it. - interrupt: Deferred.succeed(interrupting, undefined).pipe( - Effect.andThen(Deferred.await(interrupted)), - ), - // Pauses A mid-offer, then interrupts B as a closing query would. - offer: (message) => { - const text = JSON.stringify(message.message.content); - if (text.includes("Steer A")) { - return Deferred.succeed(sending, undefined).pipe( - Effect.andThen(Deferred.await(resume)), - ); - } - return closing && text.includes("Steer B") ? Effect.interrupt : Effect.void; - }, - }); - const document = ChatFileAttachment.make({ - type: "file", - id: ChatAttachmentId.make("held-steer-document"), - name: "held.pdf", - mimeType: "application/pdf", - sizeBytes: 19 * 1024 * 1024, - }); - const pages = Buffer.from( - `%PDF-1.7\n1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj\n2 0 obj << /Type /Pages /Count 60 >> endobj\n${Array.from({ length: 60 }, (_, i) => `${i + 3} 0 obj << /Type /Page /Parent 2 0 R >> endobj`).join("\n")}\n`, - ); - yield* fileSystem.writeFile( - path.join(harness.attachmentsDir, attachmentRelativePath(document)!), - Buffer.concat([ - pages, - Buffer.alloc(document.sizeBytes - pages.length - 5, 32), - Buffer.from("%%EOF"), - ]), - ); - const input = makeClaudeTestTurnInput({ - threadId: harness.threadId, - providerThread: harness.providerThread, - now: yield* DateTime.now, - attemptId: RunAttemptId.make(`claude-held-release-${outcome}`), - text: "Keep orchestrating.", - attachments: [], - }); - yield* harness.runtime.startTurn(input); - const providerTurnId = idAllocator.derive.providerTurn({ - driver: ClaudeAdapterV2.CLAUDE_PROVIDER, - nativeTurnId: `turn:${input.attemptId}`, - }); - const steer = (name: string, attachments: ReadonlyArray = []) => - harness.runtime.steerTurn({ - threadId: harness.threadId, - runId: input.runId, - providerThread: harness.providerThread, - providerTurnId, - message: { - createdBy: "agent", - creationSource: "mcp", - messageId: MessageId.make(`held-${name}`), - text: `Steer ${name}.`, - attachments, - }, - }); - yield* harness.offerAndWait( - claudeSdkFrame({ - type: "system", - subtype: "status", - status: "compacting", - uuid: "00000000-0000-4000-8000-000000038711", - session_id: WAKE_NATIVE_SESSION, - }), - ); - const hold = (name: string, attachments: ReadonlyArray = []) => - steer(name, attachments).pipe( - Effect.flatMap((held) => { - assert.isDefined(held); - return held!.delivered.pipe(Effect.exit, Effect.forkScoped); - }), - ); - const outcomeOf = Effect.fnUntraced(function* ( - delivery: Fiber.Fiber>, - ) { - const exit = yield* Fiber.join(delivery); - return Exit.isSuccess(exit) - ? "delivered" - : Option.getOrUndefined(Cause.findErrorOption(exit.cause))?._tag; - }); - const heldA = yield* hold("A"); - const heldB = yield* hold("B"); - const heldC = outcome === "query close" ? yield* hold("C", [document]) : undefined; - const releasing = yield* harness - .offerAndWait( - claudeSdkFrame({ - type: "system", - subtype: "compact_boundary", - compact_metadata: { trigger: "auto", pre_tokens: 3000, post_tokens: 600 }, - uuid: "00000000-0000-4000-8000-000000038712", - session_id: WAKE_NATIVE_SESSION, - }), - ) - .pipe(Effect.forkScoped); - yield* Deferred.await(sending); - - if (outcome === "newer steer") { - yield* steer("C"); - yield* Deferred.succeed(resume, undefined); - yield* Fiber.join(releasing); - assert.deepEqual( - harness.offeredMessages - .slice(1) - .map((message) => /Steer (\w)\./.exec(JSON.stringify(message.message.content))?.[1]), - ["A", "B", "C"], - ); - return; - } - - if (outcome === "stop") { - const stopping = yield* harness.runtime - .interruptTurn({ providerThread: harness.providerThread, providerTurnId }) - .pipe(Effect.forkScoped); - yield* Deferred.await(interrupting); - yield* Deferred.succeed(resume, undefined); - yield* Fiber.join(releasing); - // B would reach the prompt queue after Stop and start a turn nobody asked for. - assert.lengthOf(harness.offeredMessages, 2); - yield* Deferred.succeed(interrupted, undefined); - yield* Fiber.join(stopping); - assert.equal((yield* Queue.take(harness.terminalReceipts)).status, "interrupted"); - assert.deepEqual( - [yield* outcomeOf(heldA), yield* outcomeOf(heldB)], - ["delivered", "ProviderAdapterSteerDeclinedError"], - ); - return; - } - - // The query closes while B is offered, which interrupts the release mid-drain. - closing = true; - yield* Deferred.succeed(resume, undefined); - yield* Queue.take(harness.terminalReceipts); - // B was already in Claude's queue when the close cut its offer short: declining it - // would send it twice. C never left the hold. - assert.deepEqual( - [yield* outcomeOf(heldA), yield* outcomeOf(heldB), yield* outcomeOf(heldC!)], - ["delivered", "delivered", "ProviderAdapterSteerDeclinedError"], - ); - // The undelivered PDF's pages are free again, so a new turn can send it natively. - const before = harness.offeredMessages.length; - yield* harness.runtime.startTurn( - makeClaudeTestTurnInput({ - threadId: harness.threadId, - providerThread: harness.providerThread, - now: yield* DateTime.now, - attemptId: RunAttemptId.make("claude-held-release-after-stop"), - text: "Read this PDF.", - attachments: [document], - providerTurnOrdinal: 2, - nativeThreadHasTurns: true, - }), - ); - const documents = harness.offeredMessages - .slice(before) - .flatMap((message) => - Array.isArray(message.message.content) - ? message.message.content.filter((block) => block.type === "document") - : [], - ); - assert.lengthOf(documents, 1); - }).pipe( - Effect.scoped, - Effect.provide( - Layer.mergeAll( - IdAllocator.layer, - McpProviderSessions.layer, - NodeServices.layer, - NodeCrypto.layer, - ), - ), - ), - ); - it.effect("names the notebook a Claude NotebookEdit changed", () => Effect.gen(function* () { const harness = yield* makeWakeHarness; diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index 3e1178912bf80..221885913f680 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -595,6 +595,8 @@ export const ClaudeProviderCapabilitiesV2 = { supportsNativeResume: true, supportsActiveSteering: true, activeSteeringInterruptsTools: true, + // A "next" steer waits out a running auto-compaction instead of aborting it. + activeSteeringDuringCompaction: true, supportsSteeringByInterruptRestart: false, supportsQueuedMessages: true, terminalStatusQuality: "strong", diff --git a/apps/server/src/orchestration-v2/EffectWorker.ts b/apps/server/src/orchestration-v2/EffectWorker.ts index 613e1f3ceafc2..c6aa09efd5e69 100644 --- a/apps/server/src/orchestration-v2/EffectWorker.ts +++ b/apps/server/src/orchestration-v2/EffectWorker.ts @@ -117,7 +117,6 @@ export const layerExecutor: Layer.Layer< const threads = yield* ThreadManagementService.ThreadManagementService; const projectionStore = yield* ProjectionStore.ProjectionStoreV2; const settings = yield* ServerSettings.ServerSettingsService; - const scope = yield* Effect.scope; const startRun = ( effect: EffectOutbox.OrchestrationEffectV2, runId: RunId, @@ -327,58 +326,37 @@ export const layerExecutor: Layer.Layer< ), ); } - case "provider-turn.steer": { - const settleSteer = ( - sent: Effect.Effect< - Effect.Success>, - ProviderTurnControlService.ProviderTurnControlError - >, - ): Effect.Effect => - sent.pipe( - Effect.tap((held) => - held !== undefined - ? // Returning frees this thread's later effects, such as Stop, while the - // provider holds the steer; its delivery settles the message afterwards. - settleSteer(held.delivered).pipe( - // No outbox row retries this, so retry what was not the provider's answer. - // Settling again rereads state; it never resends the steer. - Effect.retry({ - while: (error) => - !isProviderTurnControlError(error.cause) || - error.cause.settlementUnavailable === true, - schedule: Schedule.exponential("1 second").pipe( - Schedule.modifyDelay(({ duration }) => - Effect.succeed(Duration.min(duration, Duration.seconds(30))), - ), - ), - times: 8, - }), - Effect.catchCause((cause) => - Effect.logWarning( - "orchestration-v2.effect-worker.held-steer-settle-failed", - { effectId: effect.id }, - cause, - ), - ), - Effect.forkIn(scope), - ) - : Effect.gen(function* () { - if (effect.request.type !== "provider-turn.steer") return; - const messageId = effect.request.messageId; - const projection = yield* threads.getThreadRecords( - effect.threadId, - ["messages", "runs"], - { messageIds: [effect.request.messageId] }, - ); - const message = projection.messages.find((row) => row.id === messageId); - if (message?.delegatedCompletion === undefined) return; - yield* threads.dispatch({ - type: "notification.delivery.accept", - commandId: CommandId.make(`command:mailbox-accepted:${effect.id}`), - threadId: effect.threadId, - messageId: message.id, - }); - }), + case "provider-turn.steer": + return providerTurnControl + .steer({ + threadId: effect.threadId, + providerSessionId: effect.request.providerSessionId, + providerThreadId: effect.request.providerThreadId, + providerTurnId: effect.request.providerTurnId, + messageId: effect.request.messageId, + ...(effect.request.modelSelection === undefined + ? {} + : { modelSelection: effect.request.modelSelection }), + }) + .pipe( + Effect.tap(() => + Effect.gen(function* () { + if (effect.request.type !== "provider-turn.steer") return; + const messageId = effect.request.messageId; + const projection = yield* threads.getThreadRecords( + effect.threadId, + ["messages", "runs"], + { messageIds: [effect.request.messageId] }, + ); + const message = projection.messages.find((row) => row.id === messageId); + if (message?.delegatedCompletion === undefined) return; + yield* threads.dispatch({ + type: "notification.delivery.accept", + commandId: CommandId.make(`command:mailbox-accepted:${effect.id}`), + threadId: effect.threadId, + messageId: message.id, + }); + }), ), Effect.catch((error) => Effect.gen(function* () { @@ -472,21 +450,7 @@ export const layerExecutor: Layer.Layer< cause, }), ), - Effect.asVoid, ); - return settleSteer( - providerTurnControl.steer({ - threadId: effect.threadId, - providerSessionId: effect.request.providerSessionId, - providerThreadId: effect.request.providerThreadId, - providerTurnId: effect.request.providerTurnId, - messageId: effect.request.messageId, - ...(effect.request.modelSelection === undefined - ? {} - : { modelSelection: effect.request.modelSelection }), - }), - ); - } case "provider-turn.restart": return providerTurnControl .interruptAndAwaitTerminal({ diff --git a/apps/server/src/orchestration-v2/Orchestrator.ts b/apps/server/src/orchestration-v2/Orchestrator.ts index caff67072f651..0a3424735a670 100644 --- a/apps/server/src/orchestration-v2/Orchestrator.ts +++ b/apps/server/src/orchestration-v2/Orchestrator.ts @@ -7059,74 +7059,23 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio ); if (command.steerFollowUpOfRunId !== undefined) { const source = projection.runs.find((run) => run.id === command.steerFollowUpOfRunId); - const message = projection.messages.find( - (candidate) => candidate.id === command.messageId && candidate.runId === source?.id, - ); - const discarded = + if ( source === undefined || command.dispatchMode.type !== "queue_after_active" || - message === undefined || + !projection.messages.some( + (message) => message.id === command.messageId && message.runId === source.id, + ) || projection.thread.archivedAt !== null || - projection.thread.deletedAt !== null; - if (discarded || (yield* stopReachedRun(command, command.threadId, source.id))) { - const now = yield* DateTime.now; - // The provider never took this steer and Stop cancels it, so say so where it was sent. - if (!discarded && source.rootNodeId !== null) { - const emitEvent = emit(events, command); - const item = projection.turnItems.find( - (candidate) => - candidate.id === idAllocator.derive.userTurnItem({ messageId: message.id }), - ); - if (item?.type === "user_message" && item.status !== "cancelled") { - yield* emitEvent({ - type: "turn-item.updated", - threadId: command.threadId, - runId: source.id, - nodeId: source.rootNodeId, - providerInstanceId: source.providerInstanceId, - occurredAt: now, - payload: { ...item, status: "cancelled", updatedAt: now }, - }); - } - if (message.delegatedCompletion === undefined && message.notification === undefined) { - yield* emitEvent({ - type: "turn-item.updated", - threadId: command.threadId, - runId: source.id, - nodeId: source.rootNodeId, - providerInstanceId: source.providerInstanceId, - occurredAt: now, - payload: { - id: idAllocator.derive.runSignalTurnItem({ - runId: source.id, - signal: `unsent-steer:${message.id}`, - }), - threadId: command.threadId, - runId: source.id, - nodeId: source.rootNodeId, - providerThreadId: source.providerThreadId, - providerTurnId: null, - nativeItemRef: null, - parentItemId: null, - ordinal: yield* nextTurnItemOrdinal(projection), - status: "completed", - title: "Steer not sent", - startedAt: now, - completedAt: now, - updatedAt: now, - type: "system_notice", - message: `The turn stopped before this steer was sent. Resend it if needed: "${message.text}"`, - }, - }); - } - } + projection.thread.deletedAt !== null || + (yield* stopReachedRun(command, command.threadId, source.id)) + ) { yield* emit( events, command, )({ type: "thread.metadata-updated", threadId: command.threadId, - occurredAt: now, + occurredAt: yield* DateTime.now, payload: projection.thread, }); return; diff --git a/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts b/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts index 4fe1dbfa815ed..10cc4b10b7130 100644 --- a/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts +++ b/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts @@ -28,7 +28,7 @@ import { CodexProviderCapabilitiesV2 } from "./Adapters/CodexAdapterV2.ts"; import * as McpAppModelContext from "../mcpApps/McpAppModelContext.ts"; import * as EventSink from "./EventSink.ts"; import * as ProjectionStore from "./ProjectionStore.ts"; -import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; +import type * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; import * as ProviderSessionManager from "./ProviderSessionManager.ts"; import * as ProviderTurnControlService from "./ProviderTurnControlService.ts"; @@ -379,90 +379,6 @@ it.effect( }), ); -it.effect("keeps a held steer's failed settlement read apart from its decline", () => - Effect.gen(function* () { - const now = yield* DateTime.now; - const threadId = ThreadId.make("thread:held-steer-settle"); - const sessionId = ProviderSessionId.make("provider-session:held-steer-settle"); - const providerTurnId = ProviderTurnId.make("provider-turn:held-steer-settle"); - const attemptId = RunAttemptId.make("run-attempt:held-steer-settle"); - const providerThread = { - id: ProviderThreadId.make("provider-thread:held-steer-settle"), - driver, - providerInstanceId, - providerSessionId: sessionId, - } as OrchestrationV2ProviderThread; - const projection = makeProjection({ now, threadId, providerThread, providerTurnId, attemptId }); - const runtime = { - instanceId: providerInstanceId, - driver, - providerSessionId: sessionId, - steerTurn: (input: ProviderAdapter.ProviderAdapterV2SteerInput) => - Effect.succeed({ - delivered: Effect.fail( - new ProviderAdapter.ProviderAdapterSteerDeclinedError({ - driver, - providerThreadId: input.providerThread.id, - providerTurnId: input.providerTurnId, - }), - ), - }), - } as unknown as ProviderAdapter.ProviderAdapterV2SessionRuntime; - const layerControl = ProviderTurnControlService.layer.pipe( - Layer.provide( - Layer.mergeAll( - layerProjectionStore(() => - Effect.succeed({ - providerThread, - providerTurn: projection.providerTurns[0], - attempt: projection.attempts[0], - message: { - id: MessageId.make("message:held-steer-settle"), - text: "Subagent finished.", - attachments: [], - createdBy: "agent", - creationSource: "mcp", - } as unknown as NonNullable< - ProjectionStore.ProjectionProviderControlContext["message"] - >, - run: { - id: RunId.make("run:held-steer-settle"), - status: "running", - activeAttemptId: attemptId, - } as OrchestrationV2Run, - }), - ), - layerSessions(sessionId, runtime), - // The decline waits for the turn to settle, and that read fails. - Layer.mock(EventSink.EventSinkV2)({ - latestSequence: () => Effect.fail(new EventSink.EventSinkStreamError({ threadId })), - }), - Layer.mock(McpAppModelContext.McpAppModelContext)({ - forThread: () => Effect.succeed([]), - }), - ), - ), - ); - - const failure = yield* Effect.gen(function* () { - const control = yield* ProviderTurnControlService.ProviderTurnControlServiceV2; - const held = yield* control.steer({ - threadId, - providerSessionId: sessionId, - providerThreadId: providerThread.id, - providerTurnId, - messageId: MessageId.make("message:held-steer-settle"), - }); - assert.isDefined(held); - return yield* held!.delivered.pipe(Effect.flip); - }).pipe(Effect.provide(layerControl)); - - // Retryable: the worker settles again instead of treating it as the provider's answer. - assert.isTrue(failure.settlementUnavailable); - assert.isUndefined(failure.steerDeclined); - }), -); - it.effect("steers a running turn with the thread's MCP app model context", () => Effect.gen(function* () { const now = yield* DateTime.now; diff --git a/apps/server/src/orchestration-v2/ProviderTurnControlService.ts b/apps/server/src/orchestration-v2/ProviderTurnControlService.ts index a1d5c636bdc0e..25df164788e76 100644 --- a/apps/server/src/orchestration-v2/ProviderTurnControlService.ts +++ b/apps/server/src/orchestration-v2/ProviderTurnControlService.ts @@ -44,8 +44,6 @@ export class ProviderTurnControlError extends Schema.TaggedError Effect.Effect< - void | { readonly delivered: Effect.Effect }, - ProviderTurnControlError - >; + }) => Effect.Effect; /** Best effort: a turn that ended or moved sessions picks the selection up when it next starts. */ readonly applyModelSelection: (input: { readonly threadId: ThreadId; @@ -456,11 +451,34 @@ export const layer: Layer.Layer< mcpAppModelContext, input.threadId, ); - // A held steer's later delivery fails the same ways an immediate one does. - const asControlError = ( - steer: Effect.Effect, - ) => - steer.pipe( + yield* loaded.session.value + .steerTurn({ + threadId: input.threadId, + runId: run.id, + providerThread: loaded.providerThread, + providerTurnId: loaded.providerTurn.id, + ...(input.modelSelection === undefined + ? {} + : { modelSelection: input.modelSelection }), + ...(appContext.length === 0 ? {} : { appContext }), + message: { + messageId: message.id, + text: projectComposerContextForProvider({ + text: message.text, + records: message.context?.records ?? [], + }), + attachments: message.attachments, + createdBy: message.createdBy, + creationSource: message.creationSource, + ...(message.scheduledTaskId === undefined + ? {} + : { scheduledTaskId: message.scheduledTaskId }), + ...(message.senderThreadId === undefined + ? {} + : { senderThreadId: message.senderThreadId }), + }, + }) + .pipe( Effect.catchTags({ ProviderAdapterSteerDeclinedError: (cause) => Effect.fail( @@ -490,74 +508,7 @@ export const layer: Layer.Layer< }); }), ), - Effect.mapError((cause) => - isProviderTurnControlError(cause) - ? cause - : new ProviderTurnControlError({ - threadId: input.threadId, - operation: "steer", - providerTurnId: input.providerTurnId, - cause, - }), - ), ); - const held = yield* asControlError( - loaded.session.value.steerTurn({ - threadId: input.threadId, - runId: run.id, - providerThread: loaded.providerThread, - providerTurnId: loaded.providerTurn.id, - ...(input.modelSelection === undefined - ? {} - : { modelSelection: input.modelSelection }), - ...(appContext.length === 0 ? {} : { appContext }), - message: { - messageId: message.id, - text: projectComposerContextForProvider({ - text: message.text, - records: message.context?.records ?? [], - }), - attachments: message.attachments, - createdBy: message.createdBy, - creationSource: message.creationSource, - ...(message.scheduledTaskId === undefined - ? {} - : { scheduledTaskId: message.scheduledTaskId }), - ...(message.senderThreadId === undefined - ? {} - : { senderThreadId: message.senderThreadId }), - }, - }), - ); - if (held === undefined) return; - // A held steer is declined as its turn ends; its follow-up needs that end persisted. - return { - delivered: asControlError(held.delivered).pipe( - Effect.catchIf( - (error) => error.steerDeclined === true, - (error) => - // The run must settle too: a mailbox follow-up is refused while it still runs. - awaitSettled(input.threadId, { - ...input, - ...(loaded.providerTurn.runAttemptId === null - ? {} - : { attemptId: loaded.providerTurn.runAttemptId }), - }).pipe( - Effect.mapError( - (cause) => - new ProviderTurnControlError({ - threadId: input.threadId, - operation: "steer", - providerTurnId: input.providerTurnId, - settlementUnavailable: true, - cause, - }), - ), - Effect.andThen(Effect.fail(error)), - ), - ), - ), - }; }, (effect, input) => effect.pipe( diff --git a/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts b/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts index 0df7088a0e7f7..ca794563234d7 100644 --- a/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts +++ b/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts @@ -48,7 +48,6 @@ import * as CommandReceiptStore from "./CommandReceiptStore.ts"; import { userFacingDispatchErrorMessage } from "./UserFacingErrors.ts"; import { checkpointWorkspace } from "@t3tools/provider-testing/replayWorkspace"; import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; -import { makeProviderFailure } from "@t3tools/provider-core/server/failure"; import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests"; const driver = ProviderDriverKind.make("codex"); @@ -64,8 +63,6 @@ it.effect.each( [true, "without native steering"], [true, "with interrupting native steering"], [true, "settled only"], - [true, "while held"], - [true, "while held through a failure"], [false, "during continuation"], ["question", "during delivery"], ] as const @@ -163,22 +160,6 @@ it.effect.each( Effect.gen(function* () { steerCalls += 1; if (timing === "after delivery" || timing === "during continuation") return; - // Held like a steer that waits out a compaction, then declined when the turn ends. - if (timing === "while held" || timing === "while held through a failure") { - return { - delivered: Deferred.await(rejectSteer).pipe( - Effect.andThen( - Effect.fail( - new ProviderAdapter.ProviderAdapterSteerDeclinedError({ - driver, - providerThreadId: turn.providerThread.id, - providerTurnId: turn.providerTurnId, - }), - ), - ), - ), - }; - } yield* Deferred.succeed(steerEntered, undefined); yield* Deferred.await(rejectSteer); return yield* new ProviderAdapter.ProviderAdapterSteerRunError({ @@ -352,72 +333,6 @@ it.effect.each( : {}), }); if (timing !== "before dispatch") yield* dispatchSteer; - if (timing === "while held" || timing === "while held through a failure") { - const failed = timing === "while held through a failure"; - // Subscribed before the worker runs: the follow-up commits as soon as the hold ends. - const followUp = yield* watch( - (event) => - event.type === "message.updated" && - event.payload.id === messageId && - event.payload.runId !== first.runId, - ); - yield* worker.drain(); - assert.equal(steerCalls, 1); - const holding = yield* orchestrator.getThreadProjection(threadId); - assert.equal(holding.subagents[0]?.completionDelivery?.state, "claimed"); - const turn = holding.providerTurns[0]!; - const status = failed ? "failed" : "completed"; - // Declined as the turn ends: before anything is persisted, or once a failed turn is - // persisted but its run has not settled yet. - if (!failed) yield* Deferred.succeed(rejectSteer, undefined); - const turnEnded = yield* watch( - (event) => event.type === "provider-turn.updated" && event.payload.status === status, - ); - const runSettled = yield* watch( - (event) => - event.type === "run.updated" && - event.payload.id === first.runId && - event.payload.status === (failed ? "failed" : "waiting"), - ); - yield* Queue.offer(events, { - type: "provider_turn.updated", - driver, - providerTurn: { ...turn, status, completedAt: yield* DateTime.now }, - }); - yield* Fiber.join(turnEnded); - if (failed) yield* Deferred.succeed(rejectSteer, undefined); - const ended = { - type: "turn.terminal", - driver, - providerThreadId: turn.providerThreadId, - providerTurnId: turn.id, - runOrdinal: first.runOrdinal, - threadDisposition: "reusable", - } as const; - yield* Queue.offer( - events, - failed - ? { - ...ended, - status: "failed", - failureItemOrdinal: 100, - failure: makeProviderFailure({ - message: "Claude exited.", - class: "transport_error", - }), - } - : { ...ended, status: "completed", failure: null }, - ); - yield* Fiber.join(runSettled); - yield* Fiber.join(followUp); - yield* worker.drain(); - yield* orchestrator.resumeQueuedRuns; - yield* worker.drain(); - assert.lengthOf(started, 2); - assert.equal(started[1]?.message.messageId, messageId); - assert.include(started[1]?.message.text ?? "", String(taskId)); - return; - } if (timing === "during continuation") { const projection = yield* orchestrator.getThreadProjection(threadId); const turn = projection.providerTurns[0]!; @@ -1643,18 +1558,6 @@ it.effect.each(declinedSteerTimings)( assert.equal(started.length, 1); if (timing === "stop-before-decline") { assert.isUndefined(queued); - // Stop cancelled a steer the provider never took; the thread says so. - assert.equal( - pending.turnItems.find( - (item) => item.type === "user_message" && item.messageId === messageId, - )?.status, - "cancelled", - ); - const notice = pending.turnItems.find( - (item) => item.type === "system_notice" && item.runId === first.runId, - ); - assert.equal(notice?.title, "Steer not sent"); - assert.include(notice?.type === "system_notice" ? notice.message : "", "follow up"); return; } assert.equal(queued?.status, "queued"); diff --git a/docs/user/providers-claude.md b/docs/user/providers-claude.md index 733c31f6469ac..0c4be91d48ac3 100644 --- a/docs/user/providers-claude.md +++ b/docs/user/providers-claude.md @@ -57,10 +57,7 @@ window. Leave it empty for Claude Code's default. You can also send `/compact` in an existing conversation. Claude Code also compacts automatically. A message steered into a turn while Claude compacts -automatically waits for the compaction to finish, then reaches the same turn. If -the turn ends first, the message starts the next turn instead, unless you stopped -the turn. -To see context usage, see +reaches the same turn once the compaction finishes. To see context usage, see [commands and skills](./composer.md#commands-and-skills). When you return to a large thread after Claude's prompt cache expires, a diff --git a/packages/provider-core/src/server/ProviderAdapter.ts b/packages/provider-core/src/server/ProviderAdapter.ts index 65b04df8fa729..62fe110dd5245 100644 --- a/packages/provider-core/src/server/ProviderAdapter.ts +++ b/packages/provider-core/src/server/ProviderAdapter.ts @@ -591,14 +591,6 @@ export interface ProviderAdapterV2SteerInput { readonly appContext?: ProviderAdapterV2TurnInput["appContext"]; } -/** - * A steer the provider holds to send later, such as while it compacts. `delivered` succeeds once - * the provider has it, and fails with `ProviderAdapterSteerDeclinedError` if its turn ends first. - */ -export interface ProviderAdapterV2HeldSteer { - readonly delivered: Effect.Effect; -} - export interface ProviderAdapterV2InterruptInput { readonly providerThread: OrchestrationV2ProviderThread; readonly providerTurnId: ProviderTurnId; @@ -762,7 +754,7 @@ export interface ProviderAdapterV2SessionRuntime { ) => Effect.Effect; readonly steerTurn: ( input: ProviderAdapterV2SteerInput, - ) => Effect.Effect; + ) => Effect.Effect; /** Applies a thread's new selection to its running process where the provider can; otherwise it waits for the next turn. */ readonly applyModelSelection?: (input: { readonly providerThread: OrchestrationV2ProviderThread;