The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
Expire closed workspaces that open descendants do not use (#17464)
Devin Foleyfe85fd7ac45d
diff --git a/doc/DEVELOPING.md b/doc/DEVELOPING.mdindex 0e44d7feb8..fea6694f2e 100644--- a/doc/DEVELOPING.md+++ b/doc/DEVELOPING.md@@ -2618,8 +2618,8 @@ Environment overrides:- `PAPERCLIP_GIT_RESTORE_POINTS_ENABLED=true` lets git cache expiration remove closedworktrees with unpushed or uncommitted work after saving an encrypted restore point(see `doc/recoverable-disk-cleanup.md`). It is off by default.- `PAPERCLIP_GIT_RESTORE_POINT_TERMINAL_DELAY_DAYS=<days>` sets how long the issue tree- must be closed first. The default is `3`. A negative, empty, or non-numeric value falls+ `PAPERCLIP_GIT_RESTORE_POINT_TERMINAL_DELAY_DAYS=<days>` sets how long the issues that+ use the workspace (the source issue and descendants bound to it) must be closed first. The default is `3`. A negative, empty, or non-numeric value fallsback to the default.`PAPERCLIP_GIT_RESTORE_POINT_IDLE_DAYS=<days>` sets how long an open issue tree'sworktree must go untouched before it is removed the same way; runs restore itdiff --git a/doc/recoverable-disk-cleanup.md b/doc/recoverable-disk-cleanup.mdindex 1fa8a1a892..ea4aa98200 100644--- a/doc/recoverable-disk-cleanup.md+++ b/doc/recoverable-disk-cleanup.md@@ -158,6 +158,17 @@ closed issue's worktree only when its remote can reproduce it exactly. With`PAPERCLIP_GIT_RESTORE_POINTS_ENABLED=true`, it can also remove a worktree that hasunpushed commits, uncommitted or untracked files, or history-only commits, once its issuetree has been closed for `PAPERCLIP_GIT_RESTORE_POINT_TERMINAL_DELAY_DAYS` (default `3`).+For this, only the issues in the tree that use the workspace count: the source issue, and+each descendant that is bound to it (`execution_workspace_id`, which is how a child that+inherits the parent's workspace with `reuse_existing` is recorded) or that selects it as+its current or pending existing workspace. The delay runs from the latest close time among+those issues. A closed issue's worktree can therefore be removed while descendants that+work in their own workspaces stay open. Any issue still bound to the workspace, and any+live run, finalization, lease, recovery action or runtime service of an issue in the tree+or of the workspace, still keeps it. If an open descendant later binds to the removed+workspace, its next run or a comment reopens it from the restore point, as below. The+workspace reaper does not compact or archive such a worktree by its normal rules while+descendants are open; only expiration removes it.It also removes the worktree of an issue tree that is still open once nothing hastouched it for `PAPERCLIP_GIT_RESTORE_POINT_IDLE_DAYS` (default `7`, `0` turns this off):no issue in the tree or bound to the workspace was updated and no run for those issues ordiff --git a/server/src/__tests__/git-restore-point-expiration.test.ts b/server/src/__tests__/git-restore-point-expiration.test.tsindex 510c9a536e..49a05169ab 100644--- a/server/src/__tests__/git-restore-point-expiration.test.ts+++ b/server/src/__tests__/git-restore-point-expiration.test.ts@@ -14,7 +14,8 @@ import { executionWorkspaceService } from "../services/execution-workspaces.js";import { expireReconstructableGitWorkspace, gitWorkspaceLastActivityAt } from "../services/git-workspace-expiration.js";import { getStorageService } from "../storage/index.js";import { markGitRestorePointExpired } from "../services/git-restore-point-storage.js";-import { GIT_RESTORE_POINT_EXPIRED_WARNING } from "../services/execution-workspaces.js";+import { GIT_RESTORE_POINT_EXPIRED_WARNING, setMetadataReopenPendingConsumption } from "../services/execution-workspaces.js";+import { issueService } from "../services/issues.js";const gitEnv = { ...process.env, GIT_AUTHOR_NAME: "Fixture", GIT_AUTHOR_EMAIL: "[email protected]",GIT_COMMITTER_NAME: "Fixture", GIT_COMMITTER_EMAIL: "[email protected]", GIT_TERMINAL_PROMPT: "0" };@@ -356,6 +357,181 @@ describeEmbeddedPostgres("git restore point expiration", () => {});});+ describe("closed source issue with open descendants", () => {+ async function child(f: Awaited<ReturnType<typeof fixture>>, values: Partial<typeof issues.$inferInsert> = {}) {+ const id = randomUUID();+ await db.insert(issues).values({ id, companyId: f.companyId, parentId: f.issueId, title: "Follow-up", status: "blocked", ...values });+ return id;+ }+ async function ownWorkspace(f: Awaited<ReturnType<typeof fixture>>, sourceIssueId: string) {+ const id = randomUUID();+ await db.insert(executionWorkspaces).values({ id, companyId: f.companyId, sourceIssueId, mode: "isolated_workspace", strategyType: "git_worktree",+ name: "Child workspace", status: "active", providerType: "local_fs", cwd: path.join(root, "child-workspaces", id), providerRef: path.join(root, "child-workspaces", id) });+ await db.update(issues).set({ executionWorkspaceId: id, executionWorkspacePreference: "reuse_existing" }).where(eq(issues.id, sourceIssueId));+ return id;+ }+ const worker = (now = Date.now()) => executionWorkspaceService(db, { gitCacheExpirationEnabled: true, now: () => new Date(now),+ gitRestorePoints: { storage: getStorageService(), terminalDelayMs: 3 * DAY_MS, keyDurable: true, idleMs: 7 * DAY_MS } });++ it("expires the closed issue's worktree while open children work in their own workspaces", async () => {+ const f = await fixture();+ const unpushed = await makeUnsavedWork(f.cwd);+ const blocked = await child(f, { status: "blocked" });+ await ownWorkspace(f, blocked);+ const reviewing = await child(f, { status: "in_review" });+ await ownWorkspace(f, reviewing);+ const grandchild = await child(f, { parentId: reviewing, status: "in_progress" });+ await ownWorkspace(f, grandchild);+ await child(f, { status: "todo" });+ expect(await f.expire()).toMatchObject({ candidate: true, expired: true, restorePoint: true, skipReason: null });+ expect(await exists(f.cwd)).toBe(false);+ expect(await f.ledger()).toMatchObject([{ status: "active" }]);+ expect(await f.reopen()).toMatchObject({ ok: true, reopened: true });+ expect(git(f.cwd, "rev-parse", "HEAD")).toBe(unpushed);+ expect(await fs.readFile(path.join(f.cwd, "notes", "todo.md"), "utf8")).toBe("untracked work\n");+ });++ it("lets the workspace reaper expire it, timed from the issues that use the workspace", async () => {+ const f = await fixture();+ await makeUnsavedWork(f.cwd);+ const open = await child(f, { status: "in_progress", updatedAt: new Date() });+ await ownWorkspace(f, open);+ const closed = await child(f, { status: "done", completedAt: new Date(Date.now() - 60_000) });+ await ownWorkspace(f, closed);+ expect(await worker().sweepTerminalWorkspaces()).toMatchObject({ archived: 1 });+ expect(await exists(f.cwd)).toBe(false);+ expect((await f.row()).status).toBe("archived");+ expect(await f.ledger()).toMatchObject([{ status: "active" }]);+ });++ it("times the restore point from the issues that use the workspace once every child is closed", async () => {+ const f = await fixture();+ await makeUnsavedWork(f.cwd);+ const closed = await child(f, { status: "done", completedAt: new Date(Date.now() - 60_000) });+ await ownWorkspace(f, closed);+ expect(await worker().sweepTerminalWorkspaces()).toMatchObject({ archived: 1 });+ expect(await exists(f.cwd)).toBe(false);+ expect(await f.ledger()).toMatchObject([{ status: "active" }]);+ });++ it("waits for the terminal delay of a recently closed child that used the workspace", async () => {+ const f = await fixture();+ await makeUnsavedWork(f.cwd);+ await child(f, { status: "in_progress" }).then(id => ownWorkspace(f, id));+ const closedAt = new Date(Date.now() - DAY_MS);+ await child(f, { status: "done", completedAt: closedAt, executionWorkspaceId: f.workspaceId });+ const early = worker();+ expect(await early.sweepTerminalWorkspaces()).toMatchObject({ archived: 0 });+ expect(await exists(f.cwd)).toBe(true);+ expect(await worker(closedAt.getTime() + 3 * DAY_MS + 60_000).sweepTerminalWorkspaces()).toMatchObject({ archived: 1 });+ expect(await exists(f.cwd)).toBe(false);+ });++ it("never compacts a closed issue's worktree while children are open", async () => {+ const f = await fixture();+ await makeUnsavedWork(f.cwd);+ await db.update(executionWorkspaces).set({ providerType: "git_worktree" }).where(eq(executionWorkspaces.id, f.workspaceId));+ await db.update(issues).set({ completedAt: new Date(Date.now() - 2 * DAY_MS) }).where(eq(issues.id, f.issueId));+ await fs.mkdir(path.join(f.cwd, "node_modules", "pkg"), { recursive: true });+ await fs.writeFile(path.join(f.cwd, "node_modules", "pkg", "index.js"), "module.exports = 1;\n");+ await child(f, { status: "in_progress" }).then(id => ownWorkspace(f, id));+ for (const reaper of [executionWorkspaceService(db, { workspaceCompactionDelayMs: 0 }),+ executionWorkspaceService(db, { workspaceCompactionDelayMs: 0, gitCacheExpirationEnabled: true,+ gitRestorePoints: { storage: getStorageService(), terminalDelayMs: 3 * DAY_MS, keyDurable: true } })]) {+ expect(await reaper.sweepTerminalWorkspaces()).toMatchObject({ archived: 0, compacted: 0 });+ expect(await exists(path.join(f.cwd, "node_modules", "pkg", "index.js"))).toBe(true);+ }+ });++ it("keeps today's reopen fence handling while a reopen is pending", async () => {+ const f = await fixture();+ await makeUnsavedWork(f.cwd);+ await child(f, { status: "in_progress" }).then(id => ownWorkspace(f, id));+ await db.update(executionWorkspaces).set({ metadata: setMetadataReopenPendingConsumption((await f.row()).metadata, new Date()) })+ .where(eq(executionWorkspaces.id, f.workspaceId));+ expect(await worker().sweepTerminalWorkspaces()).toMatchObject({ archived: 0 });+ expect(await exists(f.cwd)).toBe(true);+ expect((await f.row()).metadata?.reopenPendingConsumption).toBeUndefined();+ });++ it("keeps the worktree while an open child is bound to it", async () => {+ const f = await fixture();+ await makeUnsavedWork(f.cwd);+ await child(f, { status: "blocked", executionWorkspaceId: f.workspaceId, executionWorkspacePreference: "reuse_existing" });+ expect(await f.expire()).toMatchObject({ expired: false, skipReason: "live_or_unresolved_consumer" });+ expect(await worker().sweepTerminalWorkspaces()).toMatchObject({ archived: 0, skippedNonTerminalTree: 1 });+ expect(await exists(f.cwd)).toBe(true);+ });++ it("keeps the worktree while an open grandchild is bound to it under a child with its own workspace", async () => {+ const f = await fixture();+ const middle = await child(f, { status: "in_review" });+ await ownWorkspace(f, middle);+ await child(f, { parentId: middle, status: "todo", executionWorkspaceId: f.workspaceId });+ expect(await f.expire()).toMatchObject({ expired: false, skipReason: "live_or_unresolved_consumer" });+ expect(await exists(f.cwd)).toBe(true);+ });++ it("keeps the worktree for a child created later that inherits it with reuse_existing", async () => {+ const f = await fixture();+ const created = await issueService(db).create(f.companyId, { parentId: f.issueId, title: "Inherited follow-up", status: "todo" });+ expect(created).toMatchObject({ executionWorkspaceId: f.workspaceId, executionWorkspacePreference: "reuse_existing" });+ expect(await f.expire()).toMatchObject({ expired: false, skipReason: "live_or_unresolved_consumer" });+ expect(await worker().sweepTerminalWorkspaces()).toMatchObject({ archived: 0, skippedNonTerminalTree: 1 });+ expect(await exists(f.cwd)).toBe(true);+ });++ it("keeps the worktree while an open child selects it as its existing workspace", async () => {+ const f = await fixture();+ const selection = { kind: "existing" as const, workspaceId: f.workspaceId };+ const selecting = await child(f, { status: "todo", workspaceSelection: { version: 1, selection, source: "explicit" } });+ expect(await f.expire()).toMatchObject({ expired: false, skipReason: "live_or_unresolved_consumer" });+ await db.update(issues).set({ workspaceSelection: null, workspacePendingSelection: { version: 1, requestKey: "fixture",+ expectedBindingRevision: 0, intent: { version: 1, selection, source: "explicit" } } }).where(eq(issues.id, selecting));+ expect(await f.expire()).toMatchObject({ expired: false, skipReason: "live_or_unresolved_consumer" });+ await db.update(issues).set({ workspacePendingSelection: null }).where(eq(issues.id, selecting));+ expect(await f.expire()).toMatchObject({ expired: true });+ });++ it("keeps the worktree while a child run referencing it is live", async () => {+ const f = await fixture();+ const running = await child(f, { status: "in_progress" });+ await ownWorkspace(f, running);+ const agentId = randomUUID();+ await db.insert(agents).values({ id: agentId, companyId: f.companyId, name: "Worker", adapterType: "process" });+ const [run] = await db.insert(heartbeatRuns).values({ companyId: f.companyId, agentId, status: "running", startedAt: new Date(),+ contextSnapshot: { issueId: running, executionWorkspaceId: f.workspaceId } }).returning();+ expect(await f.expire()).toMatchObject({ expired: false, skipReason: "live_or_unresolved_consumer" });+ expect(await exists(f.cwd)).toBe(true);+ await db.update(heartbeatRuns).set({ status: "succeeded", finishedAt: new Date() }).where(eq(heartbeatRuns.id, run!.id));+ expect(await f.expire()).toMatchObject({ expired: true });+ });++ it("keeps the worktree while the closed issue was closed inside the terminal delay", async () => {+ const f = await fixture();+ await db.update(issues).set({ completedAt: new Date(Date.now() - 60_000) }).where(eq(issues.id, f.issueId));+ await child(f, { status: "in_progress" }).then(id => ownWorkspace(f, id));+ expect(await f.expire()).toMatchObject({ expired: false, skipReason: "live_or_unresolved_consumer" });+ expect(await exists(f.cwd)).toBe(true);+ });++ it("restores the saved state when an open child later binds to the expired workspace", async () => {+ const f = await fixture();+ const unpushed = await makeUnsavedWork(f.cwd);+ const follower = await child(f, { status: "in_progress" });+ expect(await f.expire()).toMatchObject({ expired: true, restorePoint: true });+ await db.update(issues).set({ executionWorkspaceId: f.workspaceId, executionWorkspacePreference: "reuse_existing" }).where(eq(issues.id, follower));+ const reopened = await executionWorkspaceService(db).reopenClosedIsolatedExecutionWorkspaceForIssue({ workspaceId: f.workspaceId,+ issue: { id: follower, companyId: f.companyId, projectId: null }, actor: { actorType: "user", agentId: null },+ authorizationActor: { type: "board", source: "local_implicit", isInstanceAdmin: true } });+ expect(reopened).toMatchObject({ ok: true, reopened: true });+ expect(git(f.cwd, "rev-parse", "HEAD")).toBe(unpushed);+ expect(await fs.readFile(path.join(f.cwd, "marker.txt"), "utf8")).toBe("unstaged edit\n");+ expect(git(f.cwd, "show", ":marker.txt")).toBe("staged edit");+ expect(await fs.readFile(path.join(f.cwd, "notes", "todo.md"), "utf8")).toBe("untracked work\n");+ });+ });+it("expires a worktree whose only extra files are ignored, and restores them on reopen", async () => {const f = await fixture();await fs.mkdir(path.join(f.cwd, "ui"), { recursive: true });diff --git a/server/src/__tests__/git-workspace-expiration.test.ts b/server/src/__tests__/git-workspace-expiration.test.tsindex 7055ede59d..80a1b51005 100644--- a/server/src/__tests__/git-workspace-expiration.test.ts+++ b/server/src/__tests__/git-workspace-expiration.test.ts@@ -816,7 +816,8 @@ describeEmbeddedPostgres("reconstructable Git expiration", () => {it("preserves live descendants and pending reopening", async () => {const f = await fixture();- await db.insert(issues).values({ companyId: f.companyId, title: "Active child", status: "in_progress", parentId: f.issueId });+ await db.insert(issues).values({ companyId: f.companyId, title: "Active child", status: "in_progress", parentId: f.issueId,+ executionWorkspaceId: f.workspaceId, executionWorkspacePreference: "reuse_existing" });expect((await f.expire()).expired).toBe(false);await db.delete(issues).where(eq(issues.parentId, f.issueId));const row = await f.row();diff --git a/server/src/__tests__/heartbeat-git-restore-point-resume.test.ts b/server/src/__tests__/heartbeat-git-restore-point-resume.test.tsindex dc5ebb6d3f..9620083333 100644--- a/server/src/__tests__/heartbeat-git-restore-point-resume.test.ts+++ b/server/src/__tests__/heartbeat-git-restore-point-resume.test.ts@@ -68,7 +68,7 @@ describe.skipIf(!support.supported)("heartbeat resume of an idle-expired workspaawait fs.rm(root, { recursive: true, force: true });}, 60_000);- async function seed() {+ async function seed(options: { closedParent?: boolean } = {}) {const home = path.join(root, randomUUID());vi.stubEnv("PAPERCLIP_HOME", home);vi.stubEnv("PAPERCLIP_INSTANCE_ID", "default");@@ -108,24 +108,31 @@ describe.skipIf(!support.supported)("heartbeat resume of an idle-expired workspaisolatedRemoteSource: { schema: "paperclip.isolated-remote-source.v1", companyId, issueId, repoUrl } } });await db.update(issues).set({ executionWorkspaceId: workspaceId, executionWorkspacePreference: "reuse_existing", updatedAt: idleSince }).where(eq(issues.id, issueId));+ const childId = randomUUID();+ if (options.closedParent) {+ await db.update(issues).set({ status: "done", completedAt: new Date(Date.now() - 4 * DAY_MS) }).where(eq(issues.id, issueId));+ await db.insert(issues).values({ id: childId, companyId, projectId, parentId: issueId, title: "Open follow-up", status: "in_progress",+ workMode: "standard", assigneeAgentId: agentId, responsibleUserId: "responsible-user", issueNumber: 2, identifier: `${issuePrefix}-2`,+ executionWorkspaceSettings: { mode: "isolated_workspace" } });+ }await fs.writeFile(path.join(realized.cwd, "marker.txt"), "commit B (unpushed)\n");git(realized.cwd, "commit", "-qam", "B");const unpushed = git(realized.cwd, "rev-parse", "HEAD");await fs.writeFile(path.join(realized.cwd, "notes.md"), "uncommitted notes\n");const workspace = () => db.select().from(executionWorkspaces).where(eq(executionWorkspaces.id, workspaceId)).then(rows => rows[0]!);const expiration = await expireReconstructableGitWorkspace(db, await workspace(), {- dryRun: false, expireBase: false, now: new Date(), idleCutoff: new Date(Date.now() - 7 * DAY_MS),+ dryRun: false, expireBase: false, now: new Date(), idleCutoff: options.closedParent ? undefined : new Date(Date.now() - 7 * DAY_MS),restorePoint: { storage: getStorageService(), notBefore: new Date(Date.now() - DAY_MS), keyDurable: true },});- const queueRun = async () => {+ const queueRun = async (target = issueId) => {await db.insert(agentWakeupRequests).values({ id: wakeupId, companyId, agentId, source: "assignment", triggerDetail: "system",- reason: "issue_assigned", payload: { issueId }, status: "queued", runId });+ reason: "issue_assigned", payload: { issueId: target }, status: "queued", runId });await db.insert(heartbeatRuns).values({ id: runId, companyId, agentId, invocationSource: "assignment", triggerDetail: "system", status: "queued",- wakeupRequestId: wakeupId, responsibleUserId: "responsible-user", contextSnapshot: { issueId, taskId: issueId, wakeReason: "issue_assigned" } });+ wakeupRequestId: wakeupId, responsibleUserId: "responsible-user", contextSnapshot: { issueId: target, taskId: target, wakeReason: "issue_assigned" } });await db.update(issues).set({ checkoutRunId: runId, executionRunId: runId, executionAgentNameKey: "resumer", executionLockedAt: new Date() })- .where(eq(issues.id, issueId));+ .where(eq(issues.id, target));};- return { issueId, workspaceId, runId, cwd: realized.cwd, unpushed, expiration, workspace, queueRun };+ return { issueId, childId, workspaceId, runId, cwd: realized.cwd, unpushed, expiration, workspace, queueRun };}async function waitForRun(heartbeat: ReturnType<typeof heartbeatService>, runId: string) {@@ -159,4 +166,23 @@ describe.skipIf(!support.supported)("heartbeat resume of an idle-expired workspaconst [issue] = await db.select().from(issues).where(eq(issues.id, seeded.issueId));expect(issue.executionWorkspaceId).toBe(seeded.workspaceId);});++ it("restores a closed parent's expired workspace when an open child binds to it", async () => {+ const seeded = await seed({ closedParent: true });+ expect(seeded.expiration).toMatchObject({ expired: true, restorePoint: true });+ await expect(fs.access(seeded.cwd)).rejects.toMatchObject({ code: "ENOENT" });+ await db.update(issues).set({ executionWorkspaceId: seeded.workspaceId, executionWorkspacePreference: "reuse_existing" })+ .where(eq(issues.id, seeded.childId));+ await seeded.queueRun(seeded.childId);+ const heartbeat = heartbeatService(db);+ await heartbeat.resumeQueuedRuns();+ const run = await waitForRun(heartbeat, seeded.runId);+ await heartbeat.waitForRunExecutionDrain(seeded.runId);+ expect(run).toMatchObject({ status: "succeeded" });+ expect(adapterExecute.mock.calls[0]?.[0]).toMatchObject({ context: { executionWorkspaceId: seeded.workspaceId,+ paperclipWorkspace: { cwd: seeded.cwd } } });+ expect(git(seeded.cwd, "rev-parse", "HEAD")).toBe(seeded.unpushed);+ expect(await fs.readFile(path.join(seeded.cwd, "notes.md"), "utf8")).toBe("uncommitted notes\n");+ expect((await seeded.workspace()).status).not.toBe("archived");+ });});diff --git a/server/src/services/execution-workspaces.ts b/server/src/services/execution-workspaces.tsindex 9d42edcc6e..caf9a90511 100644--- a/server/src/services/execution-workspaces.ts+++ b/server/src/services/execution-workspaces.ts@@ -5,7 +5,7 @@ import { measureRunTransaction } from "./execution-transaction-timing.js";import { measureRunPhase } from "./execution-preparation-timing.js";import { assertExecutionWorkspaceRecordAccess, assertTaskWorkspaceExecutionAccess, assertTaskWorkspaceSourceProjectAccess } from "./task-workspace-access.js";import { verifiedRecordedIsolatedRemoteSource, withIsolatedRepositorySourceLock } from "./isolated-remote-workspace-source.js";-import { expireReconstructableGitWorkspace, gitWorkspaceLastActivityAt, hasPendingGitExpiration } from "./git-workspace-expiration.js";+import { expireReconstructableGitWorkspace, gitWorkspaceLastActivityAt, hasPendingGitExpiration, listIssuesUsingGitWorkspace } from "./git-workspace-expiration.js";import { hasPendingIsolatedRepositoryRehomeCleanup, isIsolatedRepositoryRehomeCandidate, rehomeExpiredIsolatedRestoration, rehomeIsolatedRepositoryWorkspace, sweepOrphanedIsolatedRepositorySources } from "./isolated-repository-rehome.js";import { hasPendingNestedCloneMigration, isNestedCloneMigrationCandidate, nextNestedCloneMigrationBatch, pendingNestedCloneMigrationNames, listNestedCloneMigrationNames, migrateNestedRepositoryClone,NESTED_CLONE_MIGRATION_RETRY_REASONS, type NestedCloneMigrationRotation } from "./nested-clone-migration.js";@@ -3434,7 +3434,14 @@ export function executionWorkspaceService(db: Db, opts: ExecutionWorkspaceServicworkspace.metadata as Record<string, unknown> | null,);if (reopenPending) terminalWorkspaceDeadlines.set(workspace.id, now().getTime());- if (!sourceIssue || issueTree.some(issue => !TERMINAL_ISSUE_STATUSES.has(issue.status))) {+ const treeOpen = issueTree.some(issue => !TERMINAL_ISSUE_STATUSES.has(issue.status));+ const gitExpirationCandidate = workspace.providerType !== "plugin" && Boolean(opts.gitCacheExpirationEnabled)+ && (hasPendingGitExpiration(workspace) || (workspace.mode === "isolated_workspace" && workspace.strategyType === "git_worktree"));+ const usingIssueIds = sourceIssue && gitExpirationCandidate && !reopenPending+ && TERMINAL_ISSUE_STATUSES.has(sourceIssue.status)+ ? await listIssuesUsingGitWorkspace(db, workspace, issueTree.map(issue => issue.id)) : null;+ const expirationTree = usingIssueIds ? issueTree.filter(issue => usingIssueIds.has(issue.id)) : issueTree;+ if (!sourceIssue || expirationTree.some(issue => !TERMINAL_ISSUE_STATUSES.has(issue.status))) {if (reopenPending) {await clearReopenPendingConsumptionUnderLock(workspace.id, {expectedGeneration: readExecutionWorkspaceLifecycleGeneration(@@ -3473,11 +3480,13 @@ export function executionWorkspaceService(db: Db, opts: ExecutionWorkspaceServicresult.skippedNonTerminalTree += 1;continue;}- const latestTerminalAt = Math.max(...issueTree.map(issue => issueTerminalTimestamp(issue)!.getTime()));+ const expirationTerminalAt = Math.max(...expirationTree.map(issue => issueTerminalTimestamp(issue)!.getTime()));+ const latestTerminalAt = treeOpen ? expirationTerminalAt : Math.max(...issueTree.map(issue => issueTerminalTimestamp(issue)!.getTime()));// Compaction runs once per terminal cycle, after its own delay and// before the archive cooldown, so a workspace the reaper cannot archive// yet (or ever) stops holding regenerable files.const compactionPending = workspaceCompactionDelayMs !== null+ && !treeOpen&& !isClosedExecutionWorkspaceStatus(workspace.status)&& !reopenPending&& compactedTerminalAt.get(workspace.id) !== latestTerminalAt;@@ -3503,14 +3512,13 @@ export function executionWorkspaceService(db: Db, opts: ExecutionWorkspaceServic);}}- if (workspace.providerType !== "plugin" && opts.gitCacheExpirationEnabled && (hasPendingGitExpiration(workspace)- || (workspace.mode === "isolated_workspace" && workspace.strategyType === "git_worktree"))) {+ if (gitExpirationCandidate) {const expiration = await expireReconstructableGitWorkspace(db, workspace, {dryRun: opts.gitCacheExpirationDryRun ?? false, expireBase: opts.gitBaseExpirationEnabled ?? false,now: now(), signal, beforeDelete: opts.beforeTerminalWorkspaceCleanup,restorePoint: opts.gitRestorePoints ? {storage: opts.gitRestorePoints.storage,- notBefore: new Date(latestTerminalAt + opts.gitRestorePoints.terminalDelayMs),+ notBefore: new Date(expirationTerminalAt + opts.gitRestorePoints.terminalDelayMs),keyDurable: opts.gitRestorePoints.keyDurable,} : undefined,});diff --git a/server/src/services/git-workspace-expiration.ts b/server/src/services/git-workspace-expiration.tsindex ff9e6c7ffc..c551f7471a 100644--- a/server/src/services/git-workspace-expiration.ts+++ b/server/src/services/git-workspace-expiration.ts@@ -3,7 +3,7 @@ import fs from "node:fs/promises";import path from "node:path";import { randomBytes } from "node:crypto";import { acquireGitExpirationLocks } from "./git-workspace-expiration-locks.js";-import { and, eq, ne, sql } from "drizzle-orm";+import { and, eq, inArray, ne, sql } from "drizzle-orm";import { executionWorkspaces, issues, heartbeatRuns, nativeRunFinalizations, environmentLeases,workspaceRuntimeServices, issueRecoveryActions, projectWorkspaces, withDedicatedDbConnection, type Db } from "@paperclipai/db";import { createGitRemoteAuthProvider } from "./git-credentials.js";@@ -124,6 +124,21 @@ export function expirationScope(workspace: Workspace) {)`;}+function issueUsesWorkspace(workspace: Pick<Workspace, "id" | "sourceIssueId">) {+ return sql`(${issues.id} = ${workspace.sourceIssueId} OR ${issues.executionWorkspaceId} = ${workspace.id}+ OR (${issues.workspaceSelection}->'selection'->>'kind' = 'existing'+ AND ${issues.workspaceSelection}->'selection'->>'workspaceId' = ${workspace.id})+ OR (${issues.workspacePendingSelection}->'intent'->'selection'->>'kind' = 'existing'+ AND ${issues.workspacePendingSelection}->'intent'->'selection'->>'workspaceId' = ${workspace.id}))`;+}++export async function listIssuesUsingGitWorkspace(db: Db | Tx, workspace: Pick<Workspace, "id" | "companyId" | "sourceIssueId">, issueIds: string[]) {+ if (issueIds.length === 0) return new Set<string>();+ const rows = await db.select({ id: issues.id }).from(issues)+ .where(and(eq(issues.companyId, workspace.companyId), inArray(issues.id, issueIds), issueUsesWorkspace(workspace)));+ return new Set(rows.map(row => row.id));+}+export async function gitWorkspaceLastActivityAt(db: Db | Tx, workspace: Workspace): Promise<Date | null> {if (!workspace.sourceIssueId) return null;const rows = await db.execute<{ at: string | Date | null }>(sql`${expirationScope(workspace)}@@ -142,8 +157,10 @@ export async function isGitWorkspaceExpirationEligible(tx: Tx, workspace: WorkspNOT EXISTS (SELECT 1 FROM tree WHERE updated_at > ${idleCutoff.toISOString()}::timestamptz)AND NOT EXISTS (SELECT 1 FROM bound WHERE updated_at > ${idleCutoff.toISOString()}::timestamptz)AND NOT EXISTS (SELECT 1 FROM relevant_runs WHERE greatest(created_at, started_at, finished_at) > ${idleCutoff.toISOString()}::timestamptz)` : sql`- NOT EXISTS (SELECT 1 FROM tree WHERE status NOT IN ('done', 'cancelled')- OR coalesce(CASE WHEN status = 'done' THEN completed_at ELSE cancelled_at END, updated_at) > ${new Date(now.getTime() - DAY_MS).toISOString()}::timestamptz)+ NOT EXISTS (SELECT 1 FROM ${issues} WHERE ${issues.companyId} = ${workspace.companyId}+ AND ${issues.id} IN (SELECT id FROM tree) AND ${issueUsesWorkspace(workspace)}+ AND (${issues.status} NOT IN ('done', 'cancelled')+ OR coalesce(CASE WHEN ${issues.status} = 'done' THEN ${issues.completedAt} ELSE ${issues.cancelledAt} END, ${issues.updatedAt}) > ${new Date(now.getTime() - DAY_MS).toISOString()}::timestamptz))AND NOT EXISTS (SELECT 1 FROM ${issues} WHERE company_id = ${workspace.companyId}AND execution_workspace_id = ${workspace.id} AND status NOT IN ('done', 'cancelled'))`;const recoveryActionBlocks = idleCutoff ? sql`true` : sql`(cause = 'native_workspace_finalization_owner_unverified'