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, 17:15 UTC
fix(server): a send to a thread whose worktree can't be recreated now fails instead of reporting started (#36251)
Julius Marminge committed
Nov 13, 2026 at 09:54 UTC
d70bfe6e97158cd47435d3f173e7d5bc35e4e562
7 files changed
+229
-7
apps/server/src/mcp/OrchestratorMcpService.ts
+1
@@ -251,6 +251,7 @@ function threadManagementFailure(error: unknown): OrchestratorMcpFailure {
251
return failure("run_not_found", error.message);
252
case "ThreadManagementThreadArchivedError":
253
case "ThreadManagementNoSteerableRunError":
254
+ case "ThreadManagementWorktreeRestoreError":
255
return failure("thread_not_sendable", error.message);
256
case "ThreadManagementThreadNotInterruptibleError":
257
return failure("thread_not_interruptible", error.message);
apps/server/src/orchestration-v2/ProviderTurnStartService.test.ts
+48
@@ -40,6 +40,10 @@ import {
40
withWorkspaceLease,
41
} from "../workspace/workspaceLease.ts";
42
import * as GitWorkflow from "../git/GitWorkflowService.ts";
43
+import {
44
+ layerThreadWorktreeRestore,
45
+ ThreadWorktreeRestore,
46
+} from "../workspace/restoreMissingWorktree.ts";
47
import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
48
import { layerRealGit } from "./ProviderTurnStartService.testkit.ts";
49
import * as ProjectService from "../project/ProjectService.ts";
@@ -272,6 +276,50 @@ it.each([
276
expect(harness.createWorktree).toHaveBeenCalledTimes(input.recreated ? 1 : 0);
277
});
278
279
+const restoreLeaseExists = vi.fn(() => Effect.succeed(false));
280
+const restoreLeaseCreateWorktree = vi.fn(() => Effect.succeed({} as never));
281
+const layerRestoreLeaseTest = layerThreadWorktreeRestore.pipe(
282
+ Layer.provide(
283
+ Layer.mergeAll(
284
+ Layer.succeed(FileSystem.FileSystem, {
285
+ exists: restoreLeaseExists,
286
+ realPath: (target: string) => Effect.succeed(normalize(target)),
287
+ } as never),
288
+ layerWorktreeLocation(),
289
+ Layer.mock(GitWorkflow.GitWorkflowService)({
290
+ pruneWorktrees: () => Effect.void,
291
+ createWorktree: restoreLeaseCreateWorktree,
292
+ listLocalBranchNames: () => Effect.succeed(["feature/restore"]),
293
+ }),
294
+ Layer.mock(ProjectService.ProjectService)({
295
+ getById: () =>
296
+ Effect.succeedSome({ workspaceRoot: "/tmp/provider-turn-start-project" } as never),
297
+ }),
298
+ ),
299
+ ),
300
+);
301
+
302
+effectIt.effect("restores a missing worktree before a send only under the workspace lease", () =>
303
+ Effect.gen(function* () {
304
+ const worktreePath = `${managedWorktreesDir}/project/feature-restore`;
305
+ const { restore } = yield* ThreadWorktreeRestore;
306
+ yield* withWorkspaceLease(
307
+ worktreePath,
308
+ Effect.gen(function* () {
309
+ const restoring = yield* restore({
310
+ id: ThreadId.make("thread_send_restore_lease"),
311
+ projectId: ProjectId.make("project_send_restore_lease"),
312
+ worktreePath,
313
+ branch: "feature/restore",
314
+ }).pipe(Effect.forkChild({ startImmediately: true }));
315
+ expect(restoreLeaseExists).not.toHaveBeenCalled();
316
+ return restoring;
317
+ }),
318
+ ).pipe(Effect.flatMap(Fiber.join));
319
+ expect(restoreLeaseCreateWorktree).toHaveBeenCalledTimes(1);
320
+ }).pipe(Effect.provide(layerRestoreLeaseTest)),
321
+);
322
+
323
function makeLocalCommandHarness(input: {
324
readonly text: string;
325
readonly nativeGoals?: boolean;
apps/server/src/orchestration-v2/ThreadManagementService.test.ts
+100
@@ -38,6 +38,11 @@ import * as ProviderSessionManager from "./ProviderSessionManager.ts";
38
import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
39
import * as ThreadManagementService from "./ThreadManagementService.ts";
40
import * as ThreadCommandExecutor from "./ThreadCommandExecutor.ts";
41
+import * as LegacyV1ThreadImporter from "./legacy/LegacyV1ThreadImporter.ts";
42
+import {
43
+ ThreadWorktreeRestore,
44
+ WorktreeRecreateError,
45
+} from "../workspace/restoreMissingWorktree.ts";
46
47
it("stamps authoritative provenance on commands that create threads or messages", () => {
48
const command: OrchestrationV2Command = {
@@ -199,6 +204,101 @@ it.effect(
204
},
205
);
206
207
+it.effect.each([
208
+ { label: "fails a send that starts a turn", running: false },
209
+ { label: "still steers a running turn", running: true },
210
+])("sendToThread with a missing worktree that cannot be recreated $label", ({ running }) => {
211
+ const projectId = ProjectId.make("project:thread-management:worktree-gone");
212
+ const threadId = ThreadId.make("thread:thread-management:worktree-gone");
213
+ const dispatched: Array<string> = [];
214
+ const layerTest = ThreadManagementService.layerWithLegacyImporter.pipe(
215
+ Layer.provide(
216
+ Layer.succeed(ThreadWorktreeRestore, {
217
+ restore: () =>
218
+ Effect.fail(
219
+ new WorktreeRecreateError({
220
+ worktreePath: "/worktrees/gone",
221
+ branch: "t3/gone",
222
+ cause: new Error("branch_checked_out_in_worktree"),
223
+ }),
224
+ ),
225
+ }),
226
+ ),
227
+ Layer.provide(
228
+ Layer.mock(LegacyV1ThreadImporter.LegacyV1ThreadImporter)({
229
+ ensureTranscript: () => Effect.succeed({ importedThreadCount: 0, importedMessageCount: 0 }),
230
+ }),
231
+ ),
232
+ Layer.provide(Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({})),
233
+ Layer.provide(
234
+ Layer.mock(Orchestrator.OrchestratorV2)({
235
+ getThreadRecords: () =>
236
+ Effect.succeed({
237
+ thread: {
238
+ id: threadId,
239
+ projectId,
240
+ deletedAt: null,
241
+ archivedAt: null,
242
+ worktreePath: "/worktrees/gone",
243
+ branch: "t3/gone",
244
+ modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "test" },
245
+ },
246
+ runs: running
247
+ ? [
248
+ {
249
+ id: RunId.make("run:thread-management:worktree-gone"),
250
+ status: "running",
251
+ activeAttemptId: "attempt:thread-management:worktree-gone",
252
+ },
253
+ ]
254
+ : [],
255
+ providerTurns: running
256
+ ? [
257
+ {
258
+ runAttemptId: "attempt:thread-management:worktree-gone",
259
+ status: "running",
260
+ },
261
+ ]
262
+ : [],
263
+ messages: [],
264
+ turnItems: [],
265
+ } as unknown as OrchestrationV2ThreadProjection),
266
+ dispatch: (command) =>
267
+ Effect.sync(() => {
268
+ dispatched.push(command.type);
269
+ return { sequence: 1, storedEvents: [] } as never;
270
+ }),
271
+ }),
272
+ ),
273
+ Layer.provide(ServerSettings.layerTest()),
274
+ Layer.provideMerge(layerReceiptsTest),
275
+ );
276
+
277
+ return Effect.gen(function* () {
278
+ const threads = yield* ThreadManagementService.ThreadManagementService;
279
+ const error = yield* Effect.flip(
280
+ threads.sendToThread({
281
+ projectId,
282
+ threadId,
283
+ commandId: CommandId.make("command:thread-management:worktree-gone"),
284
+ messageId: MessageId.make("message:thread-management:worktree-gone"),
285
+ text: "Reply with ok.",
286
+ attachments: [],
287
+ mode: "auto",
288
+ createdBy: "agent",
289
+ creationSource: "mcp",
290
+ }),
291
+ );
292
+ // The mock records no message, so a dispatched send ends in the projection read.
293
+ expect(error._tag).toBe(
294
+ running
295
+ ? "ThreadManagementDurableRunProjectionError"
296
+ : "ThreadManagementWorktreeRestoreError",
297
+ );
298
+ expect(dispatched).toEqual(running ? ["message.dispatch"] : []);
299
+ }).pipe(Effect.provide(layerTest));
300
+});
301
+
302
it.effect("waitForThread follows a restart continuation instead of the cut run", () =>
303
Effect.gen(function* () {
304
const projectId = ProjectId.make("project:thread-management:wait-restart");
apps/server/src/orchestration-v2/ThreadManagementService.ts
+44
@@ -69,6 +69,7 @@ import { DispatchModeLimit, exceededDispatchModeLimit } from "./DispatchModeLimi
69
import { projectTurnItemForDetail } from "./WireProjection.ts";
70
import * as LegacyV1ThreadImporter from "./legacy/LegacyV1ThreadImporter.ts";
71
import * as ServerSettings from "../serverSettings.ts";
72
+import { ThreadWorktreeRestore } from "../workspace/restoreMissingWorktree.ts";
73
74
export type ThreadManagementSendMode = "auto" | "queue" | "steer" | "restart";
75
@@ -316,6 +317,19 @@ export class ThreadManagementDurableRunProjectionError extends Schema.TaggedErro
317
}
318
}
319
320
+export class ThreadManagementWorktreeRestoreError extends Schema.TaggedError<ThreadManagementWorktreeRestoreError>()(
321
+ "ThreadManagementWorktreeRestoreError",
322
+ {
323
+ threadId: ThreadId,
324
+ cause: Schema.Defect(),
325
+ },
326
+) {
327
+ override get message(): string {
328
+ const detail = this.cause instanceof Error ? ` ${this.cause.message}` : "";
329
+ return `Couldn't recreate the missing workspace of thread ${this.threadId}, so the message was not sent.${detail}`;
330
+ }
331
+}
332
+
333
export class ThreadManagementProviderInstanceDisabledError extends Schema.TaggedError<ThreadManagementProviderInstanceDisabledError>()(
334
"ThreadManagementProviderInstanceDisabledError",
335
{
@@ -360,6 +374,7 @@ export const ThreadManagementError = Schema.Union([
374
ThreadManagementProjectThreadsListError,
375
ThreadManagementDurableRunProjectionError,
376
ThreadManagementProviderInstanceDisabledError,
377
+ ThreadManagementWorktreeRestoreError,
378
]);
379
export type ThreadManagementError = typeof ThreadManagementError.Type;
380
@@ -592,6 +607,7 @@ const make = Effect.gen(function* () {
607
const legacyImporter = yield* LegacyV1ThreadImporter.LegacyV1ThreadImporter;
608
const serverSettings = yield* ServerSettings.ServerSettingsService;
609
const receipts = yield* CommandReceiptStore.CommandReceiptStoreV2;
610
+ const worktreeRestore = yield* ThreadWorktreeRestore;
611
612
const assertProviderInstanceEnabled: ThreadManagementServiceShape["assertProviderInstanceEnabled"] =
613
(input) =>
@@ -873,6 +889,26 @@ const make = Effect.gen(function* () {
889
};
890
}
891
892
+ // Turn start would fail on its own after the send reported success; a replay keeps its answer.
893
+ // A live steer starts no turn, so it needs no workspace.
894
+ if (dispatchMode.type !== "steer_active") {
895
+ yield* worktreeRestore
896
+ .restore(target.thread)
897
+ .pipe(
898
+ Effect.catch((cause) =>
899
+ hasReceipt(input.commandId).pipe(
900
+ Effect.flatMap((replay) =>
901
+ replay
902
+ ? Effect.void
903
+ : Effect.fail(
904
+ new ThreadManagementWorktreeRestoreError({ threadId: input.threadId, cause }),
905
+ ),
906
+ ),
907
+ ),
908
+ ),
909
+ );
910
+ }
911
+
912
const dispatched = yield* dispatch({
913
type: "message.dispatch",
914
commandId: input.commandId,
@@ -1719,6 +1755,12 @@ const make = Effect.gen(function* () {
1755
});
1756
});
1757
1758
+const layerThreadWorktreeRestoreNoop = Layer.succeed(ThreadWorktreeRestore, {
1759
+ restore: Effect.fn("ThreadWorktreeRestore.restore")(function () {
1760
+ return Effect.void;
1761
+ }),
1762
+});
1763
+
1764
const layerLegacyV1ThreadImporterNoop = Layer.succeed(
1765
LegacyV1ThreadImporter.LegacyV1ThreadImporter,
1766
LegacyV1ThreadImporter.LegacyV1ThreadImporter.of({
@@ -1740,6 +1782,7 @@ export const layer: Layer.Layer<
1782
| CommandReceiptStore.CommandReceiptStoreV2
1783
> = Layer.effect(ThreadManagementService, make).pipe(
1784
Layer.provide(layerLegacyV1ThreadImporterNoop),
1785
+ Layer.provide(layerThreadWorktreeRestoreNoop),
1786
Layer.provide(ThreadCommandExecutor.layer),
1787
);
1788
@@ -1747,6 +1790,7 @@ export const layerWithLegacyImporter: Layer.Layer<
1790
ThreadManagementService,
1791
never,
1792
| LegacyV1ThreadImporter.LegacyV1ThreadImporter
1793
+ | ThreadWorktreeRestore
1794
| Orchestrator.OrchestratorV2
1795
| ProviderSessionManager.ProviderSessionManagerV2
1796
| ServerSettings.ServerSettingsService
apps/server/src/orchestration-v2/ThreadMessageIntake.ts
+1
@@ -27,6 +27,7 @@ function dispatchWasNotAccepted(
27
case "OrchestratorProviderSelectionBusyError":
28
case "OrchestratorRuntimeModeAboveCeilingError":
29
case "ThreadManagementProviderInstanceDisabledError":
30
+ case "ThreadManagementWorktreeRestoreError":
31
return true;
32
default:
33
return false;
apps/server/src/orchestration-v2/runtimeLayer.ts
+6
-6
@@ -47,6 +47,7 @@ import * as ProviderRuntimeRecoveryService from "./ProviderRuntimeRecoveryServic
47
import * as ProviderSwitchService from "./ProviderSwitchService.ts";
48
import * as ProviderTurnControlService from "./ProviderTurnControlService.ts";
49
import * as ProviderTurnStartService from "./ProviderTurnStartService.ts";
50
+import { layerThreadWorktreeRestore } from "../workspace/restoreMissingWorktree.ts";
51
import * as RunExecutionService from "./RunExecutionService.ts";
52
import * as RunFinalizationService from "./RunFinalizationService.ts";
53
import * as ResourceCleanupService from "./ResourceCleanupService.ts";
@@ -267,6 +268,7 @@ const layerThreadManagementProvided = ThreadManagementService.layerWithLegacyImp
268
layerLegacyV1ThreadImporterProvided,
269
layerCommandReceiptStoreProvided,
270
layerProviderSessionManagerProvided,
271
+ layerThreadWorktreeRestore,
272
),
273
),
274
);
@@ -281,14 +283,13 @@ const layerManagedProjectFoldersProvided = ManagedProjectFolders.layer.pipe(
283
const layerThreadLaunchProvided = ThreadLaunchService.layer.pipe(
284
Layer.provide(
285
Layer.mergeAll(
284
- layerProjectService,
286
layerProjectSetupScriptRunner,
287
layerManagedProjectFoldersProvided,
288
layerThreadManagementProvided,
289
layerCommandReceiptStoreProvided,
290
layerEventSink,
291
IdAllocator.layer,
291
- ),
292
+ ).pipe(Layer.provideMerge(layerProjectService)),
293
),
294
);
295
const layerSecretRequestsProvided = SecretRequests.layer.pipe(
@@ -307,11 +308,10 @@ const layerScheduledTaskProvided = ScheduledTaskService.layer.pipe(
308
const layerScratchThreadPromotionProvided = ScratchThreadPromotion.layer.pipe(
309
Layer.provide(
310
Layer.mergeAll(
310
- layerProjectService,
311
layerManagedProjectFoldersProvided,
312
layerThreadManagementProvided,
313
layerScheduledTaskProvided,
314
- ),
314
+ ).pipe(Layer.provideMerge(layerProjectService)),
315
),
316
);
317
const layerProviderContinuationWorkerProvided = ProviderContinuationService.layer.pipe(
@@ -389,8 +389,7 @@ export const layerProduction = Layer.mergeAll(
389
WorktreeBranchSync.layer.pipe(
390
Layer.provide(Layer.merge(layerThreadManagementProvided, ProjectionStore.layer)),
391
),
392
- layer.pipe(Layer.provide(layerProjectService)),
393
- layerProjectService,
392
+ layer,
393
layerManagedProjectFoldersProvided,
394
layerThreadLaunchProvided,
395
layerScheduledTaskProvided,
@@ -414,6 +413,7 @@ export const layerProduction = Layer.mergeAll(
413
EffectOutbox.layerPruneWorker.pipe(Layer.provide(EffectOutbox.layer)),
414
).pipe(
415
Layer.provide(ResourceCleanupService.layer.pipe(Layer.provide(layerScheduledTaskProvided))),
416
+ Layer.provideMerge(layerProjectService),
417
Layer.provide(Scheduler.layer),
418
Layer.provideMerge(layerEventInfrastructure),
419
);
apps/server/src/workspace/restoreMissingWorktree.ts
+29
-1
@@ -1,6 +1,8 @@
1
import { ThreadId, type ProjectId, type TerminalCwdNotFoundError } from "@t3tools/contracts";
2
+import * as Context from "effect/Context";
3
import * as Effect from "effect/Effect";
4
import * as FileSystem from "effect/FileSystem";
5
+import * as Layer from "effect/Layer";
6
import * as Option from "effect/Option";
7
import * as Path from "effect/Path";
8
import * as Schema from "effect/Schema";
@@ -9,9 +11,10 @@ import * as GitWorkflowService from "../git/GitWorkflowService.ts";
11
import * as ProjectService from "../project/ProjectService.ts";
12
import { makeIsManagedWorktreePath } from "../worktreesDirectory.ts";
13
import { isWithinRoot } from "./KnownWorkspaces.ts";
14
+import { withWorkspaceLease } from "./workspaceLease.ts";
15
import { TerminalCwdRecovery } from "../terminal/Manager.ts";
16
14
-class WorktreeRecreateError extends Schema.TaggedError<WorktreeRecreateError>()(
17
+export class WorktreeRecreateError extends Schema.TaggedError<WorktreeRecreateError>()(
18
"WorktreeRecreateError",
19
{
20
worktreePath: Schema.String,
@@ -166,6 +169,31 @@ export const makeRestoreMissingWorktree = Effect.gen(function* () {
169
});
170
});
171
172
+export class ThreadWorktreeRestore extends Context.Service<
173
+ ThreadWorktreeRestore,
174
+ {
175
+ readonly restore: (
176
+ thread: WorktreeThread,
177
+ ) => Effect.Effect<void, WorktreeRecreateError | WorktreeRecreateNoBaseError>;
178
+ }
179
+>()("t3/workspace/restoreMissingWorktree/ThreadWorktreeRestore") {}
180
+
181
+// Turn start restores under the same lease, so concurrent restores see each other's worktree.
182
+export const layerThreadWorktreeRestore = Layer.effect(
183
+ ThreadWorktreeRestore,
184
+ Effect.gen(function* () {
185
+ const path = yield* Path.Path;
186
+ const restore = yield* makeRestoreMissingWorktree;
187
+ return {
188
+ restore: Effect.fn("ThreadWorktreeRestore.restore")(function* (thread: WorktreeThread) {
189
+ return yield* thread.worktreePath === null
190
+ ? restore(thread)
191
+ : withWorkspaceLease(path.resolve(thread.worktreePath), restore(thread));
192
+ }),
193
+ };
194
+ }),
195
+);
196
+
197
// Worktree setup uses terminals, so recovery must stay outside TerminalManager.
198
export const makePrepareTerminalLaunch = Effect.fn(
199
"restoreMissingWorktree.makePrepareTerminalLaunch",