@devries-cameron20 / t3code-1 / commits / f69b3a27a7
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

fix(server): replay accepted steers after the target turn ends (#38831)

Co-authored-by: Julius Marminge <julius0216@outlook.com>

CCJ committed Nov 19, 2026 at 11:30 UTC f69b3a27a7945745889a4f77662e75560c9c8af4
2 files changed +101 -12
apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts
+87
@@ -3229,6 +3229,93 @@ it.effect("reports a restart that stops the running turn as restarted", () =>
3229 }),
3230 );
3231
3232 +it.effect("replays an accepted steer after its target turn completes", () =>
3233 + Effect.gen(function* () {
3234 + const name = "steer-retry-after-completion";
3235 + const { events, started, steered, layer, startFirstTurn } =
3236 + yield* nextTurnSelectionHarness(name);
3237 + yield* Effect.gen(function* () {
3238 + const orchestrator = yield* Orchestrator.OrchestratorV2;
3239 + const worker = yield* EffectWorker.OrchestrationEffectWorkerV2;
3240 + const threadManagement = yield* ThreadManagementService.ThreadManagementService;
3241 + const threadId = yield* startFirstTurn;
3242 + const input = {
3243 + projectId: ProjectId.make(`project:${name}`),
3244 + commandId: CommandId.make("steer"),
3245 + threadId,
3246 + messageId: MessageId.make("message:steer"),
3247 + text: "Please report the test result",
3248 + attachments: [],
3249 + mode: "steer",
3250 + createdBy: "agent",
3251 + creationSource: "mcp",
3252 + } as const;
3253 + const accepted = yield* threadManagement.sendToThread(input);
3254 + assert.equal(accepted.delivery, "steered");
3255 + yield* worker.drain();
3256 +
3257 + const waiting = yield* orchestrator.streamDomainEvents.pipe(
3258 + Stream.filter(
3259 + (event) =>
3260 + event.type === "run.updated" &&
3261 + event.payload.id === accepted.run.id &&
3262 + event.payload.status === "waiting",
3263 + ),
3264 + Stream.take(1),
3265 + Stream.runDrain,
3266 + Effect.forkScoped({ startImmediately: true }),
3267 + );
3268 + const turn = (yield* orchestrator.getThreadProjection(threadId)).providerTurns[0]!;
3269 + yield* Queue.offer(events, {
3270 + type: "provider_turn.updated",
3271 + driver,
3272 + providerTurn: { ...turn, status: "completed", completedAt: yield* DateTime.now },
3273 + });
3274 + yield* Queue.offer(events, {
3275 + type: "turn.terminal",
3276 + driver,
3277 + providerThreadId: turn.providerThreadId,
3278 + providerTurnId: turn.id,
3279 + runOrdinal: accepted.run.ordinal,
3280 + status: "completed",
3281 + failure: null,
3282 + threadDisposition: "reusable",
3283 + });
3284 + yield* Fiber.join(waiting);
3285 + yield* worker.drain();
3286 +
3287 + const replayed = yield* threadManagement.sendToThread(input);
3288 + assert.equal(replayed.dispatch.replayed, true);
3289 + assert.equal(replayed.delivery, accepted.delivery);
3290 + assert.equal(replayed.message.id, accepted.message.id);
3291 + assert.equal(replayed.run.id, accepted.run.id);
3292 + assert.equal(replayed.run.status, "completed");
3293 +
3294 + const fresh = yield* threadManagement
3295 + .sendToThread({
3296 + ...input,
3297 + commandId: CommandId.make("fresh-steer"),
3298 + messageId: MessageId.make("message:fresh-steer"),
3299 + })
3300 + .pipe(Effect.flip);
3301 + assert.equal(fresh._tag, "ThreadManagementNoSteerableRunError");
3302 + yield* worker.drain();
3303 + assert.deepEqual(steered, [input.text]);
3304 + assert.lengthOf(started, 1);
3305 + }).pipe(
3306 + Effect.provide(
3307 + ThreadManagementService.layer.pipe(
3308 + Layer.provideMerge(layer),
3309 + Layer.provide(ServerSettings.layerTest()),
3310 + Layer.provide(
3311 + CommandReceiptStore.layer.pipe(Layer.provide(SqlitePersistence.layerMemory)),
3312 + ),
3313 + ),
3314 + ),
3315 + );
3316 + }),
3317 +);
3318 +
3319 it.effect("queues a goal clear without stopping work when no goal drives it", () =>
3320 Effect.gen(function* () {
3321 const { steered, layer, startFirstTurn, send, read } = yield* goalHarness("goal-clear");
apps/server/src/orchestration-v2/ThreadManagementService.ts
+14 -12
@@ -880,23 +880,25 @@ const make = Effect.gen(function* () {
880 input.freshContext && (input.mode === "steer" || input.mode === "restart")
881 ? "queue"
882 : input.mode;
883 + const explicitSteer = mode === "steer" || mode === "restart";
884 + const missingSteeringTarget = explicitSteer && steerableRun === undefined;
885 + // A command receipt outlives its target turn. Dispatch validates and replays it.
886 + if (missingSteeringTarget && !(yield* hasReceipt(input.commandId))) {
887 + return yield* new ThreadManagementNoSteerableRunError({
888 + threadId: input.threadId,
889 + mode,
890 + });
891 + }
892 +
893 let dispatchMode: Extract<
894 OrchestrationV2Command,
895 { readonly type: "message.dispatch" }
896 >["dispatchMode"];
887 - if (mode === "steer" || mode === "restart") {
888 - if (steerableRun === undefined) {
889 - return yield* new ThreadManagementNoSteerableRunError({
890 - threadId: input.threadId,
891 - mode,
892 - });
893 - }
897 + if ((explicitSteer || mode === "auto") && steerableRun !== undefined) {
898 dispatchMode = {
895 - type: mode === "steer" ? "steer_active" : "restart_active",
899 + type: mode === "restart" ? "restart_active" : "steer_active",
900 targetRunId: steerableRun.id,
901 };
898 - } else if (mode === "auto" && steerableRun !== undefined) {
899 - dispatchMode = { type: "steer_active", targetRunId: steerableRun.id };
902 } else {
903 dispatchMode = {
904 type: mode === "queue" ? "queue_after_active" : "start_immediately",
@@ -904,8 +906,8 @@ const make = Effect.gen(function* () {
906 }
907
908 // Turn start would fail on its own after the send reported success; a replay keeps its answer.
907 - // A live steer starts no turn, so it needs no workspace.
908 - if (dispatchMode.type !== "steer_active") {
909 + // A live steer and a receipt replay without a target turn need no workspace.
910 + if (!missingSteeringTarget && dispatchMode.type !== "steer_active") {
911 yield* worktreeRestore
912 .restore(target.thread)
913 .pipe(