@akira-tl/forgerelay 0.7.4 → 0.8.1

package/CHANGELOG.md

@@ -4,6 +4,27 @@ 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
+
+- Workspace identity is now canonical per physical checkout or managed worktree, so different Host conversations reuse one persistent `workspaceId`; legacy duplicate IDs remain compatible aliases, and `newWorkspace` no longer creates same-target duplicates.
+
+### Fixed
+
+- Composite member bootstrap now preserves capability guides and subagent provider/profile context exposed by the underlying Workspace.
+- Composite member `context="none"` now truthfully reports suppressed bootstrap instead of claiming it was already delivered.
+
 ## [0.7.4] - 2026-08-30
 
 ### Added

package/dist/db/migrations.js

@@ -74,6 +74,11 @@ const migrations = [
         name: "subagent-run-ownership",
         up: migrateSubagentRunOwnership,
     },
+    {
+        version: 16,
+        name: "workspace-session-aliases",
+        up: migrateWorkspaceSessionAliases,
+    },
 ];
 export function migrateDatabase(sqlite) {
     const migrate = sqlite.transaction(() => {
@@ -368,6 +373,20 @@ function migrateSubagentRunOwnership(sqlite) {
     addColumnIfMissing(sqlite, "local_agent_sessions", "active_owner_id", "text");
     addColumnIfMissing(sqlite, "local_agent_sessions", "active_owner_pid", "integer");
 }
+function migrateWorkspaceSessionAliases(sqlite) {
+    sqlite.exec(`
+    create table if not exists workspace_session_aliases (
+      alias_id text primary key,
+      workspace_session_id text not null,
+      foreign key (workspace_session_id)
+        references workspace_sessions(id)
+        on delete cascade
+    );
+
+    create index if not exists workspace_session_aliases_workspace_idx
+      on workspace_session_aliases(workspace_session_id);
+  `);
+}
 function migrateActivityHostTurnWorkspace(sqlite) {
     migrateActivityHostTurns(sqlite);
     addColumnIfMissing(sqlite, "activity_host_turns", "workspace_id", "text");

package/dist/db/schema.js

@@ -16,6 +16,14 @@ export const workspaceSessions = sqliteTable("workspace_sessions", {
     index("workspace_sessions_root_idx").on(table.root, table.lastUsedAt),
     index("workspace_sessions_status_idx").on(table.status, table.lastUsedAt),
 ]);
+export const workspaceSessionAliases = sqliteTable("workspace_session_aliases", {
+    aliasId: text("alias_id").primaryKey(),
+    workspaceSessionId: text("workspace_session_id")
+        .notNull()
+        .references(() => workspaceSessions.id, { onDelete: "cascade" }),
+}, (table) => [
+    index("workspace_session_aliases_workspace_idx").on(table.workspaceSessionId),
+]);
 export const loadedAgentFiles = sqliteTable("loaded_agent_files", {
     workspaceSessionId: text("workspace_session_id")
         .notNull()

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

@@ -1362,6 +1362,22 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         const skills = workspace.skills
             .filter((skill) => !skill.disableModelInvocation)
             .map((skill) => ({ name: skill.name, description: skill.description }));
+        const capabilityGuides = workspace.capabilityGuides.map((guide) => ({
+            name: guide.name,
+            description: guide.description,
+            whenToRead: guide.whenToRead,
+            path: formatPathForPrompt(guide.filePath),
+        }));
+        const agentProviders = config.subagents ? subagentProviders : [];
+        const agents = workspace.agentProfiles.map((profile) => {
+            const summary = summarizeSubagentProfile(profile);
+            const availability = agentProviders.find((provider) => provider.name === summary.provider);
+            return {
+                ...summary,
+                providerAvailable: availability?.available,
+                providerUnavailableReason: availability?.reason,
+            };
+        });
         return {
             member: memberName,
             workspaceId: compositeWorkspaceId,
@@ -1373,15 +1389,20 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             includeBootstrapContext: opened.includeBootstrapContext,
             ...(opened.includeBootstrapContext
                 ? {
+                    capabilityGuides,
                     agentsFiles,
                     availableAgentsFiles,
                     skills,
+                    agentProviders,
+                    agents,
                     skillDiagnostics: redactSkillDiagnosticPaths(workspace.skillDiagnostics),
                 }
                 : {}),
             instruction: opened.includeBootstrapContext
                 ? `Bootstrap context for Composite member ${memberName}. Keep using Composite workspaceId ${compositeWorkspaceId} and pass member=${memberName} for work operations.`
-                : `Composite member ${memberName} context was already delivered for this Host context; keep using Composite workspaceId ${compositeWorkspaceId} with member=${memberName}.`,
+                : contextPolicy === "none"
+                    ? `Bootstrap context for Composite member ${memberName} was intentionally suppressed by context=none. Keep using Composite workspaceId ${compositeWorkspaceId} with member=${memberName}; request context=auto or context=full when member bootstrap is needed.`
+                    : `Composite member ${memberName} context was already delivered for this Host context; keep using Composite workspaceId ${compositeWorkspaceId} with member=${memberName}.`,
         };
     };
     const coreOperations = createCoreOperationExecutor({
@@ -1960,7 +1981,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             action: z
                 .enum(["open", "list", "member"])
                 .optional()
-                .describe("Defaults to open. Use list to inspect logical workspaces. Use member to add/remove a named execution member on an existing Composite Workspace."),
+                .describe("Defaults to open. Use list to inspect known Workspaces. Use member to add/remove a named execution member on an existing Composite Workspace."),
             memberAction: z
                 .enum(["add", "update", "remove"])
                 .optional()
@@ -2000,7 +2021,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             workspaceId: z
                 .string()
                 .optional()
-                .describe("For action=open, an existing logical workspace ID to resume in this conversation. For action=list, filters inventory to one workspace ID."),
+                .describe("For action=open, an existing Workspace ID to resume or reuse. Historical duplicate IDs from earlier ForgeRelay versions may resolve to the canonical Workspace ID. For action=list, filters inventory to one Workspace ID."),
             mode: z
                 .enum(["checkout", "worktree"])
                 .optional()
@@ -2016,7 +2037,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             newWorkspace: z
                 .boolean()
                 .optional()
-                .describe("When true, allocate a fresh logical workspaceId for the same physical checkout or worktree and bind this conversation to it. Use only after the user explicitly requests a new logical workspace."),
+                .describe("Deprecated compatibility flag. It no longer creates another Workspace identity for the same physical checkout or managed worktree; ForgeRelay reuses that target's canonical Workspace. Use newWorktree=true when the user explicitly needs separate Git isolation."),
             context: z
                 .enum(["auto", "full", "none"])
                 .optional()
@@ -2036,7 +2057,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             staleOnly: z
                 .boolean()
                 .optional()
-                .describe("For action=list, return only active logical workspaces idle for more than two days."),
+                .describe("For action=list, return only active Workspaces idle for more than two days."),
             offset: z
                 .number()
                 .int()
@@ -2570,7 +2591,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         const loadedAgentsFiles = includeBootstrapContext ? cardAgentsFiles : [];
         const availableAgentsFileOutputs = includeBootstrapContext ? cardAvailableAgentsFiles : [];
         const workspaceContextInstruction = "For later open_workspace calls, context=\"auto\" avoids repeating unchanged bootstrap context; use context=\"none\" when only the workspace handle/metadata is needed, or context=\"full\" to force a refresh.";
-        const workspaceManagementInstruction = "When you need to continue an earlier logical workspace or organize workspace state, use open_workspace(action=\"list\") to inspect candidates, then resume a selected workspaceId or ask the user before close_workspace cleanup.";
+        const workspaceManagementInstruction = "When you need to inspect known Workspaces, continue earlier work, or organize Workspace state, use open_workspace(action=\"list\") to inspect candidates, then resume a selected workspaceId or ask the user before close_workspace cleanup.";
         const cardInstruction = config.skillsEnabled
             ? `Use this workspaceId in all subsequent tool calls for this project. Follow loaded agentsFiles instructions. Read an availableAgentsFiles path before working under it. When a task matches an available skill, load it with read(path=\"skills://<name>\") before proceeding. When a task matches a capability guide, read its advertised path before proceeding. ${workspaceContextInstruction} ${workspaceManagementInstruction}`
             : `Use this workspaceId in all subsequent tool calls for this project. Follow loaded agentsFiles instructions. Read an availableAgentsFiles path before working under it. When a task matches a capability guide, read its advertised path before proceeding. ${workspaceContextInstruction} ${workspaceManagementInstruction}`;
@@ -2632,7 +2653,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         ? `Known worktrees: ${knownWorktrees.map((worktree) => `${worktree.path} [${worktree.workspaceId}]${worktree.branch ? ` branch=${worktree.branch}` : ""}${worktree.targetBranch ? ` target=${worktree.targetBranch}` : ""}${worktree.current ? " (current)" : ""}`).join(", ")}`
                         : undefined,
                     staleWorkspaces.length > 0
-                        ? `Idle logical workspaces for this same physical workspace (>2 days): ${staleWorkspaces.map((stale) => `${stale.workspaceId} last-used=${stale.lastUsedAt}`).join(", ")}. Tell the user these are available to resume or explicitly close; do not clean them up automatically.`
+                        ? `This Workspace has been idle for more than 2 days: ${staleWorkspaces.map((stale) => `${stale.workspaceId} last-used=${stale.lastUsedAt}`).join(", ")}. It remains available to resume or explicitly close; do not clean it up automatically.`
                         : undefined,
                     `ForgeRelay ${capabilityFingerprint.version} capabilities: ${capabilityFingerprint.capabilities.join(", ")}`,
                     instruction,
@@ -2900,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. Composite Workspaces dissolve here: only the Composite identity and member links are removed; member Workspaces, files, processes, worktrees, and relay routes remain intact. Checkout-backed workspaces release only the logical handle. 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)
@@ -2911,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(),
@@ -2930,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.");
             }
@@ -2951,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,
@@ -2961,6 +2991,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 structuredContent: {
                     result,
                     workspaceId,
+                    action: "close",
                     kind: "composite",
                     name: composite.name,
                     members: composite.members,
@@ -2969,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
@@ -2992,7 +3074,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     const busyWorkspaceIds = physicalWorkspaceIds
                         .filter((id) => processSessions.activeWorkspaceIds().has(id));
                     if (busyWorkspaceIds.length > 0) {
-                        throw new Error(`Cannot close this worktree-backed workspace while logical workspace processes are still running: ${busyWorkspaceIds.join(", ")}.`);
+                        throw new Error(`Cannot close this worktree-backed Workspace while Workspace processes are still running: ${busyWorkspaceIds.join(", ")}.`);
                     }
                     const startedAt = performance.now();
                     const retirement = await codeIntelligence.retireWorkspaceRoot(workspace.root);
@@ -3026,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,
@@ -3040,6 +3123,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         structuredContent: {
                             result,
                             workspaceId,
+                            action: "close",
                             mode: "worktree",
                             sourceRoot: closed.sourceRoot,
                             branch: closed.branch,
@@ -3054,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/workspace-store.js

@@ -1,6 +1,6 @@
 import { and, desc, eq } from "drizzle-orm";
 import { openDatabase } from "./db/client.js";
-import { workspaceContextDeliveries, workspaceConversationBindings, workspaceSessions, } from "./db/schema.js";
+import { workspaceContextDeliveries, workspaceConversationBindings, workspaceSessionAliases, workspaceSessions, } from "./db/schema.js";
 const DEFAULT_TOUCH_FLUSH_INTERVAL_MS = 5 * 60 * 1_000;
 export class SqliteWorkspaceStore {
     database;
@@ -61,24 +61,33 @@ export class SqliteWorkspaceStore {
         return session;
     }
     getSession(id) {
+        const sessionId = this.resolveSessionId(id);
+        if (!sessionId)
+            return undefined;
         const row = this.database.db
             .select()
             .from(workspaceSessions)
-            .where(eq(workspaceSessions.id, id))
+            .where(eq(workspaceSessions.id, sessionId))
             .get();
         if (!row)
             return undefined;
-        return applySessionTouch(rowToWorkspaceSession(row), this.pendingSessionTouches.get(id));
+        return applySessionTouch(rowToWorkspaceSession(row), this.pendingSessionTouches.get(sessionId));
     }
     touchSession(id) {
-        this.pendingSessionTouches.set(id, this.now().toISOString());
+        const sessionId = this.resolveSessionId(id);
+        if (!sessionId)
+            return;
+        this.pendingSessionTouches.set(sessionId, this.now().toISOString());
     }
     setSessionStatus(id, status) {
-        this.pendingSessionTouches.delete(id);
+        const sessionId = this.resolveSessionId(id);
+        if (!sessionId)
+            return;
+        this.pendingSessionTouches.delete(sessionId);
         this.database.db
             .update(workspaceSessions)
             .set({ status, lastUsedAt: this.now().toISOString() })
-            .where(eq(workspaceSessions.id, id))
+            .where(eq(workspaceSessions.id, sessionId))
             .run();
     }
     listSessions(input = {}) {
@@ -100,11 +109,56 @@ export class SqliteWorkspaceStore {
             .map((session) => applySessionTouch(session, this.pendingSessionTouches.get(session.id)))
             .sort((left, right) => right.lastUsedAt.localeCompare(left.lastUsedAt));
     }
+    foldSessions(input) {
+        const aliases = input.aliasIds.filter((id) => id !== input.canonicalId);
+        if (aliases.length === 0)
+            return;
+        const fold = this.database.sqlite.transaction(() => {
+            this.database.sqlite.prepare(`
+        update workspace_sessions
+           set created_at = ?, last_used_at = ?, status = ?
+         where id = ?
+      `).run(input.createdAt, input.lastUsedAt, input.status, input.canonicalId);
+            const rebindConversation = this.database.sqlite.prepare(`
+        update workspace_conversation_bindings
+           set workspace_session_id = ?
+         where workspace_session_id = ?
+      `);
+            const rebindSubagents = this.database.sqlite.prepare(`
+        update local_agent_sessions
+           set workspace_id = ?
+         where workspace_id = ?
+      `);
+            const rebindAliases = this.database.sqlite.prepare(`
+        update workspace_session_aliases
+           set workspace_session_id = ?
+         where workspace_session_id = ?
+      `);
+            const deleteSession = this.database.sqlite.prepare("delete from workspace_sessions where id = ?");
+            const rememberAlias = this.database.sqlite.prepare(`
+        insert into workspace_session_aliases (alias_id, workspace_session_id)
+        values (?, ?)
+        on conflict(alias_id) do update set workspace_session_id = excluded.workspace_session_id
+      `);
+            for (const aliasId of aliases) {
+                rebindConversation.run(input.canonicalId, aliasId);
+                rebindSubagents.run(input.canonicalId, aliasId);
+                rebindAliases.run(input.canonicalId, aliasId);
+                deleteSession.run(aliasId);
+                rememberAlias.run(aliasId, input.canonicalId);
+                this.pendingSessionTouches.delete(aliasId);
+            }
+        });
+        fold.immediate();
+    }
     deleteSession(id) {
-        this.pendingSessionTouches.delete(id);
+        const sessionId = this.resolveSessionId(id);
+        if (!sessionId)
+            return;
+        this.pendingSessionTouches.delete(sessionId);
         this.database.db
             .delete(workspaceSessions)
-            .where(eq(workspaceSessions.id, id))
+            .where(eq(workspaceSessions.id, sessionId))
             .run();
     }
     listConversationBindings() {
@@ -212,6 +266,21 @@ export class SqliteWorkspaceStore {
             .where(and(eq(workspaceContextDeliveries.conversationScopeId, conversationScopeId), eq(workspaceContextDeliveries.targetKey, targetKey)))
             .run();
     }
+    resolveSessionId(id) {
+        const direct = this.database.db
+            .select({ id: workspaceSessions.id })
+            .from(workspaceSessions)
+            .where(eq(workspaceSessions.id, id))
+            .get();
+        if (direct)
+            return direct.id;
+        return this.database.db
+            .select({ workspaceSessionId: workspaceSessionAliases.workspaceSessionId })
+            .from(workspaceSessionAliases)
+            .where(eq(workspaceSessionAliases.aliasId, id))
+            .get()
+            ?.workspaceSessionId;
+    }
     get pendingTouchCount() {
         return this.pendingSessionTouches.size + this.pendingConversationTouches.size;
     }