# Files changed · PR \#23900 · pingdotgg/t3code [View on GitCafe](https://git.cafe/pingdotgg/t3code/pull/23900/diffs) Repository: [pingdotgg/t3code](https://git.cafe/pingdotgg/t3code) Visibility: public [fix\(server\): clean up deleted threads worktrees with subagents](https://git.cafe/pingdotgg/t3code/pull/23900.md) Version: 7 Head commit: ad34e6c92ce601be54aff7c5c22901c8100503e9 Base commit: 23bd753806eb9db5a315fbf9ac6563d355f20b3a Comparison base: e78297d89133eb69a375750974c88aa744dae7c7 Showing up to 20 entries from this revision. If the pull request changes, reopen the first page before continuing. ## apps/server/src/storageCleanup.test.ts Status: modified; +106; −6 ```diff @@ -262,6 +262,7 @@ storageCleanup, }; let threads = [shell({ branch: "feature", worktreePath: worktree })]; + let deletedThreads: OrchestrationV2ThreadShell[] = []; let storedWorktreePaths: string[] = [worktree]; let projectRoots = [repo]; let editBeforeRemoval = false; @@ -358,12 +359,17 @@ }), }, ] - : strings.join("").includes('AS "worktreePath"') - ? [ - ...threads.flatMap((thread) => thread.worktreePath ?? []), - ...storedWorktreePaths, - ].map((worktreePath) => ({ worktreePath })) - : [], + : strings.join("").includes("deleted_at IS NOT NULL") + ? deletedThreads.map((thread) => ({ + payload_json: JSON.stringify(thread), + workspaceRoot: repo, + })) + : strings.join("").includes('AS "worktreePath"') + ? [ + ...threads.flatMap((thread) => thread.worktreePath ?? []), + ...storedWorktreePaths, + ].map((worktreePath) => ({ worktreePath })) + : [], )) as unknown as SqlClient.SqlClient), Effect.provideService(GitManager.GitManager, { invalidateStatus: () => Effect.void, @@ -414,6 +420,9 @@ }, setThreads: (next: typeof threads) => { threads = next; + }, + setDeletedThreads: (next: OrchestrationV2ThreadShell[]) => { + deletedThreads = next; }, setStoredWorktreePaths: (paths: string[]) => { storedWorktreePaths = paths; @@ -848,6 +857,97 @@ ); }); +describe("deleted thread worktrees", () => { + const parent = (worktreePath: string) => + shell({ branch: "feature", worktreePath, deletedAt: at(-DAY_MS) }); + // Deleting the parent leaves its native subagent thread in the projection. + const subagent = ( + owner: OrchestrationV2ThreadShell, + overrides: Partial = {}, + ) => + shell({ + id: ThreadId.make("child"), + title: "Subagent", + branch: "feature", + worktreePath: owner.worktreePath, + status: "completed", + createdBy: "agent", + creationSource: "provider", + lineage: { + rootThreadId: owner.id, + parentThreadId: owner.id, + relationshipToParent: "subagent", + }, + ...overrides, + }); + + it.effect.each(["no subagents", "native subagent"] as const)( + "removes a deleted thread's worktree with %s", + (scenario) => + Effect.gen(function* () { + yield* TestClock.setTime(NOW_MS); + const fixture = yield* cleanupFixture({ + ...DEFAULT_SERVER_SETTINGS.storageCleanup, + worktreeAfterDays: null, + worktreeOnDelete: true, + }); + const owner = parent(fixture.worktree); + fixture.setDeletedThreads([owner]); + fixture.setThreads(scenario === "native subagent" ? [subagent(owner)] : []); + const report = yield* fixture.service.runNow; + expect(report.entries[0]).toMatchObject({ + threadId: owner.id, + outcome: "removed", + reason: "Thread was deleted", + }); + expect(yield* fixture.fs.exists(fixture.worktree)).toBe(false); + }).pipe(Effect.provide(cleanupTestLayer), Effect.scoped), + ); + + it.effect("applies the remaining subagent's rules when deletion cleanup is off", () => + Effect.gen(function* () { + yield* TestClock.setTime(NOW_MS); + const fixture = yield* cleanupFixture({ + ...DEFAULT_SERVER_SETTINGS.storageCleanup, + worktreeAfterDays: 8, + worktreeOnDelete: false, + }); + const owner = parent(fixture.worktree); + const child = subagent(owner); + fixture.setDeletedThreads([owner]); + fixture.setThreads([child]); + const report = yield* fixture.service.runNow; + expect(report.entries[0]).toMatchObject({ + threadId: child.id, + outcome: "removed", + reason: "Inactive for 30 days", + }); + expect(yield* fixture.fs.exists(fixture.worktree)).toBe(false); + }).pipe(Effect.provide(cleanupTestLayer), Effect.scoped), + ); + + it.effect("waits out the settle grace of a subagent that just settled", () => + Effect.gen(function* () { + yield* TestClock.setTime(NOW_MS); + const fixture = yield* cleanupFixture({ + ...DEFAULT_SERVER_SETTINGS.storageCleanup, + worktreeAfterDays: null, + worktreeOnDelete: true, + }); + const owner = parent(fixture.worktree); + fixture.setDeletedThreads([owner]); + fixture.setThreads([subagent(owner, { settledAt: at(0), updatedAt: at(0) })]); + const report = yield* fixture.service.runNow; + expect(report.entries[0]).toMatchObject({ + threadId: owner.id, + outcome: "kept", + reason: "Settled moments ago", + }); + expect(yield* fixture.fs.exists(fixture.worktree)).toBe(true); + }).pipe(Effect.provide(cleanupTestLayer), Effect.scoped), + ); +}); + describe("orphan worktree reports", () => { it.live("keeps orphan results visible when thread results fill the report", () => runCleanupTest( ``` ## apps/server/src/storageCleanup.ts Status: modified; +47; −32 ```diff @@ -146,7 +146,9 @@ } /** Only a complete subagent chain within this worktree shares ownership. */ +function worktreeOwner>( + threads: ReadonlyArray, +) { -function worktreeOwner(threads: ReadonlyArray) { if (threads.length === 1) return threads[0]; const byId = new Map(threads.map((thread) => [thread.id, thread])); const tops = threads.filter((thread) => !byId.has(thread.lineage.parentThreadId!)); @@ -750,8 +752,24 @@ snapshot.threads.filter((thread) => thread.worktreePath !== null), (thread) => path.resolve(thread.worktreePath!), ); + const deletedByPath = Map.groupBy(deletedThreads, (thread) => + path.resolve(thread.worktreePath!), + ); const candidates = [ + ...[...groups].map( - ...[...groups.values()].map((group) => worktreeOwner(group) ?? group[0]!), + ([worktreePath, group]) => + // A deleted thread still owns the worktree its remaining subagents share, + // but only deletion cleanup acts on it; otherwise the live rules apply. + deletedByPath + .get(worktreePath) + ?.find( + (deleted) => + resolveWorktreeCleanup(serverSettings, deleted.projectId).worktreeOnDelete && + worktreeOwner([deleted, ...group]) === deleted, + ) ?? + worktreeOwner(group) ?? + group[0]!, + ), ...deletedThreads.filter((thread) => !groups.has(path.resolve(thread.worktreePath!))), ]; for (const thread of candidates) { @@ -761,6 +779,7 @@ const group = groups.get(worktreePath) ?? []; const activityAt = Math.max(...group.map(storageCleanupActivityAt)); const deleted = "workspaceRoot" in thread; + const members = deleted ? [thread, ...group] : group; const project = deleted ? { workspaceRoot: thread.workspaceRoot } : snapshot.projects.find((entry) => entry.id === thread.projectId); @@ -779,12 +798,12 @@ yield* Effect.gen(function* () { if (!(yield* fs.exists(worktreePath))) return; if (deleted && !settings.worktreeOnDelete) return keep("no rules apply"); - if (group.length > 1 && worktreeOwner(group) === undefined) - return keep(`shared by ${group.length} threads`); + if (members.length > 1 && worktreeOwner(members) === undefined) + return keep(`shared by ${members.length} threads`); if (project === undefined) return keep("project is unavailable"); if ( thread.branch === null || + !group.every((member) => storageCleanupThreadIdle(member, now)) - (!deleted && !group.every((member) => storageCleanupThreadIdle(member, now))) ) return keep("thread is running or has pending work"); if (group.some((member) => member.branch !== thread.branch)) @@ -807,7 +826,6 @@ const changes = yield* localChangesReason(worktreePath, settings); if (changes !== null) return keep(changes); if ( - !deleted && group.some( (member) => member.settledAt !== null && @@ -928,7 +946,6 @@ if (hasTerminal(worktreePath)) return "open terminal"; if (deleted) { if ( - latest.length > 0 || !resolveWorktreeCleanup(yield* settingsService.getSettings, thread.projectId) .worktreeOnDelete ) @@ -940,32 +957,30 @@ WHERE thread_id = ${thread.id} AND status NOT IN ('succeeded', 'cancelled') LIMIT 1 `; if (pendingCleanup.length > 0) return "thread deletion is still pending"; - } else { - const latestShells = yield* Effect.forEach(latest, (entry) => - projections.getThreadShell(entry.threadId), - ); - const latestGroup = latestShells.filter((shell) => shell !== null); - const latestOwner = worktreeOwner(latestGroup); - if ( - latestGroup.length !== group.length || - latestOwner?.id !== thread.id || - latestOwner?.branch !== thread.branch || - latestGroup.some((shell) => { - const previous = group.find((member) => member.id === shell.id); - return ( - previous === undefined || - shell.branch !== thread.branch || - !Equal.equals(shell.settledAt, previous.settledAt) || - (shell.settledAt !== null && - !Equal.equals(shell.updatedAt, previous.updatedAt)) || - !storageCleanupThreadIdle(shell, now) || - path.resolve(shell.worktreePath!) !== worktreePath || - storageCleanupActivityAt(shell) !== storageCleanupActivityAt(previous) - ); - }) - ) - return "thread activity or shared worktree changed since check"; } + const latestShells = yield* Effect.forEach(latest, (entry) => + projections.getThreadShell(entry.threadId), + ); + const latestGroup = latestShells.filter((shell) => shell !== null); + const latestOwner = worktreeOwner(deleted ? [thread, ...latestGroup] : latestGroup); + if ( + latestGroup.length !== group.length || + latestOwner?.id !== thread.id || + latestOwner?.branch !== thread.branch || + latestGroup.some((shell) => { + const previous = group.find((member) => member.id === shell.id); + return ( + previous === undefined || + shell.branch !== thread.branch || + !Equal.equals(shell.settledAt, previous.settledAt) || + (shell.settledAt !== null && !Equal.equals(shell.updatedAt, previous.updatedAt)) || + !storageCleanupThreadIdle(shell, now) || + path.resolve(shell.worktreePath!) !== worktreePath || + storageCleanupActivityAt(shell) !== storageCleanupActivityAt(previous) + ); + }) + ) + return "thread activity or shared worktree changed since check"; // Sessions can outlive their run and can be shared across app threads. const sessionRows = yield* sql<{ payload_json: string }>` SELECT payload_json FROM orchestration_v2_projection_provider_sessions ```