@devries-cameron20 / t3code Mirror · read-only / commits / d70bfe6e97
Fork 0

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",