@devries-cameron20 / t3code Mirror · read-only / commits / a49a3f771b
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 22, 13:15 UTC

fix(server): session stops no longer trigger storage sweeps unless a deleted worktree waits (#26038)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Julius Marminge committed Oct 29, 2026 at 10:52 UTC a49a3f771b4566d79e93a85afc3480a60c33bfed
2 files changed +412 -32
apps/server/src/storageCleanup.test.ts
+354 -13
@@ -16,6 +16,8 @@ import {
16 DEFAULT_SERVER_SETTINGS,
17 type WorktreeKeepWhen,
18 type StorageCleanupSettings,
19 + type TerminalMetadataStreamEvent,
20 + type TerminalSummary,
21 } from "@t3tools/contracts";
22 import * as HostProcess from "@t3tools/shared/HostProcess";
23 import * as ServerConfig from "./config.ts";
@@ -32,8 +34,11 @@ import { CodexProviderCapabilitiesV2 } from "./orchestration-v2/Adapters/CodexAd
34 import { ServerActivation } from "./serverActivation.ts";
35 import { describe, expect, it } from "@effect/vitest";
36 import {
37 + EventId,
38 ProjectId,
39 + ProviderDriverKind,
40 ProviderInstanceId,
41 + ProviderSessionId,
42 RunId,
43 RuntimeRequestId,
44 ThreadId,
@@ -268,8 +273,11 @@ const cleanupFixture = (
273 let editBeforeRemoval = false;
274 let openSessionCwd: string | null = null;
275 let sessionLive = true;
276 + let onLiveCheck: Effect.Effect<void> = Effect.void;
277 + let outboxStatus: string | null = null;
278 let fullStatusCalls = 0;
279 let snapshotReads = 0;
280 + let terminalListener: ((event: TerminalMetadataStreamEvent) => Effect.Effect<void>) | undefined;
281 let events: Stream.Stream<OrchestrationV2DomainEvent> = Stream.empty;
282 const activated = yield* Deferred.make<void>();
283 const context = yield* Layer.build(StorageCleanup.layer).pipe(
@@ -335,7 +343,8 @@ const cleanupFixture = (
343 Effect.sync(() => threads.find((thread) => thread.id === threadId) ?? null),
344 } as unknown as ProjectionStore.ProjectionStoreV2["Service"]),
345 Effect.provideService(ProviderSessionManager.ProviderSessionManagerV2, {
338 - isLive: () => Effect.sync(() => sessionLive),
346 + isLive: () =>
347 + Effect.sync(() => sessionLive).pipe(Effect.tap(() => Effect.suspend(() => onLiveCheck))),
348 } as unknown as ProviderSessionManager.ProviderSessionManagerV2["Service"]),
349 Effect.provideService(Orchestrator.OrchestratorV2, {
350 streamDomainEvents: Stream.suspend(() => events),
@@ -359,29 +368,39 @@ const cleanupFixture = (
368 }),
369 },
370 ]
362 - : strings.join("").includes("deleted_at IS NOT NULL")
363 - ? deletedThreads.map((thread) => ({
364 - payload_json: JSON.stringify(thread),
365 - workspaceRoot: repo,
366 - }))
367 - : strings.join("").includes('AS "worktreePath"')
368 - ? [
369 - ...threads.flatMap((thread) => thread.worktreePath ?? []),
370 - ...storedWorktreePaths,
371 - ].map((worktreePath) => ({ worktreePath }))
372 - : [],
371 + : outboxStatus !== null && strings.join("").includes("orchestration_v2_effect_outbox")
372 + ? [{ status: outboxStatus }]
373 + : strings.join("").includes("deleted_at IS NOT NULL")
374 + ? deletedThreads.map((thread) => ({
375 + payload_json: JSON.stringify(thread),
376 + workspaceRoot: repo,
377 + }))
378 + : strings.join("").includes('AS "worktreePath"')
379 + ? [
380 + ...threads.flatMap((thread) => thread.worktreePath ?? []),
381 + ...storedWorktreePaths,
382 + ].map((worktreePath) => ({ worktreePath }))
383 + : [],
384 )) as unknown as SqlClient.SqlClient),
385 Effect.provideService(GitManager.GitManager, {
386 invalidateStatus: () => Effect.void,
387 } as unknown as GitManager.GitManager["Service"]),
388 Effect.provideService(TerminalManager.TerminalManager, {
378 - subscribeMetadata: () => Effect.succeed(() => {}),
389 + subscribeMetadata: (
390 + listener: (event: TerminalMetadataStreamEvent) => Effect.Effect<void>,
391 + ) =>
392 + Effect.sync(() => {
393 + terminalListener = listener;
394 + return () => {};
395 + }),
396 } as unknown as TerminalManager.TerminalManager["Service"]),
397 Effect.provideService(ServerActivation, Deferred.await(activated)),
398 );
399 return {
400 service: Context.get(context, StorageCleanup.StorageCleanup),
401 repo,
402 + setTerminals: (terminals: TerminalSummary[]) =>
403 + terminalListener?.({ type: "snapshot", terminals }) ?? Effect.void,
404 editBeforeRemoval: () => {
405 editBeforeRemoval = true;
406 },
@@ -421,6 +440,12 @@ const cleanupFixture = (
440 setThreads: (next: typeof threads) => {
441 threads = next;
442 },
443 + setOnLiveCheck: (hook: Effect.Effect<void>) => {
444 + onLiveCheck = hook;
445 + },
446 + setOutboxStatus: (status: string | null) => {
447 + outboxStatus = status;
448 + },
449 setDeletedThreads: (next: OrchestrationV2ThreadShell[]) => {
450 deletedThreads = next;
451 },
@@ -925,6 +950,322 @@ describe("deleted thread worktrees", () => {
950 }).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
951 );
952
953 + // Releases one stopped-session event after the startup sweep and returns the snapshot reads it caused.
954 + const stopSessionAfterStartupSweep = (
955 + fixture: Effect.Success<ReturnType<typeof cleanupFixture>>,
956 + threadId: ThreadId,
957 + beforeStop: Effect.Effect<void> = Effect.void,
958 + cwd = fixture.worktree,
959 + ) =>
960 + Effect.gen(function* () {
961 + const startupSwept = yield* Deferred.make<void>();
962 + const delivered = yield* Deferred.make<void>();
963 + const stopped: OrchestrationV2DomainEvent = {
964 + id: EventId.make("event:session-stopped"),
965 + type: "provider-session.updated",
966 + threadId,
967 + occurredAt: at(0),
968 + payload: {
969 + id: ProviderSessionId.make("session-1"),
970 + driver: ProviderDriverKind.make("codex"),
971 + providerInstanceId: ProviderInstanceId.make("codex"),
972 + status: "stopped",
973 + cwd,
974 + model: null,
975 + capabilities: CodexProviderCapabilitiesV2,
976 + createdAt: at(-DAY_MS),
977 + updatedAt: at(0),
978 + lastError: null,
979 + },
980 + };
981 + yield* fixture.activate(
982 + Stream.fromEffect(Deferred.await(startupSwept)).pipe(
983 + Stream.flatMap(() => Stream.make(stopped)),
984 + Stream.concat(
985 + Stream.fromEffect(Deferred.succeed(delivered, undefined)).pipe(Stream.drain),
986 + ),
987 + ),
988 + );
989 + yield* fixture.service.reports.pipe(
990 + Stream.filter((report) => report !== null),
991 + Stream.take(1),
992 + Stream.runDrain,
993 + );
994 + yield* fixture.service.drain;
995 + yield* beforeStop;
996 + const readsBefore = fixture.snapshotReads();
997 + yield* Deferred.succeed(startupSwept, undefined);
998 + yield* Deferred.await(delivered);
999 + yield* fixture.service.drain;
1000 + return fixture.snapshotReads() - readsBefore;
1001 + });
1002 +
1003 + it.effect("does not sweep when a live thread's session stops and no deleted worktree waits", () =>
1004 + Effect.gen(function* () {
1005 + yield* TestClock.setTime(NOW_MS);
1006 + const fixture = yield* cleanupFixture();
1007 + const reads = yield* stopSessionAfterStartupSweep(fixture, ThreadId.make("thread-1"));
1008 + expect(reads, "a live thread's stopped session re-read every thread").toBe(0);
1009 + }).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
1010 + );
1011 +
1012 + it.effect("removes a deleted thread's worktree once its session stops", () =>
1013 + Effect.gen(function* () {
1014 + yield* TestClock.setTime(NOW_MS);
1015 + const fixture = yield* cleanupFixture({
1016 + ...DEFAULT_SERVER_SETTINGS.storageCleanup,
1017 + worktreeAfterDays: null,
1018 + worktreeOnDelete: true,
1019 + });
1020 + const owner = parent(fixture.worktree);
1021 + fixture.setDeletedThreads([owner]);
1022 + fixture.setThreads([]);
1023 + fixture.setOpenSessionCwd(fixture.worktree);
1024 + const reads = yield* stopSessionAfterStartupSweep(
1025 + fixture,
1026 + owner.id,
1027 + Effect.sync(() => fixture.setSessionLive(false)),
1028 + );
1029 + expect(reads).toBeGreaterThan(0);
1030 + expect(yield* fixture.fs.exists(fixture.worktree)).toBe(false);
1031 + }).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
1032 + );
1033 +
1034 + it.effect("removes a deleted thread's worktree once a live thread's session in it stops", () =>
1035 + Effect.gen(function* () {
1036 + yield* TestClock.setTime(NOW_MS);
1037 + const fixture = yield* cleanupFixture({
1038 + ...DEFAULT_SERVER_SETTINGS.storageCleanup,
1039 + worktreeAfterDays: null,
1040 + worktreeOnDelete: true,
1041 + });
1042 + const owner = parent(fixture.worktree);
1043 + const child = subagent(owner);
1044 + fixture.setDeletedThreads([owner]);
1045 + fixture.setThreads([child]);
1046 + fixture.setOpenSessionCwd(fixture.worktree);
1047 + const reads = yield* stopSessionAfterStartupSweep(
1048 + fixture,
1049 + child.id,
1050 + Effect.gen(function* () {
1051 + expect((yield* fixture.service.latestReport)?.entries[0]).toMatchObject({
1052 + threadId: owner.id,
1053 + outcome: "kept",
1054 + reason: "Provider session is still open",
1055 + });
1056 + fixture.setSessionLive(false);
1057 + }),
1058 + );
1059 + expect(reads).toBeGreaterThan(0);
1060 + expect(yield* fixture.fs.exists(fixture.worktree)).toBe(false);
1061 + }).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
1062 + );
1063 +
1064 + it.effect(
1065 + "removes a deleted thread's worktree once its terminal closes and its session stops",
1066 + () =>
1067 + Effect.gen(function* () {
1068 + yield* TestClock.setTime(NOW_MS);
1069 + const fixture = yield* cleanupFixture({
1070 + ...DEFAULT_SERVER_SETTINGS.storageCleanup,
1071 + worktreeAfterDays: null,
1072 + worktreeOnDelete: true,
1073 + });
1074 + const owner = parent(fixture.worktree);
1075 + fixture.setDeletedThreads([owner]);
1076 + fixture.setThreads([]);
1077 + yield* fixture.setTerminals([
1078 + {
1079 + threadId: owner.id,
1080 + terminalId: "terminal-1",
1081 + cwd: fixture.worktree,
1082 + worktreePath: fixture.worktree,
1083 + status: "running",
1084 + pid: 1,
1085 + exitCode: null,
1086 + exitSignal: null,
1087 + hasRunningSubprocess: false,
1088 + label: "Terminal",
1089 + updatedAt: DateTime.formatIso(at(0)),
1090 + },
1091 + ]);
1092 + const reads = yield* stopSessionAfterStartupSweep(
1093 + fixture,
1094 + owner.id,
1095 + Effect.gen(function* () {
1096 + expect((yield* fixture.service.latestReport)?.entries[0]).toMatchObject({
1097 + threadId: owner.id,
1098 + outcome: "kept",
1099 + reason: "Open terminal",
1100 + });
1101 + yield* fixture.setTerminals([]);
1102 + }),
1103 + fixture.repo,
1104 + );
1105 + expect(reads).toBeGreaterThan(0);
1106 + expect(yield* fixture.fs.exists(fixture.worktree)).toBe(false);
1107 + }).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
1108 + );
1109 +
1110 + it.effect(
1111 + "retries a deleted thread's worktree kept for another reason when a session in it stops",
1112 + () =>
1113 + Effect.gen(function* () {
1114 + yield* TestClock.setTime(NOW_MS);
1115 + const fixture = yield* cleanupFixture({
1116 + ...DEFAULT_SERVER_SETTINGS.storageCleanup,
1117 + worktreeAfterDays: null,
1118 + worktreeOnDelete: true,
1119 + });
1120 + const owner = parent(fixture.worktree);
1121 + fixture.setDeletedThreads([owner]);
1122 + fixture.setThreads([]);
1123 + yield* fixture.fs.writeFileString(`${fixture.worktree}/tracked.txt`, "agent edit\n");
1124 + const reads = yield* stopSessionAfterStartupSweep(
1125 + fixture,
1126 + owner.id,
1127 + Effect.gen(function* () {
1128 + expect((yield* fixture.service.latestReport)?.entries[0]).toMatchObject({
1129 + threadId: owner.id,
1130 + outcome: "kept",
1131 + reason: "Has uncommitted changes (1 file)",
1132 + });
1133 + yield* fixture.fs
1134 + .writeFileString(`${fixture.worktree}/tracked.txt`, "original\n")
1135 + .pipe(Effect.orDie);
1136 + }),
1137 + );
1138 + expect(reads).toBeGreaterThan(0);
1139 + expect(yield* fixture.fs.exists(fixture.worktree)).toBe(false);
1140 + }).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
1141 + );
1142 +
1143 + it.effect("does not sweep for a kept deleted worktree when a session elsewhere stops", () =>
1144 + Effect.gen(function* () {
1145 + yield* TestClock.setTime(NOW_MS);
1146 + const fixture = yield* cleanupFixture({
1147 + ...DEFAULT_SERVER_SETTINGS.storageCleanup,
1148 + worktreeAfterDays: null,
1149 + worktreeOnDelete: true,
1150 + });
1151 + fixture.setDeletedThreads([parent(fixture.worktree)]);
1152 + fixture.setThreads([]);
1153 + yield* fixture.fs.writeFileString(`${fixture.worktree}/tracked.txt`, "agent edit\n");
1154 + const reads = yield* stopSessionAfterStartupSweep(
1155 + fixture,
1156 + ThreadId.make("thread-elsewhere"),
1157 + Effect.void,
1158 + fixture.repo,
1159 + );
1160 + expect(reads).toBe(0);
1161 + expect(yield* fixture.fs.exists(fixture.worktree)).toBe(true);
1162 + }).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
1163 + );
1164 +
1165 + it.effect(
1166 + "does not sweep for a deleted thread whose cleanup effect failed when a session elsewhere stops",
1167 + () =>
1168 + Effect.gen(function* () {
1169 + yield* TestClock.setTime(NOW_MS);
1170 + const fixture = yield* cleanupFixture({
1171 + ...DEFAULT_SERVER_SETTINGS.storageCleanup,
1172 + worktreeAfterDays: null,
1173 + worktreeOnDelete: true,
1174 + });
1175 + const owner = parent(fixture.worktree);
1176 + fixture.setDeletedThreads([owner]);
1177 + fixture.setThreads([]);
1178 + fixture.setOutboxStatus("failed");
1179 + const reads = yield* stopSessionAfterStartupSweep(
1180 + fixture,
1181 + ThreadId.make("thread-elsewhere"),
1182 + Effect.gen(function* () {
1183 + expect((yield* fixture.service.latestReport)?.entries[0]).toMatchObject({
1184 + threadId: owner.id,
1185 + outcome: "kept",
1186 + reason: "Thread deletion is still pending",
1187 + });
1188 + }),
1189 + fixture.repo,
1190 + );
1191 + expect(reads).toBe(0);
1192 + }).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
1193 + );
1194 +
1195 + it.effect(
1196 + "removes a deleted thread's worktree when its session stops during the deletion's sweep",
1197 + () =>
1198 + Effect.gen(function* () {
1199 + yield* TestClock.setTime(NOW_MS);
1200 + const fixture = yield* cleanupFixture({
1201 + ...DEFAULT_SERVER_SETTINGS.storageCleanup,
1202 + worktreeAfterDays: null,
1203 + worktreeOnDelete: true,
1204 + });
1205 + const owner = parent(fixture.worktree);
1206 + fixture.setThreads([]);
1207 + const startupSwept = yield* Deferred.make<void>();
1208 + const sessionChecked = yield* Deferred.make<void>();
1209 + const delivered = yield* Deferred.make<void>();
1210 + const deleted = {
1211 + id: EventId.make("event:thread-deleted"),
1212 + type: "thread.deleted",
1213 + threadId: owner.id,
1214 + occurredAt: at(0),
1215 + payload: owner,
1216 + } as unknown as OrchestrationV2DomainEvent;
1217 + const stopped: OrchestrationV2DomainEvent = {
1218 + id: EventId.make("event:session-stopped"),
1219 + type: "provider-session.updated",
1220 + threadId: owner.id,
1221 + occurredAt: at(0),
1222 + payload: {
1223 + id: ProviderSessionId.make("session-1"),
1224 + driver: ProviderDriverKind.make("codex"),
1225 + providerInstanceId: ProviderInstanceId.make("codex"),
1226 + status: "stopped",
1227 + cwd: fixture.worktree,
1228 + model: null,
1229 + capabilities: CodexProviderCapabilitiesV2,
1230 + createdAt: at(-DAY_MS),
1231 + updatedAt: at(0),
1232 + lastError: null,
1233 + },
1234 + };
1235 + yield* fixture.activate(
1236 + Stream.fromEffect(Deferred.await(startupSwept)).pipe(
1237 + Stream.flatMap(() => Stream.make(deleted)),
1238 + Stream.concat(Stream.fromEffect(Deferred.await(sessionChecked)).pipe(Stream.drain)),
1239 + Stream.concat(Stream.make(stopped)),
1240 + Stream.concat(
1241 + Stream.fromEffect(Deferred.succeed(delivered, undefined)).pipe(Stream.drain),
1242 + ),
1243 + ),
1244 + );
1245 + yield* fixture.service.reports.pipe(
1246 + Stream.filter((report) => report !== null),
1247 + Stream.take(1),
1248 + Stream.runDrain,
1249 + );
1250 + yield* fixture.service.drain;
1251 + fixture.setDeletedThreads([owner]);
1252 + fixture.setOpenSessionCwd(fixture.worktree);
1253 + // The deletion's sweep sees the session live; it stops before that sweep publishes its result.
1254 + fixture.setOnLiveCheck(
1255 + Effect.gen(function* () {
1256 + fixture.setOnLiveCheck(Effect.void);
1257 + yield* Deferred.succeed(sessionChecked, undefined);
1258 + yield* Deferred.await(delivered);
1259 + fixture.setSessionLive(false);
1260 + }),
1261 + );
1262 + yield* Deferred.succeed(startupSwept, undefined);
1263 + yield* Deferred.await(delivered);
1264 + yield* fixture.service.drain;
1265 + expect(yield* fixture.fs.exists(fixture.worktree)).toBe(false);
1266 + }).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
1267 + );
1268 +
1269 it.effect("waits out the settle grace of a subagent that just settled", () =>
1270 Effect.gen(function* () {
1271 yield* TestClock.setTime(NOW_MS);
apps/server/src/storageCleanup.ts
+58 -19
@@ -705,7 +705,10 @@ const make = Effect.gen(function* () {
705 now: number,
706 entries: StorageCleanupReportEntry[],
707 ) {
708 - if (!anyWorktreePolicy(serverSettings, worktreeCleanupEnabled)) return;
708 + if (!anyWorktreePolicy(serverSettings, worktreeCleanupEnabled))
709 + return { waiting: false, kept: [] };
710 + let waiting = false;
711 + const kept: string[] = [];
712 const roots: Array<string> = [];
713 for (const directory of managedWorktreesDirectories(
714 serverSettings,
@@ -779,7 +782,15 @@ const make = Effect.gen(function* () {
782 bytes: null,
783 files: null,
784 };
782 - const keep = (reason: string) => entries.push({ ...entry, reason: sentence(reason) });
785 + const keep = (reason: string) => {
786 + if (deleted && settings.worktreeOnDelete) kept.push(worktreePath);
787 + entries.push({ ...entry, reason: sentence(reason) });
788 + };
789 + // Reasons a provider session stop or finished deletion work can clear.
790 + const waitForStop = (reason: string) => {
791 + if (deleted && settings.worktreeOnDelete) waiting = true;
792 + return reason;
793 + };
794 yield* Effect.gen(function* () {
795 if (!(yield* fs.exists(worktreePath))) return;
796 if (deleted && !settings.worktreeOnDelete) return keep("no rules apply");
@@ -790,10 +801,10 @@ const make = Effect.gen(function* () {
801 thread.branch === null ||
802 !group.every((member) => storageCleanupThreadIdle(member, now))
803 )
793 - return keep("thread is running or has pending work");
804 + return keep(waitForStop("thread is running or has pending work"));
805 if (group.some((member) => member.branch !== thread.branch))
806 return keep("a subagent thread's branch differs from this worktree's branch");
796 - if (hasTerminal(worktreePath)) return keep("open terminal");
807 + if (hasTerminal(worktreePath)) return keep(waitForStop("open terminal"));
808 // Compare canonical roots while allowing symlinked parents, never symlinked worktree directories.
809 const realPath = yield* fs.realPath(worktreePath);
810 const realParent = yield* fs.realPath(path.dirname(worktreePath));
@@ -817,7 +828,7 @@ const make = Effect.gen(function* () {
828 SETTLE_SCRIPT_GRACE_MS,
829 )
830 )
820 - return keep("settled moments ago");
831 + return keep(waitForStop("settled moments ago"));
832 const head = yield* git.resolveCommit({ cwd: worktreePath, revision: "HEAD" });
833 const old =
834 !deleted &&
@@ -924,7 +935,7 @@ const make = Effect.gen(function* () {
935 const latest = (yield* projections.getThreadWorktreePaths({
936 includeArchived: true,
937 })).filter((entry) => path.resolve(entry.worktreePath) === worktreePath);
927 - if (hasTerminal(worktreePath)) return "open terminal";
938 + if (hasTerminal(worktreePath)) return waitForStop("open terminal");
939 if (deleted) {
940 if (
941 !resolveWorktreeCleanup(yield* settingsService.getSettings, thread.projectId)
@@ -932,10 +943,13 @@ const make = Effect.gen(function* () {
943 )
944 return "thread or cleanup settings changed since check";
945 // Durable deletion cleanup must succeed or be explicitly cancelled before removing its checkout.
935 - const pendingCleanup = yield* sql`
936 - SELECT 1 FROM orchestration_v2_effect_outbox
937 - WHERE thread_id = ${thread.id} AND status NOT IN ('succeeded', 'cancelled') LIMIT 1
946 + const pendingCleanup = yield* sql<{ status: string }>`
947 + SELECT status FROM orchestration_v2_effect_outbox
948 + WHERE thread_id = ${thread.id} AND status NOT IN ('succeeded', 'cancelled')
949 `.pipe(NodeSqliteClient.readOnly);
950 + // Failed effects never retry, so only running work can finish and free the path.
951 + if (pendingCleanup.some((row) => row.status !== "failed"))
952 + return waitForStop("thread deletion is still pending");
953 if (pendingCleanup.length > 0) return "thread deletion is still pending";
954 }
955 const latestShells = yield* Effect.forEach(latest, (entry) =>
@@ -960,7 +974,7 @@ const make = Effect.gen(function* () {
974 );
975 })
976 )
963 - return "thread activity or shared worktree changed since check";
977 + return waitForStop("thread activity or shared worktree changed since check");
978 // Sessions can outlive their run and can be shared across app threads.
979 const sessionRows = yield* sql<{ payload_json: string }>`
980 SELECT payload_json FROM orchestration_v2_projection_provider_sessions
@@ -976,7 +990,7 @@ const make = Effect.gen(function* () {
990 (cwd === worktreePath || inside(worktreePath, cwd)) &&
991 (yield* providerSessions.isLive(session.id))
992 )
979 - return "provider session is still open";
993 + return waitForStop("provider session is still open");
994 }
995 return null;
996 });
@@ -1036,6 +1050,7 @@ const make = Effect.gen(function* () {
1050 outcome: "failed",
1051 reason: cleanupFailureReason(error),
1052 });
1053 + if (deleted && settings.worktreeOnDelete) kept.push(worktreePath);
1054 yield* Effect.logWarning("storage cleanup failed for worktree", {
1055 threadId: thread.id,
1056 error,
@@ -1049,6 +1064,7 @@ const make = Effect.gen(function* () {
1064 yield* projectStore.list({ includeDeleted: true }),
1065 entries,
1066 );
1067 + return { waiting, kept };
1068 });
1069
1070 const cleanFiles = Effect.fn("StorageCleanup.cleanFiles")(function* (
@@ -1090,14 +1106,21 @@ const make = Effect.gen(function* () {
1106 });
1107
1108 const reportRef = yield* SubscriptionRef.make<StorageCleanupReport | null>(null);
1109 + // Only deleted threads' worktrees wait on session stops: any stop while one waits, or a stop inside one kept for another reason.
1110 + // A deletion stays pending until a sweep that started after it finishes.
1111 + let deletedWorktreeWaits = true;
1112 + let keptDeletedWorktrees: ReadonlyArray<string> = [];
1113 + let deletions = 0;
1114 + let sweptDeletions = 0;
1115 const sweep = Effect.fn("StorageCleanup.sweep")(function* (
1116 trigger: StorageCleanupReport["trigger"],
1117 ) {
1118 + const deletionsAtStart = deletions;
1119 const now = yield* Clock.currentTimeMillis;
1120 const serverSettings = yield* settingsService.getSettings;
1121 const settings = serverSettings.storageCleanup;
1122 const entries: StorageCleanupReportEntry[] = [];
1100 - yield* cleanWorktrees(serverSettings, now, entries).pipe(
1123 + const deletedWorktrees = yield* cleanWorktrees(serverSettings, now, entries).pipe(
1124 Effect.catch((error) =>
1125 Effect.gen(function* () {
1126 entries.push({
@@ -1112,9 +1135,13 @@ const make = Effect.gen(function* () {
1135 files: null,
1136 });
1137 yield* Effect.logWarning("worktree cleanup failed", { error });
1138 + return { waiting: true, kept: [] };
1139 }),
1140 ),
1141 );
1142 + deletedWorktreeWaits = deletedWorktrees.waiting;
1143 + keptDeletedWorktrees = deletedWorktrees.kept;
1144 + sweptDeletions = deletionsAtStart;
1145 for (const category of [
1146 {
1147 kind: "browser-artifacts" as const,
@@ -1255,14 +1282,26 @@ const make = Effect.gen(function* () {
1282 }),
1283 );
1284 yield* forkParked(
1258 - Stream.runForEach(events, (event) =>
1259 - (event.type === "thread.deleted" ||
1260 - (event.type === "provider-session.updated" &&
1261 - (event.payload.status === "stopped" || event.payload.status === "error"))) &&
1262 - anyWorktreePolicy(lastSettings, (rules) => rules.worktreeOnDelete)
1285 + Stream.runForEach(events, (event) => {
1286 + if (event.type === "thread.deleted") deletions++;
1287 + else if (
1288 + event.type !== "provider-session.updated" ||
1289 + (event.payload.status !== "stopped" && event.payload.status !== "error")
1290 + )
1291 + return Effect.void;
1292 + else if (!deletedWorktreeWaits && deletions === sweptDeletions) {
1293 + const cwd = pathKey(event.payload.cwd);
1294 + if (
1295 + !keptDeletedWorktrees.some(
1296 + (worktreePath) => pathKey(worktreePath) === cwd || inside(worktreePath, cwd),
1297 + )
1298 + )
1299 + return Effect.void;
1300 + }
1301 + return anyWorktreePolicy(lastSettings, (rules) => rules.worktreeOnDelete)
1302 ? requestSweep
1264 - : Effect.void,
1265 - ).pipe(
1303 + : Effect.void;
1304 + }).pipe(
1305 Effect.catchCause((cause) =>
1306 Effect.logWarning("Storage cleanup event stream failed", { cause }),
1307 ),