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