From 060ec1c17dd540393d8a623945bcfb70d415a52f Mon Sep 17 00:00:00 2001 From: ChenCJ-io <99855454+ChenCJ-io@users.noreply.github.com> Date: Thu, 19 Nov 2026 09:49:37 +0800 Subject: [PATCH] fix(server): replay accepted steers after the target turn ends --- .../SteeringCompletion.integration.test.ts | 87 +++++++++++++++++++ .../ThreadManagementService.ts | 26 +++--- 2 files changed, 101 insertions(+), 12 deletions(-) diff --git a/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts b/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts index 062a86f6f7b2a..ca794563234d7 100644 --- a/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts +++ b/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts @@ -3229,6 +3229,93 @@ it.effect("reports a restart that stops the running turn as restarted", () => }), ); +it.effect("replays an accepted steer after its target turn completes", () => + Effect.gen(function* () { + const name = "steer-retry-after-completion"; + const { events, started, steered, layer, startFirstTurn } = + yield* nextTurnSelectionHarness(name); + yield* Effect.gen(function* () { + const orchestrator = yield* Orchestrator.OrchestratorV2; + const worker = yield* EffectWorker.OrchestrationEffectWorkerV2; + const threadManagement = yield* ThreadManagementService.ThreadManagementService; + const threadId = yield* startFirstTurn; + const input = { + projectId: ProjectId.make(`project:${name}`), + commandId: CommandId.make("steer"), + threadId, + messageId: MessageId.make("message:steer"), + text: "Please report the test result", + attachments: [], + mode: "steer", + createdBy: "agent", + creationSource: "mcp", + } as const; + const accepted = yield* threadManagement.sendToThread(input); + assert.equal(accepted.delivery, "steered"); + yield* worker.drain(); + + const waiting = yield* orchestrator.streamDomainEvents.pipe( + Stream.filter( + (event) => + event.type === "run.updated" && + event.payload.id === accepted.run.id && + event.payload.status === "waiting", + ), + Stream.take(1), + Stream.runDrain, + Effect.forkScoped({ startImmediately: true }), + ); + const turn = (yield* orchestrator.getThreadProjection(threadId)).providerTurns[0]!; + yield* Queue.offer(events, { + type: "provider_turn.updated", + driver, + providerTurn: { ...turn, status: "completed", completedAt: yield* DateTime.now }, + }); + yield* Queue.offer(events, { + type: "turn.terminal", + driver, + providerThreadId: turn.providerThreadId, + providerTurnId: turn.id, + runOrdinal: accepted.run.ordinal, + status: "completed", + failure: null, + threadDisposition: "reusable", + }); + yield* Fiber.join(waiting); + yield* worker.drain(); + + const replayed = yield* threadManagement.sendToThread(input); + assert.equal(replayed.dispatch.replayed, true); + assert.equal(replayed.delivery, accepted.delivery); + assert.equal(replayed.message.id, accepted.message.id); + assert.equal(replayed.run.id, accepted.run.id); + assert.equal(replayed.run.status, "completed"); + + const fresh = yield* threadManagement + .sendToThread({ + ...input, + commandId: CommandId.make("fresh-steer"), + messageId: MessageId.make("message:fresh-steer"), + }) + .pipe(Effect.flip); + assert.equal(fresh._tag, "ThreadManagementNoSteerableRunError"); + yield* worker.drain(); + assert.deepEqual(steered, [input.text]); + assert.lengthOf(started, 1); + }).pipe( + Effect.provide( + ThreadManagementService.layer.pipe( + Layer.provideMerge(layer), + Layer.provide(ServerSettings.layerTest()), + Layer.provide( + CommandReceiptStore.layer.pipe(Layer.provide(SqlitePersistence.layerMemory)), + ), + ), + ), + ); + }), +); + it.effect("queues a goal clear without stopping work when no goal drives it", () => Effect.gen(function* () { const { steered, layer, startFirstTurn, send, read } = yield* goalHarness("goal-clear"); diff --git a/apps/server/src/orchestration-v2/ThreadManagementService.ts b/apps/server/src/orchestration-v2/ThreadManagementService.ts index bfd676d7a3a22..c692636bb84fe 100644 --- a/apps/server/src/orchestration-v2/ThreadManagementService.ts +++ b/apps/server/src/orchestration-v2/ThreadManagementService.ts @@ -880,23 +880,25 @@ const make = Effect.gen(function* () { input.freshContext && (input.mode === "steer" || input.mode === "restart") ? "queue" : input.mode; + const explicitSteer = mode === "steer" || mode === "restart"; + const missingSteeringTarget = explicitSteer && steerableRun === undefined; + // A command receipt outlives its target turn. Dispatch validates and replays it. + if (missingSteeringTarget && !(yield* hasReceipt(input.commandId))) { + return yield* new ThreadManagementNoSteerableRunError({ + threadId: input.threadId, + mode, + }); + } + let dispatchMode: Extract< OrchestrationV2Command, { readonly type: "message.dispatch" } >["dispatchMode"]; - if (mode === "steer" || mode === "restart") { - if (steerableRun === undefined) { - return yield* new ThreadManagementNoSteerableRunError({ - threadId: input.threadId, - mode, - }); - } + if ((explicitSteer || mode === "auto") && steerableRun !== undefined) { dispatchMode = { - type: mode === "steer" ? "steer_active" : "restart_active", + type: mode === "restart" ? "restart_active" : "steer_active", targetRunId: steerableRun.id, }; - } else if (mode === "auto" && steerableRun !== undefined) { - dispatchMode = { type: "steer_active", targetRunId: steerableRun.id }; } else { dispatchMode = { type: mode === "queue" ? "queue_after_active" : "start_immediately", @@ -904,8 +906,8 @@ const make = Effect.gen(function* () { } // Turn start would fail on its own after the send reported success; a replay keeps its answer. - // A live steer starts no turn, so it needs no workspace. - if (dispatchMode.type !== "steer_active") { + // A live steer and a receipt replay without a target turn need no workspace. + if (!missingSteeringTarget && dispatchMode.type !== "steer_active") { yield* worktreeRestore .restore(target.thread) .pipe(