Skip to content

Commit f9013fa

Browse files
committed
fix(server): stop worktree setup when delegated tasks are cancelled
1 parent ab14b2e commit f9013fa

2 files changed

Lines changed: 115 additions & 31 deletions

File tree

‎apps/server/src/orchestration-v2/ThreadLaunchService.test.ts‎

Lines changed: 68 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -100,6 +100,7 @@ const adapter = {
100100
} as ProviderAdapter.ProviderAdapterV2["Service"];
101101

102102
interface HarnessOptions {
103+
readonly closeTerminal?: TerminalManager.TerminalManager["Service"]["close"];
103104
readonly adapters?: ReadonlyArray<ProviderAdapter.ProviderAdapterV2["Service"]>;
104105
readonly managedFolders?: Layer.Layer<ManagedProjectFolders.ManagedProjectFolders>;
105106
readonly createWorktree?: GitWorkflow.GitWorkflowService["Service"]["createWorktree"];
@@ -147,6 +148,7 @@ function makeHarness(options: HarnessOptions = {}) {
147148
const runSetup = vi.fn(
148149
options.runSetup ?? (() => Effect.succeed({ status: "no-script" as const })),
149150
);
151+
const closeTerminal = vi.fn(options.closeTerminal ?? (() => Effect.void));
150152
const generateBranchName = vi.fn(
151153
options.generateBranchName ?? (() => Effect.succeed({ branch: "generated-branch" })),
152154
);
@@ -156,7 +158,7 @@ function makeHarness(options: HarnessOptions = {}) {
156158
const layerExternalServices = Layer.mergeAll(
157159
WorktreeSetupTracker.layer,
158160
Layer.mock(ProjectCloneTracker.ProjectCloneTracker)({ get: () => Effect.succeed(null) }),
159-
Layer.mock(TerminalManager.TerminalManager)({ close: () => Effect.void }),
161+
Layer.mock(TerminalManager.TerminalManager)({ close: closeTerminal }),
160162
Layer.succeed(ProjectService.ProjectService, {
161163
create: () => Effect.die("unused"),
162164
bootstrap: () => Effect.die("unused"),
@@ -254,6 +256,7 @@ function makeHarness(options: HarnessOptions = {}) {
254256
generateBranchName,
255257
generateThreadTitle,
256258
runSetup,
259+
closeTerminal,
257260
};
258261
}
259262

@@ -2718,14 +2721,17 @@ it.effect.each(
27182721
{ failSetup: false, failResolve: false },
27192722
{ failSetup: true, failResolve: false },
27202723
{ failSetup: false, failResolve: true },
2721-
].map((failures) => ({ driver, ...failures })),
2724+
{ failSetup: false, failResolve: false, cancelSetup: true },
2725+
{ failSetup: false, failResolve: false, cancelSetup: true, cancelAsync: true },
2726+
].map((failures) => ({ driver, cancelSetup: false, cancelAsync: false, ...failures })),
27222727
),
27232728
)(
2724-
"prepares $driver delegated worktrees before execution, setup failure=$failSetup, commit failure=$failResolve",
2725-
({ driver, failSetup, failResolve }) =>
2729+
"prepares $driver delegated worktrees before execution, setup failure=$failSetup, commit failure=$failResolve, cancellation=$cancelSetup, async=$cancelAsync",
2730+
({ driver, failSetup, failResolve, cancelSetup, cancelAsync }) =>
27262731
Effect.gen(function* () {
27272732
const setupEntered = yield* Deferred.make<void>();
27282733
const allowSetup = yield* Deferred.make<void>();
2734+
const terminalClosed = yield* Deferred.make<void>();
27292735
const childInstanceId = ProviderInstanceId.make(`child-${driver}`);
27302736
const parentWorktree = driver === "codex" ? null : "/parent-worktree";
27312737
const resolveCommit = vi.fn(() =>
@@ -2741,6 +2747,7 @@ it.effect.each(
27412747
: Effect.succeed({ commitSha: "parent-local-commit" }),
27422748
);
27432749
const harness = makeHarness({
2750+
closeTerminal: () => Deferred.succeed(terminalClosed, undefined).pipe(Effect.asVoid),
27442751
adapters: [
27452752
adapter,
27462753
{ ...adapter, instanceId: childInstanceId, driver: ProviderDriverKind.make(driver) },
@@ -2767,21 +2774,35 @@ it.effect.each(
27672774
},
27682775
],
27692776
runSetup: () =>
2770-
Deferred.succeed(setupEntered, undefined).pipe(
2771-
Effect.andThen(Deferred.await(allowSetup)),
2772-
Effect.andThen(
2773-
failSetup
2774-
? Effect.fail(
2775-
new ProjectSetupScriptRunner.ProjectSetupScriptOperationError({
2776-
threadId: "child",
2777-
worktreePath: "/repo-worktrees/feature",
2778-
operation: "writeCommand",
2779-
cause: "setup failed",
2780-
}),
2781-
)
2782-
: Effect.succeed({ status: "no-script" as const }),
2783-
),
2784-
),
2777+
cancelSetup
2778+
? Effect.succeed({
2779+
status: "started" as const,
2780+
async: cancelAsync,
2781+
scriptId: "setup",
2782+
scriptName: "Setup",
2783+
scriptCommand: "setup",
2784+
terminalId: "setup",
2785+
cwd: "/repo-worktrees/feature",
2786+
completion: Deferred.succeed(setupEntered, undefined).pipe(
2787+
Effect.andThen(Deferred.await(allowSetup)),
2788+
Effect.as({ exitCode: 0, durationMs: 0 }),
2789+
),
2790+
})
2791+
: Deferred.succeed(setupEntered, undefined).pipe(
2792+
Effect.andThen(Deferred.await(allowSetup)),
2793+
Effect.andThen(
2794+
failSetup
2795+
? Effect.fail(
2796+
new ProjectSetupScriptRunner.ProjectSetupScriptOperationError({
2797+
threadId: "child",
2798+
worktreePath: "/repo-worktrees/feature",
2799+
operation: "writeCommand",
2800+
cause: "setup failed",
2801+
}),
2802+
)
2803+
: Effect.succeed({ status: "no-script" as const }),
2804+
),
2805+
),
27852806
});
27862807
const layerService = OrchestratorMcpService.layer.pipe(
27872808
Layer.provide(NodeCrypto.layer),
@@ -2850,7 +2871,7 @@ it.effect.each(
28502871
const child = yield* threads.getThreadProjection(delegated.childThreadId);
28512872
assert.equal(child.thread.lineage.parentThreadId, parentThreadId);
28522873
assert.equal(child.thread.worktreePath, "/repo-worktrees/feature");
2853-
assert.equal(child.runs[0]?.status, "preparing");
2874+
assert.equal(child.runs[0]?.status, cancelAsync ? "starting" : "preparing");
28542875
assert.equal(child.thread.modelSelection.instanceId, childInstanceId);
28552876
assert.equal(child.thread.modelSelection.model, "child-model");
28562877
assert.deepEqual(resolveCommit.mock.calls, [
@@ -2860,10 +2881,36 @@ it.effect.each(
28602881
assert.equal((yield* service.delegateTask(scope, input)).taskId, delegated.taskId);
28612882
assert.equal(harness.createWorktree.mock.calls.length, 1);
28622883
assert.equal(resolveCommit.mock.calls.length, 1);
2863-
assert.isEmpty(child.checkpointScopes);
2884+
if (!cancelAsync) assert.isEmpty(child.checkpointScopes);
28642885
const parent = yield* threads.getThreadProjection(parentThreadId);
28652886
assert.equal(parent.thread.worktreePath, parentWorktree);
28662887
assert.equal(parent.thread.branch, "parent-feature");
2888+
if (cancelSetup) {
2889+
yield* service.cancelTask(scope, { taskId: delegated.taskId });
2890+
yield* Deferred.await(terminalClosed);
2891+
if (!cancelAsync) {
2892+
yield* threads.streamStoredEventsFrom({ threadId: delegated.childThreadId }).pipe(
2893+
Stream.filter(
2894+
(stored) =>
2895+
stored.event.type === "thread.metadata-updated" &&
2896+
stored.event.payload.worktreePath === null,
2897+
),
2898+
Stream.runHead,
2899+
);
2900+
}
2901+
assert.equal(harness.closeTerminal.mock.calls.length, 1);
2902+
assert.equal(harness.removeWorktree.mock.calls.length, cancelAsync ? 0 : 1);
2903+
const cancelled = yield* threads.getThreadProjection(delegated.childThreadId);
2904+
assert.equal(cancelled.runs[0]?.status, "interrupted");
2905+
if (cancelAsync) {
2906+
assert.equal(cancelled.thread.worktreePath, "/repo-worktrees/feature");
2907+
assert.equal(cancelled.checkpointScopes[0]?.cwd, "/repo-worktrees/feature");
2908+
} else {
2909+
assert.isNull(cancelled.thread.worktreePath);
2910+
assert.isEmpty(cancelled.checkpointScopes);
2911+
}
2912+
return;
2913+
}
28672914
yield* Deferred.succeed(allowSetup, undefined);
28682915
yield* threads
28692916
.streamStoredEventsFrom({ threadId: delegated.childThreadId, eventType: "run.updated" })

‎apps/server/src/orchestration-v2/ThreadLaunchService.ts‎

Lines changed: 47 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,7 @@ import * as Option from "effect/Option";
2828
import * as Ref from "effect/Ref";
2929
import * as Schema from "effect/Schema";
3030
import * as Scope from "effect/Scope";
31+
import * as Stream from "effect/Stream";
3132
import {
3233
buildTemporaryWorktreeBranchName,
3334
flattenTemporaryWorktreeBranchName,
@@ -318,6 +319,7 @@ const make = Effect.gen(function* () {
318319
let createdWorktreePath: string | null = null;
319320
let setupTerminalId: string | null = null;
320321
let workspaceRecorded = false;
322+
let runReleased = false;
321323
if (input.workspaceStrategy.type === "worktree") {
322324
yield* setupTracker.begin({
323325
threadId,
@@ -624,7 +626,15 @@ const make = Effect.gen(function* () {
624626
threadId,
625627
runId,
626628
})
627-
.pipe(Effect.mapError(mapError(input, "release-run", threadId)));
629+
.pipe(
630+
Effect.mapError(mapError(input, "release-run", threadId)),
631+
Effect.tap(() =>
632+
Effect.sync(() => {
633+
runReleased = true;
634+
}),
635+
),
636+
Effect.uninterruptible,
637+
);
628638
}
629639
yield* setupTracker.stageStatus(threadId, "agent", "done");
630640
yield* awaitAsyncSetup;
@@ -638,14 +648,15 @@ const make = Effect.gen(function* () {
638648
cancelled ? "cancelled" : "failed",
639649
cancelled ? null : failureDetail(Cause.squash(cause)),
640650
);
641-
// A cancelled setup leaves nothing behind. A failed one keeps a worktree
642-
// the thread recorded, so a retry reuses it, and removes one it never
643-
// recorded, which a retry would otherwise duplicate.
644-
if (tracked && createdWorktreePath && (cancelled || !workspaceRecorded)) {
645-
if (setupTerminalId)
646-
yield* terminals
647-
.close({ threadId, terminalId: setupTerminalId, deleteHistory: true })
648-
.pipe(Effect.ignore);
651+
if (cancelled && setupTerminalId)
652+
yield* terminals
653+
.close({ threadId, terminalId: setupTerminalId, deleteHistory: true })
654+
.pipe(Effect.ignore);
655+
if (
656+
tracked &&
657+
createdWorktreePath &&
658+
((cancelled && !runReleased) || !workspaceRecorded)
659+
) {
649660
const removedPath = createdWorktreePath;
650661
// The thread forgets the worktree only once it is gone; a failed
651662
// removal leaves the directory for the user to clean up rather than
@@ -735,7 +746,33 @@ const make = Effect.gen(function* () {
735746
threadId: ThreadId,
736747
runId: RunId | null,
737748
) {
738-
yield* prepareInBackground(input, threadId, runId).pipe(
749+
const preparation = Effect.gen(function* () {
750+
const prepare = prepareInBackground(input, threadId, runId);
751+
if (
752+
runId === null ||
753+
(input.workspaceStrategy.type !== "worktree" && input.reusedWorktree === undefined)
754+
) {
755+
return yield* prepare;
756+
}
757+
const afterSequence = yield* threads.getThreadEventSequence(threadId);
758+
const projection = yield* threads.getThreadRecords(threadId, ["runs"]);
759+
if (projection.runs.find((run) => run.id === runId)?.status !== "preparing") return;
760+
const interruption = threads
761+
.streamStoredEventsFrom({ threadId, afterSequence, eventType: "run.updated" })
762+
.pipe(
763+
Stream.filter(
764+
(stored) =>
765+
stored.event.type === "run.updated" &&
766+
stored.event.payload.id === runId &&
767+
(stored.event.payload.status === "interrupted" ||
768+
stored.event.payload.status === "cancelled"),
769+
),
770+
Stream.runHead,
771+
Effect.flatMap((event) => (Option.isSome(event) ? Effect.interrupt : Effect.never)),
772+
);
773+
yield* Effect.raceFirst(prepare, interruption);
774+
});
775+
yield* preparation.pipe(
739776
Effect.onError((cause) =>
740777
failPreparedRun(
741778
input,

0 commit comments

Comments
 (0)