@akira-tl/forgerelay 0.8.0 → 0.8.1

package/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable ForgeRelay changes are documented here.
 
 ## [Unreleased]
 
+## [0.8.1] - 2026-08-30
+
+### Added
+
+- `close_workspace(action="delete")` explicitly removes ForgeRelay-owned checkout Workspace state without deleting or mutating project files.
+
+### Changed
+
+- Checkout Workspace close is now reversible: it preserves the canonical identity for reopen by path or ID, closed Workspaces remain listable but non-executable, legacy aliases resolve canonically, and idle GC no longer deletes persistent identity.
+
 ## [0.8.0] - 2026-08-30
 
 ### Changed

package/dist/mcp/server-instructions.js

@@ -38,7 +38,7 @@ function capabilityContractInstructions(config) {
     const staleWorkspacePolicy = config.toolMode === "codex"
         ? ""
         : ` If ${toolNames.openWorkspace} reports stale workspaces, let the user choose resume or ${toolNames.closeWorkspace}; never auto-close.`;
-    const workspaceLifecycle = `Use ForgeRelay as a local coding workspace. Default to the user's existing checkout. Reuse workspaceId from ${toolNames.openWorkspace}; change it only when asked.${staleWorkspacePolicy} Only open mode=\"worktree\" when the user explicitly asks for isolated or parallel Git work. ${toolNames.closeWorkspace} releases checkout workspaces or finalizes managed worktrees; managed close requires commitMessage.`;
+    const workspaceLifecycle = `Use ForgeRelay as a local coding workspace. Default to the user's existing checkout. Reuse workspaceId from ${toolNames.openWorkspace}; change it only when asked.${staleWorkspacePolicy} Only open mode=\"worktree\" when the user explicitly asks for isolated or parallel Git work. ${toolNames.closeWorkspace} defaults to closing checkout Workspaces for later reopen; action=delete removes only ForgeRelay-owned checkout state, never project files. Managed close finalizes the worktree and requires commitMessage.`;
     const activityPanel = `Project-work order: ${toolNames.openWorkspace} if needed → activity_panel(workspaceId) once → work tools. activity_panel is the single ForgeRelay UI render tool: Workspace above Activity. A new workspaceId creates a new card. Never call activity_panel before needed ${toolNames.openWorkspace}.`;
     const agents = `Follow instructions returned by ${toolNames.openWorkspace}. Read an availableAgentsFiles path before working under it.`;
     const capabilityGuides = `For optional capabilities from ${toolNames.openWorkspace}, use ${toolNames.capability}; if unfamiliar, describe first and read its advertised capability guide with ${toolNames.read}.`;

package/dist/server.js

@@ -2921,9 +2921,13 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     });
     registerAppTool(server, toolNames.closeWorkspace, {
         title: "Close workspace",
-        description: "Close one Workspace after the user chooses cleanup. In v0.8.0, Composite close still dissolves only the Composite identity/member links. Checkout close removes ForgeRelay state but never project files. Managed-worktree-backed Workspaces run the safe finalize lifecycle (hooks, commit, fast-forward integration, cleanup) and require commitMessage. Running processes block ordinary Workspace closure.",
+        description: "Close or explicitly delete one Workspace after the user chooses cleanup. action=close (default) preserves checkout identity for later reopen. action=delete permanently removes ForgeRelay-owned checkout state but never project files. Managed-worktree-backed Workspaces still use the safe finalize lifecycle and require commitMessage; Composite and relayed delete semantics are not available in this stage.",
         inputSchema: {
-            workspaceId: z.string().describe("Workspace identifier to close."),
+            workspaceId: z.string().describe("Workspace identifier to close or delete."),
+            action: z
+                .enum(["close", "delete"])
+                .optional()
+                .describe("Defaults to close. close preserves checkout identity for later reopen; delete permanently removes ForgeRelay-owned checkout state without deleting project files."),
             commitMessage: z
                 .string()
                 .min(1)
@@ -2932,6 +2936,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         },
         outputSchema: resultOutputSchema({
             workspaceId: z.string(),
+            action: z.enum(["close", "delete"]).optional(),
             kind: z.enum(["workspace", "composite"]).optional(),
             mode: z.enum(["checkout", "worktree"]).optional(),
             name: z.string().optional(),
@@ -2951,8 +2956,11 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         }),
         _meta: {},
         annotations: WRITE_TOOL_ANNOTATIONS,
-    }, async ({ workspaceId, commitMessage }, extra) => {
+    }, async ({ workspaceId, action = "close", commitMessage }, extra) => {
         if (compositeWorkspaces.has(workspaceId)) {
+            if (action === "delete") {
+                throw new Error("close_workspace action=delete is not available for Composite Workspaces until the Composite persistent lifecycle stage.");
+            }
             if (commitMessage !== undefined) {
                 throw new Error("close_workspace commitMessage is not valid when dissolving a Composite Workspace.");
             }
@@ -2972,6 +2980,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     tool: toolNames.closeWorkspace,
                     card: {
                         workspaceId,
+                        action: "close",
                         kind: "composite",
                         name: composite.name,
                         members: composite.members,
@@ -2982,6 +2991,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 structuredContent: {
                     result,
                     workspaceId,
+                    action: "close",
                     kind: "composite",
                     name: composite.name,
                     members: composite.members,
@@ -2990,16 +3000,67 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             };
         }
         if (remoteWorkspaces.has(workspaceId)) {
+            if (action === "delete") {
+                throw new Error("close_workspace action=delete is not available for relayed Workspaces until Workspace Relay lifecycle parity is implemented.");
+            }
             const response = await remoteWorkspaces.closeWorkspace(workspaceId, commitMessage, hostScopeIdFor(extra._meta, extra.sessionId));
             workspacePanelStates.delete(workspaceId);
             return response;
         }
+        if (action === "delete") {
+            if (commitMessage !== undefined) {
+                throw new Error("close_workspace commitMessage is not valid with action=delete for a checkout Workspace.");
+            }
+            const session = workspaces.getWorkspaceSession(workspaceId);
+            if (session.mode !== "checkout") {
+                throw new Error("close_workspace action=delete is not available for managed-worktree-backed Workspaces until their persistent lifecycle stage.");
+            }
+            if (processSessions.activeWorkspaceIds().has(session.id)) {
+                throw new Error(`Workspace ${session.id} still owns a running process. Poll, interrupt, or wait for it before deleting this Workspace.`);
+            }
+            const response = await runToolWithHooks(hooks, {
+                signal: extra.signal,
+                tool: toolNames.closeWorkspace,
+                invocation: {
+                    workspaceId: session.id,
+                    workspaceRoot: session.root,
+                    workspaceMode: session.mode,
+                    sourceRoot: session.sourceRoot,
+                },
+                payload: { workspaceId: session.id, action: "delete", mode: session.mode },
+                operation: async () => {
+                    workspaces.deleteWorkspace(session.id);
+                    await reviewCheckpoints.releaseWorkspace(session.id);
+                    const result = `Deleted ForgeRelay Workspace ${session.id}. Physical project files were not removed.`;
+                    return {
+                        content: [textBlock(result)],
+                        _meta: {
+                            tool: toolNames.closeWorkspace,
+                            card: {
+                                workspaceId: session.id,
+                                action: "delete",
+                                mode: "checkout",
+                                payload: { content: [textBlock(result)] },
+                            },
+                        },
+                        structuredContent: {
+                            result,
+                            workspaceId: session.id,
+                            action: "delete",
+                            mode: "checkout",
+                        },
+                    };
+                },
+            });
+            workspacePanelStates.delete(session.id);
+            return response;
+        }
         const workspace = workspaces.getWorkspace(workspaceId);
         const response = await runToolWithHooks(hooks, {
             signal: extra.signal,
             tool: toolNames.closeWorkspace,
             invocation: workspaceHookInvocation(workspace),
-            payload: { workspaceId, commitMessage, mode: workspace.mode },
+            payload: { workspaceId, action: "close", commitMessage, mode: workspace.mode },
             afterCwd: (response) => "sourceRoot" in response.structuredContent &&
                 typeof response.structuredContent.sourceRoot === "string"
                 ? response.structuredContent.sourceRoot
@@ -3047,6 +3108,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                             tool: toolNames.closeWorkspace,
                             card: {
                                 workspaceId,
+                                action: "close",
                                 mode: "worktree",
                                 sourceRoot: closed.sourceRoot,
                                 branch: closed.branch,
@@ -3061,6 +3123,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         structuredContent: {
                             result,
                             workspaceId,
+                            action: "close",
                             mode: "worktree",
                             sourceRoot: closed.sourceRoot,
                             branch: closed.branch,
@@ -3075,27 +3138,34 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 if (commitMessage !== undefined) {
                     throw new Error("close_workspace commitMessage is only valid for managed-worktree-backed workspaces.");
                 }
-                if (processSessions.activeWorkspaceIds().has(workspaceId)) {
-                    throw new Error(`Workspace ${workspaceId} still owns a running process. Poll, interrupt, or wait for it before closing this workspace.`);
+                const checkoutWorkspaceId = workspace.id;
+                if (processSessions.activeWorkspaceIds().has(checkoutWorkspaceId)) {
+                    throw new Error(`Workspace ${checkoutWorkspaceId} still owns a running process. Poll, interrupt, or wait for it before closing this workspace.`);
                 }
-                workspaces.closeWorkspace(workspaceId);
-                await reviewCheckpoints.releaseWorkspace(workspaceId);
-                const result = `Closed checkout-backed workspace ${workspaceId}. Physical project files were not removed.`;
+                workspaces.closeWorkspace(checkoutWorkspaceId);
+                await reviewCheckpoints.releaseWorkspace(checkoutWorkspaceId);
+                const result = `Closed checkout-backed Workspace ${checkoutWorkspaceId}; its ForgeRelay identity was preserved for later reopen. Physical project files were not removed.`;
                 return {
                     content: [textBlock(result)],
                     _meta: {
                         tool: toolNames.closeWorkspace,
                         card: {
-                            workspaceId,
+                            workspaceId: checkoutWorkspaceId,
+                            action: "close",
                             mode: "checkout",
                             payload: { content: [textBlock(result)] },
                         },
                     },
-                    structuredContent: { result, workspaceId, mode: "checkout" },
+                    structuredContent: {
+                        result,
+                        workspaceId: checkoutWorkspaceId,
+                        action: "close",
+                        mode: "checkout",
+                    },
                 };
             },
         });
-        workspacePanelStates.delete(workspaceId);
+        workspacePanelStates.delete(workspace.id);
         return response;
     });
     registerAppTool(server, toolNames.read, {

package/dist/workspaces.js

@@ -71,6 +71,9 @@ export class WorkspaceRegistry {
                 .filter((binding) => binding.conversationScopeId === openOptions.conversationScopeId)
                 .map((binding) => binding.workspaceSessionId)
             : []);
+        const workspaceIdFilter = input.workspaceId
+            ? this.store?.getSession(input.workspaceId)?.id ?? input.workspaceId
+            : undefined;
         const rootKey = input.root
             ? await canonicalPath(assertAllowedPath(input.root, [...this.config.allowedRoots, this.config.worktreeRoot]))
             : undefined;
@@ -110,7 +113,7 @@ export class WorkspaceRegistry {
             const entry = entries[index];
             if (!session || !entry)
                 continue;
-            if (input.workspaceId && entry.workspaceId !== input.workspaceId)
+            if (workspaceIdFilter && entry.workspaceId !== workspaceIdFilter)
                 continue;
             if (input.status && entry.status !== input.status)
                 continue;
@@ -149,7 +152,7 @@ export class WorkspaceRegistry {
         };
     }
     async resumeWorkspace(workspaceId, conversationScopeId, bootstrapContext = "auto") {
-        const workspace = this.getWorkspace(workspaceId);
+        const workspace = this.workspaceForOpen(workspaceId);
         const context = await this.reusedWorkspaceContext(workspace);
         if (!conversationScopeId || !this.store) {
             return {
@@ -209,22 +212,23 @@ export class WorkspaceRegistry {
         const workspace = this.getWorkspace(workspaceId);
         const canonicalWorkspaceId = workspace.id;
         if (workspace.mode === "worktree") {
-            const aliases = this.activeSessions("worktree")
-                .filter((session) => resolve(session.root) === resolve(workspace.root));
-            if (aliases.length <= 1) {
-                throw new Error(`Workspace ${canonicalWorkspaceId} is backed by a managed worktree. Use close_workspace with its managed-worktree finalize lifecycle instead of releasing the physical target as a separate handle.`);
-            }
+            throw new Error(`Workspace ${canonicalWorkspaceId} is backed by a managed worktree. Use close_workspace with its managed-worktree finalize lifecycle.`);
         }
         if (this.store) {
-            for (const binding of this.store.listConversationBindings()) {
-                if (binding.workspaceSessionId === canonicalWorkspaceId) {
-                    this.store.deleteConversationBinding(binding.conversationScopeId, binding.targetKey);
-                }
-            }
-            this.store.deleteSession(canonicalWorkspaceId);
+            this.deleteConversationBindingsForWorkspace(canonicalWorkspaceId);
+            this.store.setSessionStatus(canonicalWorkspaceId, "closed");
         }
         this.workspaces.delete(canonicalWorkspaceId);
     }
+    deleteWorkspace(workspaceId) {
+        const session = this.getWorkspaceSession(workspaceId);
+        if (session.mode !== "checkout") {
+            throw new Error(`Workspace ${session.id} is not a checkout Workspace. Delete semantics for ${session.mode} Workspaces are handled by their own lifecycle.`);
+        }
+        this.deleteConversationBindingsForWorkspace(session.id);
+        this.store?.deleteSession(session.id);
+        this.workspaces.delete(session.id);
+    }
     workspaceIdsForPhysicalWorkspace(workspace) {
         const root = resolve(workspace.root);
         return this.activeSessions(workspace.mode)
@@ -336,7 +340,7 @@ export class WorkspaceRegistry {
         if (boundContext)
             return boundContext;
         const context = await this.openOnce(targetKey, async () => {
-            const reusableWorkspace = await this.findReusableWorkspaceByDirectory(projectKey, "checkout");
+            const reusableWorkspace = await this.findReusableWorkspaceByDirectory(projectKey, "checkout", true);
             if (!reusableWorkspace)
                 return this.openCheckoutWorkspace(path);
             return this.reusedWorkspaceContext(reusableWorkspace);
@@ -547,13 +551,27 @@ export class WorkspaceRegistry {
             });
         }
     }
-    async findReusableWorkspaceByDirectory(directoryKey, mode) {
-        for (const session of this.activeSessions(mode)) {
+    async findReusableWorkspaceByDirectory(directoryKey, mode, reopenClosedCheckout = false) {
+        const sessions = this.store
+            ? this.store.listSessions({ mode })
+            : this.activeSessions(mode);
+        for (const session of sessions) {
+            const reusable = session.status === "active" ||
+                (reopenClosedCheckout && mode === "checkout" && session.status === "closed");
+            if (!reusable)
+                continue;
             const root = await this.validSessionRoot(session);
             if (!root)
                 continue;
             if (await canonicalPath(root) !== directoryKey)
                 continue;
+            if (session.status === "closed") {
+                this.store?.setSessionStatus(session.id, "active");
+                const reopened = this.store?.getSession(session.id);
+                if (!reopened)
+                    continue;
+                return this.workspaceFromSession(reopened, false);
+            }
             return this.workspaceFromSession(session, false);
         }
         return undefined;
@@ -636,6 +654,50 @@ export class WorkspaceRegistry {
             includeBootstrapContext: true,
         };
     }
+    workspaceForOpen(workspaceId) {
+        const session = this.store?.getSession(workspaceId);
+        if (session?.status === "closed" && session.mode === "checkout") {
+            this.store?.setSessionStatus(session.id, "active");
+            const reopened = this.store?.getSession(session.id);
+            if (!reopened) {
+                throw new Error(`Unknown workspaceId: ${workspaceId}. Call open_workspace first.`);
+            }
+            return this.workspaceFromSession(reopened, true);
+        }
+        return this.getWorkspace(workspaceId);
+    }
+    getWorkspaceSession(workspaceId) {
+        const session = this.store?.getSession(workspaceId);
+        if (session)
+            return session;
+        const workspace = this.workspaces.get(workspaceId);
+        if (!workspace) {
+            throw new Error(`Unknown workspaceId: ${workspaceId}. Call open_workspace first.`);
+        }
+        return {
+            id: workspace.id,
+            root: workspace.root,
+            status: "active",
+            mode: workspace.mode,
+            sourceRoot: workspace.sourceRoot,
+            baseRef: workspace.worktree?.baseRef,
+            baseSha: workspace.worktree?.baseSha,
+            branch: workspace.worktree?.branch,
+            targetBranch: workspace.worktree?.targetBranch,
+            managed: workspace.worktree?.managed ?? false,
+            createdAt: "",
+            lastUsedAt: "",
+        };
+    }
+    deleteConversationBindingsForWorkspace(workspaceId) {
+        if (!this.store)
+            return;
+        for (const binding of this.store.listConversationBindings()) {
+            if (binding.workspaceSessionId === workspaceId) {
+                this.store.deleteConversationBinding(binding.conversationScopeId, binding.targetKey);
+            }
+        }
+    }
     getWorkspace(workspaceId) {
         const workspace = this.workspaces.get(workspaceId);
         if (workspace) {

package/docs/chatgpt-coding-workflow.md

@@ -288,11 +288,15 @@ normal open path may still include `staleWorkspaces` for an idle persistent
 Workspace; use `open_workspace(action="list")` for complete, filtered inventory
 when continuation or cleanup actually requires it.
 
-In v0.8.0, `close_workspace` is still the existing public close operation:
-checkout-backed Workspaces remove their ForgeRelay record without deleting project
-files, while managed-worktree-backed Workspaces require `commitMessage` and run the
-safe commit / fast-forward-only integration / cleanup lifecycle. Persistent
-closed/reopen semantics land in the following lifecycle stage.
+For checkout-backed Workspaces, `close_workspace` defaults to `action="close"` and
+preserves the Workspace identity for later reopen. A closed Workspace stays visible
+through `open_workspace(action="list")`, while ordinary execution tools reject it
+until `open_workspace` reactivates the same ID by path or by `workspaceId`.
+`close_workspace(action="delete")` is the explicit permanent checkout cleanup path:
+it removes ForgeRelay-owned Workspace state but never deletes or mutates project
+files. Managed-worktree close still requires `commitMessage` and runs the safe commit /
+fast-forward-only integration / cleanup lifecycle; managed-worktree, Composite, and
+relayed delete semantics are completed by their later lifecycle stages.
 
 Shell commands are allowed to modify ordinary project files when that is a
 natural part of the user's requested development task; ForgeRelay does not apply

package/docs/configuration.md

@@ -339,15 +339,17 @@ or externally removed managed-worktree root can therefore remain diagnostically
 ordinary same-target opens no longer accumulate duplicate inventory rows;
 `action="list"` remains the formal on-demand inventory path.
 
-In v0.8.0, `close_workspace` still removes a checkout-backed Workspace record without
-deleting checkout files; the persistent closed/reopen lifecycle is introduced by
-the next lifecycle stage. For a managed-worktree-backed Workspace, `close_workspace` requires
-`commitMessage` and runs the existing safe worktree finalize lifecycle: close Hooks,
-commit when needed, fast-forward-only integration, cleanup, and alias invalidation.
-For a Composite Workspace, the same tool means dissolve: it removes only the
-Composite identity, membership, and Composite-facing panel/lifecycle state. It does
-not close members, finalize member worktrees, interrupt member processes, delete
-files, or remove remote registrations and relayed Workspace routes.
+For checkout-backed Workspaces, `close_workspace` now defaults to `action="close"`:
+it marks the persistent Workspace closed, removes current conversation bindings, and
+keeps the same Workspace identity available for later `open_workspace` by path or ID.
+Closed Workspaces remain visible in inventory but ordinary execution tools reject them
+until reopened. `action="delete"` permanently removes ForgeRelay-owned checkout
+identity/state while never deleting or mutating the user's checkout directory.
+Managed-worktree close still requires `commitMessage` and runs the existing safe
+finalize lifecycle; managed-worktree delete semantics land in the next lifecycle
+stage. Composite close still dissolves in this stage, and Composite delete remains
+unavailable until its persistent lifecycle stage. Relayed delete is likewise deferred
+to Workspace Relay lifecycle parity.
 
 Hot workspace/session activity timestamps are coalesced in memory and flushed to the
 SQLite state database in a transaction at most every five minutes; normal shutdown

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akira-tl/forgerelay",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Local development control plane for MCP coding agents.",
   "type": "module",
   "homepage": "https://github.com/Akira-TL/forgerelay#readme",

package/scripts/debug/accept.mjs

@@ -32,6 +32,7 @@ const stateDir = resolve(acceptanceRoot, "state");
 const worktreeRoot = resolve(acceptanceRoot, "worktrees");
 const hookLog = resolve(acceptanceRoot, "hooks.jsonl");
 const checkoutWorkspace = resolve(acceptanceRoot, "workspace");
+const lifecycleDeleteWorkspace = resolve(acceptanceRoot, "delete-workspace");
 const codeIntelligenceLog = resolve(acceptanceRoot, "code-intelligence-lsp.jsonl");
 const fakeLanguageServer = resolve(repoRoot, "src", "lsp", "test-fixtures", "fake-lsp-server.mjs");
 const gitProject = resolve(acceptanceRoot, "git-project");
@@ -45,6 +46,8 @@ await assertDebugPortFree();
 rmSync(acceptanceRoot, { recursive: true, force: true });
 mkdirSync(acceptanceRoot, { recursive: true });
 setupGitProject(checkoutWorkspace);
+setupGitProject(lifecycleDeleteWorkspace);
+writeFileSync(join(lifecycleDeleteWorkspace, "keep.txt"), "keep checkout files\n");
 setupCodeIntelligenceAcceptanceProject({
   root: checkoutWorkspace,
   fakeLanguageServer,
@@ -279,42 +282,52 @@ try {
   assert.equal(capabilityCatalog[0].available, true);
   assert.equal(capabilityCatalog[0].guide.name, "lifecycle-hooks");
 
-  const freshLogical = callTool(oauth.accessToken, sessionId, 84, "open_workspace", {
+  const repeatedOpen = callTool(oauth.accessToken, sessionId, 84, "open_workspace", {
     path: checkoutWorkspace,
     newWorkspace: true,
   }, workspaceConversationMeta);
-  const freshLogicalId = freshLogical.structuredContent.workspaceId;
-  assert.notEqual(freshLogicalId, workspaceId);
-  assert.equal(freshLogical.structuredContent.action, "open");
+  assert.equal(repeatedOpen.structuredContent.workspaceId, workspaceId);
+  assert.equal(repeatedOpen.structuredContent.action, "open");
   assert.equal(
-    freshLogical.structuredContent.contextFingerprint,
+    repeatedOpen.structuredContent.contextFingerprint,
     opened.structuredContent.contextFingerprint,
   );
-  assert.equal(freshLogical.structuredContent.agentsFiles, undefined);
-  assert.equal(freshLogical.structuredContent.capabilityGuides, undefined);
+  assert.equal(repeatedOpen.structuredContent.agentsFiles, undefined);
+  assert.equal(repeatedOpen.structuredContent.capabilityGuides, undefined);
 
   const workspaceInventory = callTool(oauth.accessToken, sessionId, 85, "open_workspace", {
     action: "list",
     root: checkoutWorkspace,
   }, workspaceConversationMeta);
   assert.equal(workspaceInventory.structuredContent.action, "list");
-  assert.equal(workspaceInventory.structuredContent.summary.matching, 2);
+  assert.equal(workspaceInventory.structuredContent.summary.matching, 1);
   const inventoryEntries = workspaceInventory.structuredContent.workspaces;
-  assert.equal(inventoryEntries.length, 2);
-  assert.equal(
-    inventoryEntries.find((entry) => entry.workspaceId === freshLogicalId)?.current,
-    true,
-  );
-  assert.equal(
-    inventoryEntries.find((entry) => entry.workspaceId === workspaceId)?.current,
-    false,
-  );
+  assert.equal(inventoryEntries.length, 1);
+  assert.equal(inventoryEntries[0].workspaceId, workspaceId);
+  assert.equal(inventoryEntries[0].current, true);
+
+  const closedWorkspace = callTool(oauth.accessToken, sessionId, 86, "close_workspace", {
+    workspaceId,
+  });
+  assert.equal(closedWorkspace.isError, undefined);
+  assert.equal(closedWorkspace.structuredContent.workspaceId, workspaceId);
+  assert.equal(closedWorkspace.structuredContent.action, "close");
+
+  const closedInventory = callTool(oauth.accessToken, sessionId, 87, "open_workspace", {
+    action: "list",
+    workspaceId,
+  }, workspaceConversationMeta);
+  assert.equal(closedInventory.structuredContent.workspaces.length, 1);
+  assert.equal(closedInventory.structuredContent.workspaces[0].state, "closed");
+  assert.equal(closedInventory.structuredContent.workspaces[0].current, false);
 
-  const closedFreshLogical = callTool(oauth.accessToken, sessionId, 86, "close_workspace", {
-    workspaceId: freshLogicalId,
+  const closedRead = callTool(oauth.accessToken, sessionId, 89, "read", {
+    workspaceId,
+    path: "AGENTS.md",
   });
-  assert.equal(closedFreshLogical.isError, undefined);
-  const resumedOriginal = callTool(oauth.accessToken, sessionId, 87, "open_workspace", {
+  assert.equal(closedRead.isError, true);
+
+  const resumedOriginal = callTool(oauth.accessToken, sessionId, 90, "open_workspace", {
     workspaceId,
   }, workspaceConversationMeta);
   assert.equal(resumedOriginal.structuredContent.workspaceId, workspaceId);
@@ -323,9 +336,33 @@ try {
     resumedOriginal.structuredContent.contextFingerprint,
     opened.structuredContent.contextFingerprint,
   );
+
+  const deleteOpened = callTool(oauth.accessToken, sessionId, 91, "open_workspace", {
+    path: lifecycleDeleteWorkspace,
+    context: "none",
+  }, { "openai/session": "acceptance-workspace-delete" });
+  const deleteWorkspaceId = deleteOpened.structuredContent.workspaceId;
+  const deleteClosed = callTool(oauth.accessToken, sessionId, 92, "close_workspace", {
+    workspaceId: deleteWorkspaceId,
+  });
+  assert.equal(deleteClosed.structuredContent.action, "close");
+  const deletedWorkspace = callTool(oauth.accessToken, sessionId, 93, "close_workspace", {
+    workspaceId: deleteWorkspaceId,
+    action: "delete",
+  });
+  assert.equal(deletedWorkspace.isError, undefined);
+  assert.equal(deletedWorkspace.structuredContent.workspaceId, deleteWorkspaceId);
+  assert.equal(deletedWorkspace.structuredContent.action, "delete");
+  assert.equal(readFileSync(join(lifecycleDeleteWorkspace, "keep.txt"), "utf8"), "keep checkout files\n");
+  const deletedInventory = callTool(oauth.accessToken, sessionId, 94, "open_workspace", {
+    action: "list",
+    workspaceId: deleteWorkspaceId,
+  });
+  assert.equal(deletedInventory.structuredContent.workspaces.length, 0);
+
   pass(
-    "workspace context + inventory",
-    `${workspaceId} -> ${freshLogicalId} -> list -> close -> resume without bootstrap replay`,
+    "workspace lifecycle + inventory",
+    `${workspaceId} canonical reuse -> close -> list -> reopen; explicit delete preserves checkout files`,
   );
 
   const directCapability = callTool(oauth.accessToken, sessionId, 79, "capability", {
@@ -972,13 +1009,14 @@ function exerciseReleaseTagHooks(accessToken, sessionId) {
 
 function exerciseSubagentHooks(runtimeEnv, debugStateDir, workspaceId, workspaceRoot) {
   const seedScript = [
-    'import { LocalAgentStore } from "./src/local-agent-store.js";',
-    'const store = new LocalAgentStore(process.env.FORGERELAY_STATE_DIR);',
+    'import { SubagentSessionStore } from "./src/subagents/sessions/store.js";',
+    'const store = new SubagentSessionStore(process.env.FORGERELAY_STATE_DIR);',
     'const record = store.create({',
     `  workspaceId: ${JSON.stringify(workspaceId)},`,
     `  workspaceRoot: ${JSON.stringify(workspaceRoot)},`,
     '  profileName: "debug-missing-profile",',
     '  provider: "codex",',
+    '  activeRun: { id: "run_debug_acceptance", startedAt: new Date().toISOString() },',
     '});',
     'store.close();',
     'process.stdout.write(record.id);',
@@ -1006,11 +1044,13 @@ function exerciseSubagentHooks(runtimeEnv, debugStateDir, workspaceId, workspace
   }
 
   const inspectScript = [
-    'import { LocalAgentStore } from "./src/local-agent-store.js";',
-    'const store = new LocalAgentStore(process.env.FORGERELAY_STATE_DIR);',
+    'import { SubagentSessionStore } from "./src/subagents/sessions/store.js";',
+    'import { SubagentDeliveryMailbox } from "./src/subagents/sessions/delivery-mailbox.js";',
+    'const store = new SubagentSessionStore(process.env.FORGERELAY_STATE_DIR);',
     `const record = store.get(${JSON.stringify(agentId)});`,
+    `const deliveries = new SubagentDeliveryMailbox(process.env.FORGERELAY_STATE_DIR).claimSession(${JSON.stringify(workspaceId)}, ${JSON.stringify(agentId)});`,
     'store.close();',
-    'process.stdout.write(JSON.stringify({ status: record?.status, error: record?.error }));',
+    'process.stdout.write(JSON.stringify({ status: record?.status, latestRun: record?.latestRun, delivery: deliveries[0] }));',
   ].join("\n");
   const inspected = spawnSync(process.execPath, ["--import", "tsx", "--input-type=module", "-e", inspectScript], {
     cwd: repoRoot,
@@ -1021,9 +1061,11 @@ function exerciseSubagentHooks(runtimeEnv, debugStateDir, workspaceId, workspace
     throw new Error(`unable to inspect debug subagent: ${inspected.stderr.trim()}`);
   }
   const record = JSON.parse(inspected.stdout);
-  assert.equal(record.status, "error");
-  assert.match(record.error, /Subagent profile not found/);
-  pass("subagent hook path", `${agentId} stopped in deterministic error path without calling a provider`);
+  assert.equal(record.status, "idle");
+  assert.equal(record.latestRun?.status, "failed");
+  assert.equal(record.delivery?.outcome, "failed");
+  assert.match(record.delivery?.error ?? "", /Subagent profile not found/);
+  pass("subagent hook path", `${agentId} stopped in deterministic failed Run without calling a provider`);
 }
 
 function toolText(result) {