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