import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as Effect from "effect/Effect";
import * as Context from "effect/Context";
import * as Deferred from "effect/Deferred";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Queue from "effect/Queue";
import type * as Path from "effect/Path";
import type * as Scope from "effect/Scope";
import * as Stream from "effect/Stream";
import { SCAN_CACHE_FILE_NAME } from "./usage/usageScanCache.ts";
import { TestClock } from "effect/testing";
import * as SqlClient from "effect/sql/SqlClient";
import {
DEFAULT_SERVER_SETTINGS,
type WorktreeKeepWhen,
type StorageCleanupSettings,
type TerminalMetadataStreamEvent,
type TerminalSummary,
} from "@t3tools/contracts";
import * as HostProcess from "@t3tools/shared/HostProcess";
import * as ServerConfig from "./config.ts";
import * as StorageCleanup from "./storageCleanup.ts";
import * as GitVcsDriver from "./vcs/GitVcsDriver.ts";
import * as GitManager from "./git/GitManager.ts";
import * as Settings from "./serverSettings.ts";
import * as ProjectionStore from "./orchestration-v2/ProjectionStore.ts";
import * as ProviderSessionManager from "./orchestration-v2/ProviderSessionManager.ts";
import * as ProjectStore from "./orchestration-v2/ProjectStore.ts";
import * as Orchestrator from "./orchestration-v2/Orchestrator.ts";
import * as TerminalManager from "./terminal/Manager.ts";
import { CodexProviderCapabilitiesV2 } from "./orchestration-v2/Adapters/CodexAdapterV2.ts";
import { ServerActivation } from "./serverActivation.ts";
import { describe, expect, it } from "@effect/vitest";
import {
EventId,
ProjectId,
ProviderDriverKind,
ProviderInstanceId,
ProviderSessionId,
RunId,
RuntimeRequestId,
ThreadId,
type OrchestrationV2DomainEvent,
type OrchestrationV2ThreadShell,
} from "@t3tools/contracts";
import * as DateTime from "effect/DateTime";
import {
storageCleanupActivityAt,
storageCleanupPullRequestMerged,
storageCleanupThreadIdle,
} from "./storageCleanup.ts";
const NOW_MS = Date.parse("2026-06-10T12:00:00.000Z");
const DAY_MS = 24 * 60 * 60 * 1_000;
function at(offsetMs: number): DateTime.Utc {
return DateTime.makeUnsafe(NOW_MS + offsetMs);
}
function shell(overrides: Partial<OrchestrationV2ThreadShell> = {}): OrchestrationV2ThreadShell {
return {
id: ThreadId.make("thread-1"),
projectId: ProjectId.make("project-1"),
title: "Thread",
providerInstanceId: ProviderInstanceId.make("codex"),
modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
runtimeMode: "full-access",
interactionMode: "default",
worktreePath: null,
activeProviderThreadId: null,
lineage: {
rootThreadId: ThreadId.make("thread-1"),
parentThreadId: null,
relationshipToParent: null,
},
forkedFrom: null,
createdBy: "user",
creationSource: "web",
activeRunId: null,
latestVisibleMessage: null,
hasActionableProposedPlan: false,
itemCount: 0,
visibleItemCount: 0,
lastVisitedAt: null,
deletedAt: null,
branch: null,
linkedPullRequest: null,
status: "idle",
activityRunStatus: null,
pendingRuntimeRequest: null,
pendingBackgroundTasks: [],
latestRunId: null,
latestRunRequestedAt: null,
latestRunStartedAt: null,
latestRunCompletedAt: null,
latestUserMessageAt: null,
createdAt: at(-30 * DAY_MS),
updatedAt: at(-10 * DAY_MS),
archivedAt: null,
settledOverride: null,
settledAt: null,
snoozedUntil: null,
snoozedAt: null,
pinnedAt: null,
...overrides,
};
}
describe("V2 storage cleanup eligibility", () => {
const candidate = () => shell({ branch: "feature", worktreePath: "/worktrees/feature" });
it("allows an idle worktree and rejects the project checkout", () => {
expect(storageCleanupThreadIdle(candidate(), NOW_MS, DEFAULT_SERVER_SETTINGS)).toBe(true);
expect(storageCleanupThreadIdle(shell(), NOW_MS, DEFAULT_SERVER_SETTINGS)).toBe(false);
});
it.each(["running", "starting", "preparing", "waiting", "queued"] as const)(
"retains a worktree while its thread is %s",
(status) => {
expect(
storageCleanupThreadIdle(candidateWithStatus(status), NOW_MS, DEFAULT_SERVER_SETTINGS),
).toBe(false);
},
);
it.each(["completed", "interrupted", "cancelled", "rolled_back"] as const)(
"retains %s while background work is pending",
(status) => {
expect(
storageCleanupThreadIdle(
{
...candidateWithStatus(status),
pendingBackgroundTasks: [{ taskId: "task-1", kind: "command" }],
},
NOW_MS,
DEFAULT_SERVER_SETTINGS,
),
).toBe(false);
},
);
it.each(["completed", "interrupted", "cancelled", "rolled_back"] as const)(
"retains %s while a runtime request is pending",
(status) => {
expect(
storageCleanupThreadIdle(
{
...candidateWithStatus(status),
pendingRuntimeRequest: {
id: RuntimeRequestId.make("request-1"),
kind: "command",
createdAt: at(0),
},
},
NOW_MS,
DEFAULT_SERVER_SETTINGS,
),
).toBe(false);
},
);
it("retains an active run even if the shell status is idle", () => {
expect(
storageCleanupThreadIdle(
{ ...candidate(), activeRunId: RunId.make("run") },
NOW_MS,
DEFAULT_SERVER_SETTINGS,
),
).toBe(false);
});
it("retains a queued prompt before the new run has been projected", () => {
expect(
storageCleanupThreadIdle(
{ ...candidate(), latestUserMessageAt: at(-1_000) },
NOW_MS,
DEFAULT_SERVER_SETTINGS,
),
).toBe(false);
});
it.each([
{ name: "snoozed until a future reset", snooze: true, resetIn: DAY_MS, idle: false },
{ name: "set to auto-resume", autoResume: true, resetIn: DAY_MS, idle: false },
{ name: "with recovery turned off", resetIn: DAY_MS, idle: true },
{ name: "auto-resuming after the reset", autoResume: true, resetIn: -1_000, idle: false },
{ name: "snoozed past its reset", snooze: true, resetIn: -1_000, idle: true },
{
name: "settled with an auto-resume pending",
autoResume: true,
settled: true,
resetIn: -1_000,
idle: true,
},
{ name: "not yet armed by the recovery worker", armed: false, resetIn: DAY_MS, idle: false },
{
name: "not yet armed, auto-resume after reset",
armed: false,
autoResumeSetting: true,
resetIn: -1_000,
idle: false,
},
{
name: "not armed with recovery settings off",
armed: false,
settingsOff: true,
resetIn: DAY_MS,
idle: true,
},
])(
"treats a usage-limited thread $name as idle: $idle",
({
autoResume = false,
snooze = false,
armed = true,
autoResumeSetting = false,
settled,
settingsOff,
resetIn,
idle,
}) => {
const runId = RunId.make("run-1");
const resetAt = DateTime.formatIso(at(resetIn));
expect(
storageCleanupThreadIdle(
{
...candidateWithStatus("failed"),
latestRunId: runId,
lastErrorClass: "usage_limit",
usageLimitResetAt: resetAt,
settledOverride: settled ? "settled" : null,
limitRecovery: armed ? { runId, resetAt, autoResume, snooze } : null,
},
NOW_MS,
{ autoResumeLimitedThreads: autoResumeSetting, snoozeLimitedThreads: !settingsOff },
),
).toBe(idle);
},
);
it("uses V2 run activity instead of metadata refreshes for retention", () => {
const thread = candidate();
const runTime = at(-3 * DAY_MS);
expect(
storageCleanupActivityAt({ ...thread, latestRunCompletedAt: runTime, updatedAt: at(0) }),
).toBe(DateTime.toEpochMillis(runTime));
});
function candidateWithStatus(status: OrchestrationV2ThreadShell["status"]) {
return { ...candidate(), status };
}
});
describe("merged pull request cleanup", () => {
const HEAD_SHA = "a".repeat(40);
const integrated = {
branch: "feature",
defaultBranch: "main",
headSha: HEAD_SHA,
integrated: true,
};
const squashed = { ...integrated, integrated: false };
const pullRequest = (
overrides: Partial<NonNullable<Parameters<typeof storageCleanupPullRequestMerged>[0]>> = {},
) => ({
state: "merged" as const,
headRef: "feature",
baseRef: "main",
headSha: HEAD_SHA,
...overrides,
});
it("removes a worktree whose head reached the default branch through a merged pull request", () => {
expect(storageCleanupPullRequestMerged(pullRequest({ headSha: null }), integrated)).toBe(true);
});
it("removes a squash-merged worktree when the pull request names its exact head", () => {
expect(storageCleanupPullRequestMerged(pullRequest(), squashed)).toBe(true);
});
it.each([
["has a later commit than the merged head", { headSha: "c".repeat(40) }],
["was merged into a release branch", { baseRef: "release" }],
["was merged into its stack parent", { baseRef: "stack-parent" }],
["was merged without a reported head commit", { headSha: null }],
["belongs to a different branch", { headRef: "other" }],
["is still open", { state: "open" }],
["was closed without merging", { state: "closed" }],
] as const)("keeps a squash worktree whose pull request %s", (_name, overrides) => {
expect(storageCleanupPullRequestMerged(pullRequest(overrides), squashed)).toBe(false);
});
it("keeps a worktree with no pull request, or one that is not merged", () => {
expect(storageCleanupPullRequestMerged(null, squashed)).toBe(false);
expect(storageCleanupPullRequestMerged(null, integrated)).toBe(false);
expect(storageCleanupPullRequestMerged(pullRequest({ state: "open" }), integrated)).toBe(false);
});
});
const allocatedBytes = (fs: FileSystem.FileSystem, file: string) =>
fs.stat(file).pipe(
Effect.map((stat) =>
Option.getOrElse(
Option.map(stat.blocks, (blocks) => Number(blocks) * 512),
() => Number(stat.size),
),
),
);
const cleanupFixture = (
storageCleanup: StorageCleanupSettings = {
...DEFAULT_SERVER_SETTINGS.storageCleanup,
worktreeAfterDays: 8,
worktreeOnDelete: true,
},
) =>
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const config = yield* ServerConfig.ServerConfig;
const git = yield* GitVcsDriver.GitVcsDriver;
const repo = yield* fs.realPath(yield* fs.makeTempDirectoryScoped({ prefix: "cleanup-repo-" }));
const command = (cwd: string, args: string[]) =>
git.execute({ operation: "cleanup-test", cwd, args });
yield* command(repo, ["init", "-b", "main"]);
yield* command(repo, ["config", "user.email", "cleanup@example.test"]);
yield* command(repo, ["config", "user.name", "Cleanup test"]);
yield* fs.writeFileString(`${repo}/tracked.txt`, "original\n");
yield* fs.writeFileString(`${repo}/.gitignore`, ".env\ndist/\nnode_modules/\n");
yield* command(repo, ["add", "."]);
yield* command(repo, ["commit", "-m", "initial"]);
yield* fs.makeDirectory(config.worktreesDir, { recursive: true });
const worktree = `${config.worktreesDir}/feature`;
yield* command(repo, ["worktree", "add", "-b", "feature", worktree]);
let settings: import("@t3tools/contracts").ServerSettings = {
...DEFAULT_SERVER_SETTINGS,
storageCleanup,
};
let threads = [shell({ branch: "feature", worktreePath: worktree })];
let deletedThreads: OrchestrationV2ThreadShell[] = [];
let storedWorktreePaths: string[] = [worktree];
let projectRoots = [repo];
let editBeforeRemoval = false;
let openSessionCwd: string | null = null;
let sessionLive = true;
let sessionLiveChecks = 0;
let onLiveCheck: Effect.Effect<void> = Effect.void;
let outboxStatus: string | null = null;
let fullStatusCalls = 0;
let snapshotReads = 0;
let terminalListener: ((event: TerminalMetadataStreamEvent) => Effect.Effect<void>) | undefined;
let events: Stream.Stream<OrchestrationV2DomainEvent> = Stream.empty;
const activated = yield* Deferred.make<void>();
const context = yield* Layer.build(StorageCleanup.layer).pipe(
Effect.provideService(GitVcsDriver.GitVcsDriver, {
...git,
execute: (input) =>
Effect.gen(function* () {
// Before Git's own clean check: inside `git worktree remove`, or on
// Windows the same status check the removal makes before deleting.
if (
editBeforeRemoval &&
(input.args.includes("remove") || input.args.includes("--porcelain"))
)
yield* fs.writeFileString(`${worktree}/tracked.txt`, "late edit\n");
return yield* git.execute(input);
}),
statusDetailsLocal: (...args) => {
fullStatusCalls++;
return git.statusDetailsLocal(...args);
},
}),
Effect.provideService(Settings.ServerSettingsService, {
getSettings: Effect.sync(() => settings),
subscribeChanges: Effect.succeed(Stream.empty),
} as unknown as Settings.ServerSettingsService["Service"]),
Effect.provideService(ProjectStore.ProjectStoreV2, {
list: () => Effect.sync(() => projectRoots.map((workspaceRoot) => ({ workspaceRoot }))),
listShells: () =>
Effect.sync(() =>
projectRoots.map((workspaceRoot, index) => ({
id: ProjectId.make(`project-${index + 1}`),
workspaceRoot,
})),
),
} as unknown as ProjectStore.ProjectStoreV2["Service"]),
Effect.provideService(ProjectionStore.ProjectionStoreV2, {
getShellSnapshot: (input?: { location?: string }) =>
Effect.sync(() => {
snapshotReads++;
const visible = threads.filter((thread) => thread.deletedAt === null);
return {
threads:
input?.location === "archive"
? []
: visible.filter((thread) => thread.archivedAt === null),
archivedThreads:
input?.location === "active"
? []
: visible.filter((thread) => thread.archivedAt !== null),
};
}),
getThreadWorktreePaths: (input?: { includeArchived?: boolean }) =>
Effect.sync(() =>
threads.flatMap((thread) =>
thread.deletedAt === null &&
(input?.includeArchived === true || thread.archivedAt === null) &&
thread.worktreePath !== null
? [{ threadId: thread.id, worktreePath: thread.worktreePath }]
: [],
),
),
getThreadShell: (threadId: ThreadId) =>
Effect.sync(() => threads.find((thread) => thread.id === threadId) ?? null),
} as unknown as ProjectionStore.ProjectionStoreV2["Service"]),
Effect.provideService(ProviderSessionManager.ProviderSessionManagerV2, {
isLive: () =>
Effect.sync(() => {
sessionLiveChecks++;
return sessionLive;
}).pipe(Effect.tap(() => Effect.suspend(() => onLiveCheck))),
} as unknown as ProviderSessionManager.ProviderSessionManagerV2["Service"]),
Effect.provideService(Orchestrator.OrchestratorV2, {
streamDomainEvents: Stream.suspend(() => events),
} as unknown as Orchestrator.OrchestratorV2["Service"]),
Effect.provideService(SqlClient.SqlClient, ((strings: TemplateStringsArray) =>
Effect.sync(() =>
openSessionCwd !== null && strings.join("").includes("projection_provider_sessions")
? [
{
payload_json: JSON.stringify({
id: "session-1",
driver: "codex",
providerInstanceId: "codex",
status: "ready",
cwd: openSessionCwd,
model: null,
capabilities: CodexProviderCapabilitiesV2,
createdAt: "2026-06-01T12:00:00.000Z",
updatedAt: "2026-06-01T12:00:00.000Z",
lastError: null,
}),
},
]
: outboxStatus !== null && strings.join("").includes("orchestration_v2_effect_outbox")
? [{ status: outboxStatus }]
: 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,
} as unknown as GitManager.GitManager["Service"]),
Effect.provideService(TerminalManager.TerminalManager, {
subscribeMetadata: (
listener: (event: TerminalMetadataStreamEvent) => Effect.Effect<void>,
) =>
Effect.sync(() => {
terminalListener = listener;
return () => {};
}),
} as unknown as TerminalManager.TerminalManager["Service"]),
Effect.provideService(ServerActivation, Deferred.await(activated)),
);
return {
service: Context.get(context, StorageCleanup.StorageCleanup),
repo,
setTerminals: (terminals: TerminalSummary[]) =>
terminalListener?.({ type: "snapshot", terminals }) ?? Effect.void,
editBeforeRemoval: () => {
editBeforeRemoval = true;
},
fs,
worktree,
config,
command,
enableFiles: () => {
settings = {
...settings,
storageCleanup: {
...settings.storageCleanup,
browserArtifactsAfterDays: 8,
logsAfterDays: 8,
},
};
},
setSettings: (next: Partial<typeof settings>) => {
settings = { ...settings, ...next };
},
setPolicy: (worktreeKeepWhen: WorktreeKeepWhen) => {
settings = {
...settings,
storageCleanup: { ...settings.storageCleanup, worktreeKeepWhen },
};
},
disable: () => {
settings = {
...settings,
storageCleanup: {
...settings.storageCleanup,
worktreeAfterDays: null,
worktreeOnDelete: false,
},
};
},
setThreads: (next: typeof threads) => {
threads = next;
},
setOnLiveCheck: (hook: Effect.Effect<void>) => {
onLiveCheck = hook;
},
setOutboxStatus: (status: string | null) => {
outboxStatus = status;
},
setDeletedThreads: (next: OrchestrationV2ThreadShell[]) => {
deletedThreads = next;
},
setStoredWorktreePaths: (paths: string[]) => {
storedWorktreePaths = paths;
},
setProjectRoots: (roots: string[]) => {
projectRoots = roots;
},
setSessionLive: (live: boolean) => {
sessionLive = live;
},
setOpenSessionCwd: (cwd: string | null) => {
openSessionCwd = cwd;
},
openTerminal: (paths: { cwd: string; worktreePath: string | null }) =>
terminalListener?.({
type: "upsert",
terminal: {
threadId: "thread-1",
terminalId: "terminal-1",
status: "running",
pid: 1,
exitCode: null,
exitSignal: null,
hasRunningSubprocess: false,
label: "Terminal",
updatedAt: "2026-06-10T12:00:00.000Z",
...paths,
},
}) ?? Effect.void,
fullStatusCalls: () => fullStatusCalls,
snapshotReads: () => snapshotReads,
sessionLiveChecks: () => sessionLiveChecks,
activate: (domainEvents: Stream.Stream<OrchestrationV2DomainEvent>) => {
events = domainEvents;
return Deferred.succeed(activated, undefined);
},
};
});
const pausedMeasurementFixture = (storageCleanup?: StorageCleanupSettings) =>
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const measuring = yield* Deferred.make<void>();
const resume = yield* Deferred.make<void>();
let measuredPath: string | undefined;
const fixture = yield* cleanupFixture(storageCleanup).pipe(
Effect.provideService(FileSystem.FileSystem, {
...fs,
readDirectory: (directory, options) =>
Effect.gen(function* () {
if (directory === measuredPath) {
yield* Deferred.succeed(measuring, undefined);
yield* Deferred.await(resume);
}
return yield* fs.readDirectory(directory, options);
}),
}),
);
measuredPath = yield* fs.realPath(fixture.worktree);
return { ...fixture, measuring, resume };
});
const cleanupTestLayer = GitVcsDriver.layer.pipe(
Layer.provideMerge(ServerConfig.layerTest(process.cwd(), { prefix: "storage-cleanup-" })),
Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
);
const runCleanupTest = <A, E>(
effect: Effect.Effect<
A,
E,
| FileSystem.FileSystem
| ServerConfig.ServerConfig
| GitVcsDriver.GitVcsDriver
| Path.Path
| Scope.Scope
>,
) => effect.pipe(Effect.provide(cleanupTestLayer), Effect.scoped);
const submoduleCleanupFixture = () =>
Effect.gen(function* () {
const fixture = yield* cleanupFixture();
const { command, repo, worktree } = fixture;
const submodule = `${worktree}/module`;
const child = `${submodule}/child`;
for (const [cwd, name] of [
[worktree, "module"],
[submodule, "child"],
] as const) {
yield* command(cwd, ["-c", "protocol.file.allow=always", "submodule", "add", repo, name]);
yield* command(`${cwd}/${name}`, ["config", "user.name", "Cleanup test"]);
yield* command(`${cwd}/${name}`, ["config", "user.email", "cleanup@example.test"]);
}
const recordSubmodules = () =>
Effect.gen(function* () {
yield* command(submodule, ["commit", "-am", "record child"]);
yield* command(submodule, ["push", "origin", "HEAD:submodule"]);
yield* command(worktree, ["commit", "-am", "record module"]);
});
yield* recordSubmodules();
return { ...fixture, submodule, child, recordSubmodules };
});
it.live("removes clean submodules recursively, including deinitialized repositories", () =>
runCleanupTest(
Effect.gen(function* () {
const { service, fs, repo, worktree, submodule, command, recordSubmodules } =
yield* submoduleCleanupFixture();
yield* command(submodule, [
"-c",
"protocol.file.allow=always",
"submodule",
"add",
repo,
"stored",
]);
yield* recordSubmodules();
yield* command(submodule, ["submodule", "deinit", "stored"]);
const admin = (yield* command(worktree, ["rev-parse", "--absolute-git-dir"])).stdout.trim();
const report = yield* service.runNow;
expect(report.entries.find((entry) => entry.path === worktree)).toMatchObject({
outcome: "removed",
});
expect(report.counts).toEqual({ removed: 1, kept: 0, failed: 0 });
expect(yield* fs.exists(worktree)).toBe(false);
expect(yield* fs.exists(admin)).toBe(false);
}),
),
);
it.live("keeps nested submodule files protected by the current keep rule", () =>
runCleanupTest(
Effect.gen(function* () {
const { service, fs, worktree, submodule, child, command, setPolicy } =
yield* submoduleCleanupFixture();
setPolicy("tracked-changes");
yield* fs.writeFileString(`${child}/tracked.txt`, "local edit\n");
expect(
(yield* service.runNow).entries.find((entry) => entry.path === worktree),
).toMatchObject({ outcome: "kept" });
expect(yield* fs.readFileString(`${child}/tracked.txt`)).toBe("local edit\n");
yield* fs.writeFileString(`${child}/tracked.txt`, "original\n");
setPolicy("any-local-files");
yield* fs.writeFileString(`${child}/.env`, "local secret\n");
expect(
(yield* service.runNow).entries.find((entry) => entry.path === worktree),
).toMatchObject({ outcome: "kept" });
expect(yield* fs.readFileString(`${child}/.env`)).toBe("local secret\n");
yield* fs.remove(`${child}/.env`);
yield* command(submodule, ["submodule", "deinit", "child"]);
yield* fs.writeFileString(`${child}/.env`, "secret after deinit\n");
const report = yield* service.runNow;
expect({
outcome: report.entries.find((entry) => entry.path === worktree)?.outcome,
contents: (yield* fs.exists(`${child}/.env`))
? yield* fs.readFileString(`${child}/.env`)
: null,
}).toEqual({ outcome: "kept", contents: "secret after deinit\n" });
yield* fs.remove(`${child}/.env`);
setPolicy("uncommitted-changes");
yield* fs.writeFileString(`${child}/notes.txt`, "notes after deinit\n");
const untrackedReport = yield* service.runNow;
expect({
outcome: untrackedReport.entries.find((entry) => entry.path === worktree)?.outcome,
contents: (yield* fs.exists(`${child}/notes.txt`))
? yield* fs.readFileString(`${child}/notes.txt`)
: null,
}).toEqual({ outcome: "kept", contents: "notes after deinit\n" });
}),
),
);
it.live("keeps unpushed submodule history after checkout and deinitialization", () =>
runCleanupTest(
Effect.gen(function* () {
const { service, fs, worktree, submodule, child, command, recordSubmodules } =
yield* submoduleCleanupFixture();
yield* command(child, ["checkout", "-b", "local-only"]);
yield* fs.writeFileString(`${child}/tracked.txt`, "unpublished work\n");
yield* command(child, ["commit", "-am", "local work"]);
const local = (yield* command(child, ["rev-parse", "HEAD"])).stdout.trim();
yield* recordSubmodules();
expect(
(yield* service.runNow).entries.find((entry) => entry.path === worktree),
).toMatchObject({ outcome: "kept", reason: expect.stringContaining("remote-tracking") });
expect(yield* fs.readFileString(`${child}/tracked.txt`)).toBe("unpublished work\n");
yield* command(child, ["checkout", "main"]);
yield* recordSubmodules();
expect(
(yield* service.runNow).entries.find((entry) => entry.path === worktree),
).toMatchObject({ outcome: "kept", reason: expect.stringContaining("remote-tracking") });
const childGit = (yield* command(child, ["rev-parse", "--absolute-git-dir"])).stdout.trim();
yield* command(submodule, ["submodule", "deinit", "child"]);
expect(
(yield* service.runNow).entries.find((entry) => entry.path === worktree),
).toMatchObject({ outcome: "kept", reason: expect.stringContaining("remote-tracking") });
expect(
(yield* command(worktree, [
"--git-dir",
childGit,
"rev-parse",
"refs/heads/local-only",
])).stdout.trim(),
).toBe(local);
expect(
(yield* command(worktree, ["--git-dir", childGit, "show", "local-only:tracked.txt"]))
.stdout,
).toBe("unpublished work\n");
yield* command(worktree, ["--git-dir", childGit, "branch", "-D", "local-only"]);
expect(
(yield* service.runNow).entries.find((entry) => entry.path === worktree),
).toMatchObject({ outcome: "kept", reason: expect.stringContaining("remote-tracking") });
expect(
(yield* command(worktree, ["--git-dir", childGit, "show", `${local}:tracked.txt`])).stdout,
).toBe("unpublished work\n");
}),
),
);
it.live("keeps submodules when stored repository metadata is malformed", () =>
runCleanupTest(
Effect.gen(function* () {
const { service, fs, worktree, submodule, child, command } = yield* submoduleCleanupFixture();
const childGit = (yield* command(child, ["rev-parse", "--absolute-git-dir"])).stdout.trim();
yield* command(submodule, ["submodule", "deinit", "child"]);
yield* fs.writeFileString(`${childGit}/HEAD`, "not a ref\n");
expect(
(yield* service.runNow).entries.find((entry) => entry.path === worktree),
).toMatchObject({ outcome: "kept", reason: expect.stringContaining("inspected") });
expect(yield* fs.exists(worktree)).toBe(true);
expect(yield* fs.readFileString(`${childGit}/HEAD`)).toBe("not a ref\n");
}),
),
);
it.live("preserves late tracked edits when submodules were never initialized", () =>
runCleanupTest(
Effect.gen(function* () {
const fixture = yield* cleanupFixture();
const { service, fs, worktree, command } = fixture;
const head = (yield* command(worktree, ["rev-parse", "HEAD"])).stdout.trim();
yield* fs.writeFileString(
`${worktree}/.gitmodules`,
'[submodule "module"]\n\tpath = module\n\turl = /unused\n',
);
yield* command(worktree, ["add", ".gitmodules"]);
yield* command(worktree, ["update-index", "--add", "--cacheinfo", `160000,${head},module`]);
yield* command(worktree, ["commit", "-m", "record uninitialized module"]);
yield* fs.makeDirectory(`${worktree}/module`);
fixture.editBeforeRemoval();
expect(
(yield* service.runNow).entries.find((entry) => entry.path === worktree),
).toMatchObject({ outcome: "failed" });
expect(yield* fs.readFileString(`${worktree}/tracked.txt`)).toBe("late edit\n");
}),
),
);
describe("subagent worktree ownership", () => {
it.effect.each([
"child",
"grandchild",
"immediate",
"active-parent",
"recent-settle",
"settle-grace",
"recent-child-activity",
"running-child",
"pending-child",
"running-parent",
"pending-parent",
"unsettled-child",
"pinned-child",
"fork",
"missing-parent",
"cycle",
] as const)("checks isolated subagent settlement (%s)", (scenario) =>
Effect.gen(function* () {
yield* TestClock.setTime(NOW_MS);
const fixture = yield* cleanupFixture({
...DEFAULT_SERVER_SETTINGS.storageCleanup,
worktreeSettledAfterDays: scenario === "immediate" ? 0 : 8,
});
const root = shell({
settledAt:
scenario === "active-parent"
? null
: scenario === "recent-settle" || scenario === "settle-grace"
? at(-30_000)
: scenario === "immediate"
? at(-120_000)
: at(-20 * DAY_MS),
settledOverride: scenario === "active-parent" ? null : "settled",
updatedAt: scenario === "settle-grace" ? at(-30_000) : at(-10 * DAY_MS),
});
const child = shell({
id: ThreadId.make("child"),
branch: "feature",
worktreePath: fixture.worktree,
lineage: {
parentThreadId:
scenario === "missing-parent"
? ThreadId.make("missing")
: scenario === "cycle"
? ThreadId.make("child")
: ["grandchild", "running-parent", "pending-parent"].includes(scenario)
? ThreadId.make("middle")
: root.id,
rootThreadId: root.id,
relationshipToParent: scenario === "fork" ? "fork" : "subagent",
},
status: scenario === "running-child" ? "running" : "completed",
pendingBackgroundTasks:
scenario === "pending-child" ? [{ taskId: "task", kind: "command" }] : [],
latestRunCompletedAt: scenario === "recent-child-activity" ? at(-2 * DAY_MS) : null,
settledOverride: scenario === "unsettled-child" ? "active" : null,
pinnedAt: scenario === "pinned-child" ? at(-DAY_MS) : null,
});
const middle = shell({
id: ThreadId.make("middle"),
status: scenario === "running-parent" ? "running" : "idle",
pendingBackgroundTasks:
scenario === "pending-parent" ? [{ taskId: "task", kind: "command" }] : [],
lineage: {
parentThreadId: root.id,
rootThreadId: root.id,
relationshipToParent: "subagent",
},
});
fixture.setThreads([child, middle, root]);
const report = yield* fixture.service.runNow;
const removed = ["child", "grandchild", "immediate"].includes(scenario);
expect(yield* fixture.fs.exists(fixture.worktree)).toBe(!removed);
expect(report.entries[0]).toMatchObject({
threadId: child.id,
outcome: removed ? "removed" : "kept",
reason: removed
? scenario === "immediate"
? "Settled for 0 days"
: "Settled for 20 days"
: scenario === "settle-grace"
? "Settled moments ago"
: scenario === "recent-settle"
? "Settled for 0 of 8 days"
: scenario === "recent-child-activity"
? "Settled for 2 of 8 days"
: scenario === "running-child" || scenario === "pending-child"
? "Thread is running or has pending work"
: "Not settled",
});
}).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
);
it.live.each([
"parent-unsettled",
"parent-resettled",
"child-unsettled",
"intermediate-running",
"intermediate-pending",
] as const)("cancels inherited settlement during measurement (%s)", (change) =>
runCleanupTest(
Effect.gen(function* () {
const fixture = yield* pausedMeasurementFixture({
...DEFAULT_SERVER_SETTINGS.storageCleanup,
worktreeSettledAfterDays: 0,
});
const root = shell({ settledAt: at(-20 * DAY_MS), settledOverride: "settled" });
const middle = shell({
id: ThreadId.make("middle"),
lineage: {
parentThreadId: root.id,
rootThreadId: root.id,
relationshipToParent: "subagent",
},
});
const child = shell({
id: ThreadId.make("child"),
branch: "feature",
worktreePath: fixture.worktree,
lineage: {
parentThreadId: middle.id,
rootThreadId: root.id,
relationshipToParent: "subagent",
},
});
fixture.setThreads([child, middle, root]);
const run = yield* fixture.service.runNow.pipe(Effect.forkChild);
yield* Deferred.await(fixture.measuring);
fixture.setThreads([
{ ...child, settledOverride: change === "child-unsettled" ? "active" : null },
{
...middle,
status: change === "intermediate-running" ? "running" : "idle",
pendingBackgroundTasks:
change === "intermediate-pending" ? [{ taskId: "task", kind: "command" }] : [],
},
change === "child-unsettled" || change.startsWith("intermediate-")
? root
: {
...root,
settledAt: change === "parent-resettled" ? at(0) : null,
settledOverride: change === "parent-resettled" ? "settled" : "active",
updatedAt: at(0),
},
]);
yield* Deferred.succeed(fixture.resume, undefined);
expect((yield* Fiber.join(run)).entries[0]).toMatchObject({
outcome: "kept",
reason: "Parent settlement changed since check",
});
expect(yield* fixture.fs.exists(fixture.worktree)).toBe(true);
}),
),
);
it.effect.each([
"idle",
"grandchild",
"null-branch",
"stale-branch",
"isolated-owner",
"fork-owner",
"missing-parent",
"cycle",
"two-tops",
"wrong-root",
"running",
"pending",
"unrelated",
"fork",
"side-chat",
"recent-activity",
"recent-inactive",
"recent-grace",
"recent-settle",
"child-settled-now",
"child-settled-only",
] as const)("checks the whole owner group (%s)", (scenario) =>
Effect.gen(function* () {
yield* TestClock.setTime(NOW_MS);
const fixture = yield* cleanupFixture();
fixture.setSettings({
storageCleanup: {
...DEFAULT_SERVER_SETTINGS.storageCleanup,
worktreeSettledAfterDays: scenario === "recent-inactive" ? null : 8,
worktreeAfterDays: scenario === "recent-inactive" ? 8 : null,
},
});
const root = shell({
branch: "feature",
worktreePath: fixture.worktree,
settledAt: scenario === "child-settled-only" ? null : at(-20 * DAY_MS),
...(scenario === "isolated-owner" || scenario === "fork-owner"
? {
lineage: {
parentThreadId: ThreadId.make("ancestor"),
rootThreadId: ThreadId.make("ancestor"),
relationshipToParent:
scenario === "fork-owner" ? ("fork" as const) : ("subagent" as const),
},
}
: {}),
});
const child = shell({
id: ThreadId.make("child"),
branch:
scenario === "null-branch"
? null
: scenario === "stale-branch"
? "t3/15a6e5ae"
: "feature",
worktreePath: fixture.worktree,
lineage: {
parentThreadId:
scenario === "missing-parent"
? ThreadId.make("missing")
: scenario === "cycle"
? ThreadId.make("child")
: scenario === "two-tops"
? null
: root.id,
rootThreadId:
scenario === "wrong-root" ? ThreadId.make("other-root") : root.lineage.rootThreadId,
relationshipToParent:
scenario === "fork" || scenario === "side-chat"
? "fork"
: scenario === "unrelated"
? null
: "subagent",
...(scenario === "side-chat" ? { sideChat: true } : {}),
},
status: scenario === "running" ? "running" : "completed",
pendingBackgroundTasks: scenario === "pending" ? [{ taskId: "task", kind: "command" }] : [],
latestRunCompletedAt:
scenario === "recent-activity" || scenario === "recent-inactive"
? at(-2 * DAY_MS)
: scenario === "recent-grace"
? at(-30_000)
: null,
settledAt: scenario === "child-settled-only" ? at(-20 * DAY_MS) : null,
});
const grandchild = {
...child,
id: ThreadId.make("grandchild"),
lineage: { ...child.lineage, parentThreadId: child.id },
};
fixture.setThreads(
scenario === "grandchild"
? [grandchild, child, root]
: scenario === "isolated-owner" || scenario === "fork-owner"
? [child, root, shell({ id: ThreadId.make("ancestor") })]
: [child, root],
);
if (scenario === "recent-settle" || scenario === "child-settled-now")
fixture.setThreads([
{
...child,
settledAt: scenario === "recent-settle" ? at(0) : at(-20 * DAY_MS),
updatedAt: at(0),
},
root,
]);
const report = yield* fixture.service.runNow;
const removed = ["idle", "grandchild", "isolated-owner", "fork-owner", "side-chat"].includes(
scenario,
);
const shared = [
"unrelated",
"fork",
"missing-parent",
"cycle",
"two-tops",
"wrong-root",
].includes(scenario);
expect(yield* fixture.fs.exists(fixture.worktree)).toBe(!removed);
expect(report.entries[0]).toMatchObject({
threadId: shared ? child.id : root.id,
outcome: removed ? "removed" : "kept",
reason: removed
? "Settled for 20 days"
: scenario === "running" || scenario === "pending"
? "Thread is running or has pending work"
: shared
? "Shared by 2 threads"
: scenario === "null-branch" || scenario === "stale-branch"
? "A subagent thread's branch differs from this worktree's branch"
: scenario === "recent-activity"
? "Settled for 2 of 8 days"
: scenario === "recent-inactive"
? "Inactive for 2 of 8 days"
: ["recent-grace", "recent-settle", "child-settled-now"].includes(scenario)
? "Settled moments ago"
: "Not settled",
});
}).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
);
it.live.each([
"running",
"pending",
"activity",
"unrelated",
"settled",
"resettled",
"null-branch",
"stale-branch",
] as const)("cancels removal when a child changes during measurement (%s)", (change) =>
runCleanupTest(
Effect.gen(function* () {
const fixture = yield* pausedMeasurementFixture();
const root = shell({ branch: "feature", worktreePath: fixture.worktree });
const child = {
...root,
id: ThreadId.make("child"),
settledAt: change === "resettled" ? at(-20 * DAY_MS) : null,
lineage: {
parentThreadId: root.id,
rootThreadId: root.id,
relationshipToParent: "subagent" as const,
},
};
fixture.setThreads([child, root]);
const run = yield* fixture.service.runNow.pipe(Effect.forkChild);
yield* Deferred.await(fixture.measuring);
fixture.setThreads([
root,
{
...child,
branch:
change === "null-branch"
? null
: change === "stale-branch"
? "t3/15a6e5ae"
: child.branch,
settledAt: change === "settled" ? at(-20 * DAY_MS) : child.settledAt,
updatedAt: change === "settled" || change === "resettled" ? at(0) : child.updatedAt,
status: change === "running" ? "running" : "idle",
pendingBackgroundTasks:
change === "pending" ? [{ taskId: "task", kind: "command" }] : [],
latestRunCompletedAt: change === "activity" ? at(-DAY_MS) : null,
},
...(change === "unrelated" ? [shell({ ...root, id: ThreadId.make("other") })] : []),
]);
yield* Deferred.succeed(fixture.resume, undefined);
expect((yield* Fiber.join(run)).entries[0]).toMatchObject({
outcome: "kept",
reason: "Thread activity or shared worktree changed since check",
});
expect(yield* fixture.fs.exists(fixture.worktree)).toBe(true);
}),
),
);
});
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<OrchestrationV2ThreadShell> = {},
) =>
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),
);
// Releases one stopped-session event after the startup sweep and returns the snapshot reads it caused.
const stopSessionAfterStartupSweep = (
fixture: Effect.Success<ReturnType<typeof cleanupFixture>>,
threadId: ThreadId,
beforeStop: Effect.Effect<void> = Effect.void,
cwd = fixture.worktree,
) =>
Effect.gen(function* () {
const startupSwept = yield* Deferred.make<void>();
const delivered = yield* Deferred.make<void>();
const stopped: OrchestrationV2DomainEvent = {
id: EventId.make("event:session-stopped"),
type: "provider-session.updated",
threadId,
occurredAt: at(0),
payload: {
id: ProviderSessionId.make("session-1"),
driver: ProviderDriverKind.make("codex"),
providerInstanceId: ProviderInstanceId.make("codex"),
status: "stopped",
cwd,
model: null,
capabilities: CodexProviderCapabilitiesV2,
createdAt: at(-DAY_MS),
updatedAt: at(0),
lastError: null,
},
};
yield* fixture.activate(
Stream.fromEffect(Deferred.await(startupSwept)).pipe(
Stream.flatMap(() => Stream.make(stopped)),
Stream.concat(
Stream.fromEffect(Deferred.succeed(delivered, undefined)).pipe(Stream.drain),
),
),
);
yield* fixture.service.reports.pipe(
Stream.filter((report) => report !== null),
Stream.take(1),
Stream.runDrain,
);
yield* fixture.service.drain;
yield* beforeStop;
const readsBefore = fixture.snapshotReads();
yield* Deferred.succeed(startupSwept, undefined);
yield* Deferred.await(delivered);
yield* fixture.service.drain;
return fixture.snapshotReads() - readsBefore;
});
it.effect("does not sweep when a live thread's session stops and no deleted worktree waits", () =>
Effect.gen(function* () {
yield* TestClock.setTime(NOW_MS);
const fixture = yield* cleanupFixture();
const reads = yield* stopSessionAfterStartupSweep(fixture, ThreadId.make("thread-1"));
expect(reads, "a live thread's stopped session re-read every thread").toBe(0);
}).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
);
it.effect("removes a deleted thread's worktree once its session stops", () =>
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([]);
fixture.setOpenSessionCwd(fixture.worktree);
const reads = yield* stopSessionAfterStartupSweep(
fixture,
owner.id,
Effect.sync(() => fixture.setSessionLive(false)),
);
expect(reads).toBeGreaterThan(0);
expect(yield* fixture.fs.exists(fixture.worktree)).toBe(false);
}).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
);
it.effect("removes a deleted thread's worktree once a live thread's session in it stops", () =>
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);
const child = subagent(owner);
fixture.setDeletedThreads([owner]);
fixture.setThreads([child]);
fixture.setOpenSessionCwd(fixture.worktree);
const reads = yield* stopSessionAfterStartupSweep(
fixture,
child.id,
Effect.gen(function* () {
expect((yield* fixture.service.latestReport)?.entries[0]).toMatchObject({
threadId: owner.id,
outcome: "kept",
reason: "Provider session is still open",
});
fixture.setSessionLive(false);
}),
);
expect(reads).toBeGreaterThan(0);
expect(yield* fixture.fs.exists(fixture.worktree)).toBe(false);
}).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
);
it.effect(
"removes a deleted thread's worktree once its terminal closes and its session stops",
() =>
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([]);
yield* fixture.setTerminals([
{
threadId: owner.id,
terminalId: "terminal-1",
cwd: fixture.worktree,
worktreePath: fixture.worktree,
status: "running",
pid: 1,
exitCode: null,
exitSignal: null,
hasRunningSubprocess: false,
label: "Terminal",
updatedAt: DateTime.formatIso(at(0)),
},
]);
const reads = yield* stopSessionAfterStartupSweep(
fixture,
owner.id,
Effect.gen(function* () {
expect((yield* fixture.service.latestReport)?.entries[0]).toMatchObject({
threadId: owner.id,
outcome: "kept",
reason: "Open terminal",
});
yield* fixture.setTerminals([]);
}),
fixture.repo,
);
expect(reads).toBeGreaterThan(0);
expect(yield* fixture.fs.exists(fixture.worktree)).toBe(false);
}).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
);
it.effect(
"retries a deleted thread's worktree kept for another reason when a session in it stops",
() =>
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([]);
yield* fixture.fs.writeFileString(`${fixture.worktree}/tracked.txt`, "agent edit\n");
const reads = yield* stopSessionAfterStartupSweep(
fixture,
owner.id,
Effect.gen(function* () {
expect((yield* fixture.service.latestReport)?.entries[0]).toMatchObject({
threadId: owner.id,
outcome: "kept",
reason: "Has uncommitted changes (1 file)",
});
yield* fixture.fs
.writeFileString(`${fixture.worktree}/tracked.txt`, "original\n")
.pipe(Effect.orDie);
}),
);
expect(reads).toBeGreaterThan(0);
expect(yield* fixture.fs.exists(fixture.worktree)).toBe(false);
}).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
);
it.effect("does not sweep for a kept deleted worktree when a session elsewhere stops", () =>
Effect.gen(function* () {
yield* TestClock.setTime(NOW_MS);
const fixture = yield* cleanupFixture({
...DEFAULT_SERVER_SETTINGS.storageCleanup,
worktreeAfterDays: null,
worktreeOnDelete: true,
});
fixture.setDeletedThreads([parent(fixture.worktree)]);
fixture.setThreads([]);
yield* fixture.fs.writeFileString(`${fixture.worktree}/tracked.txt`, "agent edit\n");
const reads = yield* stopSessionAfterStartupSweep(
fixture,
ThreadId.make("thread-elsewhere"),
Effect.void,
fixture.repo,
);
expect(reads).toBe(0);
expect(yield* fixture.fs.exists(fixture.worktree)).toBe(true);
}).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
);
it.effect(
"does not sweep for a deleted thread whose cleanup effect failed when a session elsewhere stops",
() =>
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([]);
fixture.setOutboxStatus("failed");
const reads = yield* stopSessionAfterStartupSweep(
fixture,
ThreadId.make("thread-elsewhere"),
Effect.gen(function* () {
expect((yield* fixture.service.latestReport)?.entries[0]).toMatchObject({
threadId: owner.id,
outcome: "kept",
reason: "Thread deletion is still pending",
});
}),
fixture.repo,
);
expect(reads).toBe(0);
}).pipe(Effect.provide(cleanupTestLayer), Effect.scoped),
);
it.effect(
"removes a deleted thread's worktree when its session stops during the deletion's sweep",
() =>
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.setThreads([]);
const startupSwept = yield* Deferred.make<void>();
const sessionChecked = yield* Deferred.make<void>();
const delivered = yield* Deferred.make<void>();
const deleted = {
id: EventId.make("event:thread-deleted"),
type: "thread.deleted",
threadId: owner.id,
occurredAt: at(0),
payload: owner,
} as unknown as OrchestrationV2DomainEvent;
const stopped: OrchestrationV2DomainEvent = {
id: EventId.make("event:session-stopped"),
type: "provider-session.updated",
threadId: owner.id,
occurredAt: at(0),
payload: {
id: ProviderSessionId.make("session-1"),
driver: ProviderDriverKind.make("codex"),
providerInstanceId: ProviderInstanceId.make("codex"),
status: "stopped",
cwd: fixture.worktree,
model: null,
capabilities: CodexProviderCapabilitiesV2,
createdAt: at(-DAY_MS),
updatedAt: at(0),
lastError: null,
},
};
yield* fixture.activate(
Stream.fromEffect(Deferred.await(startupSwept)).pipe(
Stream.flatMap(() => Stream.make(deleted)),
Stream.concat(Stream.fromEffect(Deferred.await(sessionChecked)).pipe(Stream.drain)),
Stream.concat(Stream.make(stopped)),
Stream.concat(
Stream.fromEffect(Deferred.succeed(delivered, undefined)).pipe(Stream.drain),
),
),
);
yield* fixture.service.reports.pipe(
Stream.filter((report) => report !== null),
Stream.take(1),
Stream.runDrain,
);
yield* fixture.service.drain;
fixture.setDeletedThreads([owner]);
fixture.setOpenSessionCwd(fixture.worktree);
// The deletion's sweep sees the session live; it stops before that sweep publishes its result.
fixture.setOnLiveCheck(
Effect.gen(function* () {
fixture.setOnLiveCheck(Effect.void);
yield* Deferred.succeed(sessionChecked, undefined);
yield* Deferred.await(delivered);
fixture.setSessionLive(false);
}),
);
yield* Deferred.succeed(startupSwept, undefined);
yield* Deferred.await(delivered);
yield* fixture.service.drain;
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(
Effect.gen(function* () {
const fixture = yield* cleanupFixture();
fixture.setThreads(
Array.from({ length: 205 }, (_, index) =>
shell({
id: ThreadId.make(`busy-${index}`),
branch: "busy",
worktreePath: `${fixture.config.worktreesDir}/busy-${index}`,
status: "running",
}),
),
);
for (let index = 0; index < 205; index++) {
yield* fixture.fs.makeDirectory(`${fixture.config.worktreesDir}/busy-${index}`);
}
const orphans = ["one", "two"].map(
(name) => `${fixture.config.worktreesDir}/repository/${name}`,
);
for (const orphan of orphans) {
yield* fixture.fs.makeDirectory(orphan, { recursive: true });
yield* fixture.fs.utimes(orphan, 1, 1);
}
const report = yield* fixture.service.runNow;
expect(report.entries).toHaveLength(200);
expect(
report.entries
.slice(0, 2)
.map((entry) => entry.path)
.sort(),
).toEqual(orphans);
expect(report.counts).toEqual({ removed: 0, kept: 207, failed: 0 });
expect(report.omittedCount).toBe(7);
}),
),
);
it.live.each(["canonical", "win32", "linux"] as const)(
"skips an ancestor of a referenced thread worktree (%s)",
(platform) =>
runCleanupTest(
Effect.gen(function* () {
const fixture = yield* cleanupFixture().pipe(
Effect.provideService(HostProcess.Platform, platform === "win32" ? "win32" : "linux"),
);
fixture.setThreads([]);
const ancestor = `${fixture.config.worktreesDir}/repository/stack`;
const worktree = `${ancestor}/feature`;
yield* fixture.command(fixture.repo, ["worktree", "add", "-b", "nested", worktree]);
const alias = `${fixture.repo}/alias`;
if (platform === "canonical") yield* fixture.fs.symlink(worktree, alias);
fixture.setStoredWorktreePaths([
platform === "canonical"
? alias
: platform === "win32"
? worktree.toUpperCase()
: worktree,
]);
yield* fixture.fs.utimes(ancestor, 1, 1);
expect((yield* fixture.service.runNow).entries).toEqual([]);
expect(yield* fixture.fs.exists(worktree)).toBe(true);
}),
),
);
it.live("continues reporting when a project root cannot be probed", () =>
runCleanupTest(
Effect.gen(function* () {
const fixture = yield* cleanupFixture();
fixture.setThreads([]);
const loop = `${fixture.repo}/loop`;
yield* fixture.fs.symlink(loop, loop);
fixture.setProjectRoots([fixture.repo, loop]);
const orphan = `${fixture.config.worktreesDir}/repository/orphan`;
yield* fixture.fs.makeDirectory(orphan, { recursive: true });
yield* fixture.fs.utimes(orphan, 1, 1);
expect((yield* fixture.service.runNow).entries).toEqual([
expect.objectContaining({ path: orphan, outcome: "kept", bytes: 0 }),
]);
}),
),
);
it.live.each(["nested", "direct"] as const)(
"reports a linked orphan's size without removing its files (%s)",
(location) =>
runCleanupTest(
Effect.gen(function* () {
const fixture = yield* cleanupFixture();
fixture.setThreads([]);
const orphan = `${fixture.config.worktreesDir}/${location === "nested" ? "repository/" : ""}orphan`;
yield* fixture.command(fixture.repo, ["worktree", "add", "-b", "orphan", orphan]);
const sizes = yield* Effect.forEach(yield* fixture.fs.readDirectory(orphan), (name) =>
allocatedBytes(fixture.fs, `${orphan}/${name}`),
);
const outside = yield* fixture.fs.makeTempDirectoryScoped();
yield* fixture.fs.writeFileString(`${outside}/external`, "outside data");
yield* fixture.fs.symlink(outside, `${orphan}/linked-directory`);
yield* fixture.fs.symlink(`${outside}/missing`, `${orphan}/dangling-link`);
yield* fixture.fs.utimes(orphan, 1, 1);
const report = yield* fixture.service.runNow;
expect(report.entries).toEqual([
{
kind: "worktree",
outcome: "kept",
reason: "No thread uses this worktree",
path: orphan,
projectPath: null,
threadId: null,
threadTitle: null,
bytes: sizes.reduce((sum, size) => sum + size, 0),
files: null,
},
]);
expect(report.bytesFreed).toBe(0);
expect(yield* fixture.fs.readFileString(`${orphan}/tracked.txt`)).toBe("original\n");
expect(yield* fixture.fs.readFileString(`${outside}/external`)).toBe("outside data");
expect(
(yield* fixture.command(orphan, ["rev-parse", "--is-inside-work-tree"])).stdout.trim(),
).toBe("true");
}),
),
);
it.live.each(["active", "outside-active-snapshot"] as const)(
"does not report a folder referenced by a thread (%s)",
(location) =>
runCleanupTest(
Effect.gen(function* () {
const fixture = yield* cleanupFixture();
const worktreePath = `${fixture.config.worktreesDir}/repository/referenced`;
yield* fixture.command(fixture.repo, [
"worktree",
"add",
"-b",
"referenced",
worktreePath,
]);
fixture.setThreads(
location === "active"
? [shell({ branch: "referenced", worktreePath, status: "running" })]
: [],
);
if (location !== "active")
fixture.setStoredWorktreePaths([fixture.worktree, worktreePath]);
yield* fixture.fs.utimes(worktreePath, 1, 1);
const report = yield* fixture.service.runNow;
expect(report.entries.filter((entry) => entry.threadId === null)).toEqual([]);
expect(yield* fixture.fs.exists(worktreePath)).toBe(true);
}),
),
);
it.live.each(["exact", "nested", "symlink"] as const)(
"does not report a folder containing a project checkout (%s)",
(location) =>
runCleanupTest(
Effect.gen(function* () {
const fixture = yield* cleanupFixture();
fixture.setThreads([]);
const worktreePath = `${fixture.config.worktreesDir}/repository/project-checkout`;