From 0a3a0718013495927cf596de79e0763634a660c9 Mon Sep 17 00:00:00 2001 From: clover caruso Date: Tue, 13 Oct 2026 16:11:38 -0700 Subject: [PATCH] feat(workspaces): archive verified completed work before collection Clover wants settled workspace directories retained until their linked PRs merge, with archival releasing them for collection. Before reading deletion references, ws gc asks T3 Code to verify completion and perform guarded archival for each prepared registered directory. All quiet/settled/strict-merge eligibility and resume guards remain server-owned. The existing collector still enforces setup, all-chat, editor, live-cwd, grace, and fresh-read protections. RPC errors or unknown results pause deletion and reset grace; dry runs never request archival. Verified the caller with a stub for only the new archiveCompleted RPC against the real isolated V2 CLI/JJ/APFS/pnpm flow: failed and malformed reads preserve eligible folders, resumed chats block deletion even after a successful reply, and archived folders collect only after grace. Backend strict merge and race tests live with that API implementation. Assisted-by: gpt-6.1-sol --- users/clover/packages/workspaces/README.md | 5 +- .../clover/packages/workspaces/workspaces.mjs | 17 +++++- .../packages/workspaces/workspaces.test.mjs | 58 +++++++++++++++++++ 3 files changed, 78 insertions(+), 2 deletions(-) diff --git a/users/clover/packages/workspaces/README.md b/users/clover/packages/workspaces/README.md index 7598e3680165258db2683aef14e0411c6cdaa657..d62c27fb7e5528982fde5f9f721c8367b7377993 100644 --- a/users/clover/packages/workspaces/README.md +++ b/users/clover/packages/workspaces/README.md @@ -38,6 +38,7 @@ reserve empty folder → create and open T3 thread → release waiting Claude/Codex hooks Every 30 seconds: + T3 verifies settled, quiet chats with linked PRs all merged → archive chats unfinished setup / unarchived T3 chat / running work / VS Code / live shell cwd → keep workspace, reset grace no references for ≥60 seconds, with a fresh check immediately before removal @@ -48,7 +49,9 @@ Every 30 seconds: Settling a chat keeps its workspace directory. Cleanup begins only after every chat using the directory is archived or deleted and no work is running. Archival -releases the directory for cleanup; settling does not. +releases the directory for cleanup; settling does not. Automatic archival uses +T3 Code's guarded merge check and retains chats with open, closed, or missing PRs. +An unavailable merge check pauses cleanup. `ws gc --dry-run` never archives chats. Only registered workspaces under `~/workspaces` are collected. JJ retains snapshotted changes; ignored files are deleted with the directory. Closing T3 diff --git a/users/clover/packages/workspaces/workspaces.mjs b/users/clover/packages/workspaces/workspaces.mjs index 4a344e545f4731356f87d70eeabb281a52a8edca..4f26b979134bca930af356f39a4fa8ebd015c3a7 100644 --- a/users/clover/packages/workspaces/workspaces.mjs +++ b/users/clover/packages/workspaces/workspaces.mjs @@ -256,7 +256,7 @@ export async function t3() { ); } - return { snapshot, dispatch, environment, app }; + return { snapshot, dispatch, rpc, environment, app }; } function dependencyKey(directory) { @@ -805,6 +805,21 @@ export async function main(args) { ); try { const client = await t3(); + if (argument !== "--dry-run") { + for (const entry of entries) { + const record = JSON.parse(fs.readFileSync(path.join(records, entry))); + if (!record.threadId || !record.prepared) continue; + const result = await client.rpc("managedWorkspaces.archiveCompleted", { + workspacePath: workspace(entry.slice(0, -5)), + }); + if ( + !Array.isArray(result?.archivedThreadIds) || + !result.archivedThreadIds.every((id) => typeof id === "string") + ) { + throw new Error("T3 Code returned an unknown archive result. Cleanup is paused."); + } + } + } const refs = await references(client); for (const entry of entries) { const id = entry.slice(0, -5); diff --git a/users/clover/packages/workspaces/workspaces.test.mjs b/users/clover/packages/workspaces/workspaces.test.mjs index 43a104c32a06100a5c12bc31cdb0904f0c189441..cb932cb612fa28fd2cd7821323c6d463d854616b 100644 --- a/users/clover/packages/workspaces/workspaces.test.mjs +++ b/users/clover/packages/workspaces/workspaces.test.mjs @@ -134,6 +134,25 @@ test("workspace lifecycle through nightly, JJ, APFS, and reference sockets", { ); const { main, t3 } = await import("./workspaces.mjs"); const client = await t3(); + const archiveRequests = []; + let archiveHandler = () => ({ archivedThreadIds: [] }); + const WebSocket = globalThis.WebSocket; + mock.method(globalThis, "WebSocket", function (...args) { + const socket = new WebSocket(...args); + const send = socket.send.bind(socket); + socket.send = (data) => { + const request = JSON.parse(String(data).trim()); + if (request.tag !== "managedWorkspaces.archiveCompleted") return send(data); + archiveRequests.push(request.payload); + Promise.resolve().then(() => archiveHandler(request.payload)).then( + (value) => ({ _tag: "Success", value }), + (error) => ({ _tag: "Failure", cause: error.message }), + ).then((exit) => socket.onmessage(new MessageEvent("message", { + data: JSON.stringify({ _tag: "Exit", requestId: request.id, exit }) + "\n", + }))); + }; + return socket; + }); const project = (await client.snapshot()).projects[0]; await client.dispatch({ type: "project.update", @@ -603,8 +622,21 @@ exec "$WORKSPACE_TEST_PNPM" "$@" ); assert.equal(readRecord().idleSince, null); referenceMock.mock.restore(); + archiveHandler = () => { throw new Error("PR read unavailable"); }; age(); + await assert.rejects(main(["gc"]), /PR read unavailable/); + assert.ok(fs.existsSync(first), "merge read failure stops eligible cleanup"); + assert.equal(readRecord().idleSince, null); + archiveHandler = () => ({ archivedThreadIds: "unknown" }); + age(); + await assert.rejects(main(["gc"]), /unknown archive result/); + assert.ok(fs.existsSync(first), "unknown merge response stops cleanup"); + assert.equal(readRecord().idleSince, null); + archiveHandler = () => ({ archivedThreadIds: [] }); + age(); + const requestsBeforeDryRun = archiveRequests.length; await main(["gc", "--dry-run"]); + assert.equal(archiveRequests.length, requestsBeforeDryRun, "dry run never requests archival"); assert.ok(fs.existsSync(first), "dry run never removes a workspace"); fs.writeFileSync( path.join(first, "saved.txt"), @@ -648,6 +680,32 @@ exec "$WORKSPACE_TEST_PNPM" "$@" await main(["gc"]); assert.ok(fs.existsSync(first), "a settled replacement chat keeps its workspace"); assert.equal(readRecord().idleSince, null); + archiveHandler = async ({ workspacePath }) => { + if (workspacePath !== first) return { archivedThreadIds: [] }; + await client.dispatch({ type: "thread.unsettle", threadId: freshRecord.threadId, reason: "user" }); + return { archivedThreadIds: [freshRecord.threadId] }; + }; + age(); + await main(["gc"]); + assert.ok(fs.existsSync(first), "a resumed chat keeps its workspace after the merge check"); + assert.equal(readRecord().idleSince, null); + await client.dispatch({ type: "thread.settle", threadId: freshRecord.threadId }); + archiveHandler = async ({ workspacePath }) => { + if (workspacePath !== first) return { archivedThreadIds: [] }; + await client.dispatch({ type: "thread.archive", threadId: freshRecord.threadId }); + return { archivedThreadIds: [freshRecord.threadId] }; + }; + await main(["gc"]); + assert.ok(fs.existsSync(first), "verified merge archival starts the deletion grace period"); + assert.ok(readRecord().idleSince > Date.now() - 5000); + archiveHandler = () => ({ archivedThreadIds: [] }); + age(); + await main(["gc"]); + assert.equal(fs.existsSync(first), false, "merged archived workspace is collected after grace"); + assert.ok(archiveRequests.some(({ workspacePath }) => workspacePath === first)); + assert.ok(archiveRequests.every(({ workspacePath }) => + path.dirname(workspacePath) === path.join(directory, "workspaces") + ), "only registered managed folders are checked"); const secondRecord = JSON.parse( fs.readFileSync( path.join(directory, ".local/state/workspaces/workspaces/second.json"), -- 2.54.1