The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 07:15 UTC
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(