@ccpocket/bridge 1.80.1 → 1.81.0

package/dist/websocket.js

@@ -7,7 +7,7 @@ import { promisify } from "node:util";
 import { WebSocketServer, WebSocket } from "ws";
 import { SessionManager, MAX_HISTORY_PER_SESSION, } from "./session.js";
 import { SdkProcess, listAvailableClaudeModels, } from "./sdk-process.js";
-import { codexErrorMessage, CodexRpcError, CodexProcess, } from "./codex-process.js";
+import { codexErrorMessage, isCodexThreadWriterConflict, CodexRpcError, CodexProcess, } from "./codex-process.js";
 import { stopManagedCodexAppServers } from "./codex-transport.js";
 import { parseClientMessage, } from "./parser.js";
 import { BRIDGE_PROTOCOL_MAX_VERSION, BRIDGE_PROTOCOL_MIN_VERSION, clientProtocolRange, negotiateProtocolVersion, } from "./protocol-version.js";
@@ -104,6 +104,7 @@ const OPT_IN_SERVER_MESSAGES = new Set([
     "goal_state",
     "guardian_approval",
     "prompt_history_status",
+    "projects",
     "push_registration_result",
 ]);
 function isRecord(value) {
@@ -517,6 +518,8 @@ export class BridgeWebSocketServer {
     uploadStore;
     galleryStore;
     projectHistory;
+    workspaceStore;
+    pendingSessionWorkspaces = new Map();
     debugTraceStore;
     recordingStore;
     worktreeStore;
@@ -570,7 +573,7 @@ export class BridgeWebSocketServer {
     pendingClaudeResumeInputs = new WeakMap();
     resumeOperations = new Map();
     constructor(options) {
-        const { server, apiKey, allowedDirs, imageStore, mediaStore, uploadStore, galleryStore, projectHistory, debugTraceStore, recordingStore, firebaseAuth, promptHistoryBackup, promptHistoryStore, platform, fileListMaxEntries, fileListMaxBytes, fileDownloadMaxBytes, fileUploadMaxBytes, deltaBatchMs, deltaBatchMaxChars, } = options;
+        const { server, apiKey, allowedDirs, imageStore, mediaStore, uploadStore, galleryStore, projectHistory, workspaceStore, debugTraceStore, recordingStore, firebaseAuth, promptHistoryBackup, promptHistoryStore, platform, fileListMaxEntries, fileListMaxBytes, fileDownloadMaxBytes, fileUploadMaxBytes, deltaBatchMs, deltaBatchMaxChars, } = options;
         this.apiKey = apiKey ?? null;
         this.allowedDirs = allowedDirs ?? [];
         this.imageStore = imageStore ?? null;
@@ -578,6 +581,7 @@ export class BridgeWebSocketServer {
         this.uploadStore = uploadStore ?? null;
         this.galleryStore = galleryStore ?? null;
         this.projectHistory = projectHistory ?? null;
+        this.workspaceStore = workspaceStore ?? null;
         this.debugTraceStore = debugTraceStore ?? new DebugTraceStore();
         this.recordingStore = recordingStore ?? null;
         this.worktreeStore = new WorktreeStore();
@@ -619,7 +623,10 @@ export class BridgeWebSocketServer {
                 const info = this.galleryStore.metaToInfo(meta);
                 this.broadcast({ type: "gallery_new_image", image: info });
             }
-        }, this.worktreeStore, () => this.broadcastSessionList());
+        }, this.worktreeStore, (sessionId) => {
+            void this.persistPendingSessionWorkspace(sessionId);
+            this.broadcastSessionList();
+        });
         this.wss.on("connection", (ws, req) => {
             // API key authentication
             if (this.apiKey) {
@@ -1069,6 +1076,7 @@ export class BridgeWebSocketServer {
         }
         const projectPath = session.projectPath;
         const codexSettings = session.codexSettings;
+        const workspace = this.workspaceForRuntimeSession(session);
         const worktreeOpts = session.worktreePath
             ? {
                 existingWorktreePath: session.worktreePath,
@@ -1086,6 +1094,7 @@ export class BridgeWebSocketServer {
             ...(codexSettings ?? {}),
             threadId,
         }));
+        this.attachWorkspaceToRuntimeSession(newSessionId, workspace);
         const newSession = this.sessionManager.get(newSessionId);
         this.send(ws, {
             type: "rewind_result",
@@ -1152,6 +1161,7 @@ export class BridgeWebSocketServer {
         }
         const projectPath = session.projectPath;
         const codexSettings = session.codexSettings;
+        const workspace = this.workspaceForRuntimeSession(session);
         const worktreeOpts = session.worktreePath
             ? {
                 existingWorktreePath: session.worktreePath,
@@ -1174,6 +1184,7 @@ export class BridgeWebSocketServer {
             ...(codexSettings ?? {}),
             threadId: forkedThreadId,
         }));
+        this.attachWorkspaceToRuntimeSession(newSessionId, workspace);
         const newSession = this.sessionManager.get(newSessionId);
         this.send(ws, this.buildSessionCreatedMessage({
             sessionId: newSessionId,
@@ -1852,7 +1863,7 @@ export class BridgeWebSocketServer {
         // Send session list and project history on connect
         this.refreshConnectionMetadata();
         this.sendSessionList(ws);
-        const projects = this.projectHistory?.getProjects() ?? [];
+        const projects = this.legacyProjectHistoryProjects();
         this.send(ws, { type: "project_history", projects });
         ws.on("message", (data) => {
             if (this.rejectedProtocolClients.has(ws))
@@ -1954,7 +1965,32 @@ export class BridgeWebSocketServer {
         }
         switch (msg.type) {
             case "start": {
-                const projectPath = resolvePlatformPath(msg.projectPath, this.platform);
+                let projectPath = resolvePlatformPath(msg.projectPath, this.platform);
+                let resolvedWorkspace;
+                if (msg.projectId) {
+                    const project = this.workspaceStore?.getProject(msg.projectId);
+                    if (!project) {
+                        this.send(ws, {
+                            type: "error",
+                            requestId: msg.requestId,
+                            errorCode: "project_not_found",
+                            message: `Project not found: ${msg.projectId}`,
+                        });
+                        break;
+                    }
+                    const normalized = this.normalizeWorkspaceRoots(project.rootPaths);
+                    if (normalized.deniedRoot || !normalized.roots) {
+                        this.send(ws, this.buildPathNotAllowedError(normalized.deniedRoot ?? project.rootPaths[0]));
+                        break;
+                    }
+                    projectPath = normalized.roots[0];
+                    resolvedWorkspace = {
+                        kind: "project",
+                        projectId: project.id,
+                        projectName: project.name,
+                        rootPaths: normalized.roots,
+                    };
+                }
                 if (!this.isPathAllowed(projectPath)) {
                     this.send(ws, {
                         ...this.buildPathNotAllowedError(msg.projectPath),
@@ -2012,9 +2048,9 @@ export class BridgeWebSocketServer {
                             break;
                         }
                     }
-                    const additionalWritableRoots = provider === "codex"
-                        ? this.normalizeAdditionalWritableRoots(msg.additionalWritableRoots, projectPath)
-                        : {};
+                    const requestedAdditionalRoots = resolvedWorkspace?.rootPaths.slice(1) ??
+                        msg.additionalWritableRoots;
+                    const additionalWritableRoots = this.normalizeAdditionalWritableRoots(requestedAdditionalRoots, projectPath);
                     if (additionalWritableRoots.deniedRoot) {
                         this.send(ws, {
                             ...this.buildPathNotAllowedError(additionalWritableRoots.deniedRoot),
@@ -2041,6 +2077,7 @@ export class BridgeWebSocketServer {
                                 ...(msg.sandboxMode
                                     ? { sandboxEnabled: msg.sandboxMode === "on" }
                                     : {}),
+                                additionalDirectories: additionalWritableRoots.roots,
                             },
                             worktreeOptions: {
                                 useWorktree: msg.useWorktree,
@@ -2086,6 +2123,10 @@ export class BridgeWebSocketServer {
                             usedFallback: false,
                         };
                     const createdSession = this.sessionManager.get(sessionId);
+                    if (resolvedWorkspace) {
+                        this.pendingSessionWorkspaces.set(sessionId, resolvedWorkspace);
+                        void this.persistPendingSessionWorkspace(sessionId);
+                    }
                     const cached = this.sessionManager.getCachedCommands(provider, createdSession?.worktreePath ?? projectPath);
                     // Load saved session name from CLI storage (for resumed sessions)
                     void this.loadAndSetSessionName(createdSession, provider, projectPath, msg.sessionId).then(() => {
@@ -2152,7 +2193,9 @@ export class BridgeWebSocketServer {
                         projectPath,
                         createdAt: new Date().toISOString(),
                     });
-                    this.projectHistory?.addProject(projectPath);
+                    if (!resolvedWorkspace) {
+                        this.projectHistory?.addProject(projectPath);
+                    }
                 }
                 catch (err) {
                     console.error(`[ws] Failed to start session:`, err);
@@ -2805,6 +2848,7 @@ export class BridgeWebSocketServer {
                     const worktreePath = session.worktreePath;
                     const worktreeBranch = session.worktreeBranch;
                     const sessionName = session.name;
+                    const workspace = this.workspaceForRuntimeSession(session);
                     this.destroySession(oldSessionId);
                     console.log(`[ws] Permission mode change: destroyed session ${oldSessionId}`);
                     const hasUserMessages = session.history?.some((m) => m.type === "user_input" || m.type === "assistant") ||
@@ -2822,8 +2866,10 @@ export class BridgeWebSocketServer {
                             serviceTier: oldSettings.serviceTier,
                             networkAccessEnabled: oldSettings.networkAccessEnabled,
                             webSearchMode: oldSettings.webSearchMode,
+                            additionalWritableRoots: oldSettings.additionalWritableRoots,
                             collaborationMode: newCollaboration,
                         }));
+                        this.attachWorkspaceToRuntimeSession(newId, workspace);
                         const newSession = this.sessionManager.get(newId);
                         if (newSession && sessionName)
                             newSession.name = sessionName;
@@ -2883,8 +2929,10 @@ export class BridgeWebSocketServer {
                             serviceTier: oldSettings.serviceTier,
                             networkAccessEnabled: oldSettings.networkAccessEnabled,
                             webSearchMode: oldSettings.webSearchMode,
+                            additionalWritableRoots: oldSettings.additionalWritableRoots,
                             collaborationMode: newCollaboration,
                         }));
+                        this.attachWorkspaceToRuntimeSession(newId, workspace);
                         const newSession = this.sessionManager.get(newId);
                         if (newSession && sessionName) {
                             newSession.name = sessionName;
@@ -3174,6 +3222,7 @@ export class BridgeWebSocketServer {
                     const sessionName = session.name;
                     const permissionMode = session.process.permissionMode;
                     const model = session.process.model;
+                    const workspace = this.workspaceForRuntimeSession(session);
                     this.destroySession(oldSessionId);
                     console.log(`[ws] Claude sandbox change: destroyed session ${oldSessionId}`);
                     const newId = this.sessionManager.create(projectPath, {
@@ -3181,9 +3230,11 @@ export class BridgeWebSocketServer {
                         permissionMode,
                         model,
                         sandboxEnabled: newEnabled,
+                        additionalDirectories: workspace?.rootPaths.slice(1),
                     }, undefined, worktreePath
                         ? { existingWorktreePath: worktreePath, worktreeBranch }
                         : undefined, "claude");
+                    this.attachWorkspaceToRuntimeSession(newId, workspace);
                     const newSession = this.sessionManager.get(newId);
                     if (newSession && sessionName)
                         newSession.name = sessionName;
@@ -3227,6 +3278,7 @@ export class BridgeWebSocketServer {
                 const sessionName = session.name;
                 const collaborationMode = session.process
                     .collaborationMode;
+                const workspace = this.workspaceForRuntimeSession(session);
                 const executionMode = oldSettings.approvalPolicy === "never" ? "fullAccess" : "default";
                 const planMode = collaborationMode === "plan";
                 const legacyPermissionMode = modesToLegacyPermissionMode("codex", executionMode, planMode);
@@ -3255,8 +3307,10 @@ export class BridgeWebSocketServer {
                         serviceTier: oldSettings.serviceTier,
                         networkAccessEnabled: oldSettings.networkAccessEnabled,
                         webSearchMode: oldSettings.webSearchMode,
+                        additionalWritableRoots: oldSettings.additionalWritableRoots,
                         collaborationMode,
                     }));
+                    this.attachWorkspaceToRuntimeSession(newId, workspace);
                     const newSession = this.sessionManager.get(newId);
                     if (newSession && sessionName)
                         newSession.name = sessionName;
@@ -3309,8 +3363,10 @@ export class BridgeWebSocketServer {
                         serviceTier: oldSettings.serviceTier,
                         networkAccessEnabled: oldSettings.networkAccessEnabled,
                         webSearchMode: oldSettings.webSearchMode,
+                        additionalWritableRoots: oldSettings.additionalWritableRoots,
                         collaborationMode,
                     }));
+                    this.attachWorkspaceToRuntimeSession(newId, workspace);
                     // Restore session name
                     const newSession = this.sessionManager.get(newId);
                     if (newSession && sessionName) {
@@ -3377,6 +3433,7 @@ export class BridgeWebSocketServer {
                     const permissionMode = sdkProc.permissionMode;
                     const worktreePath = session.worktreePath;
                     const worktreeBranch = session.worktreeBranch;
+                    const workspace = this.workspaceForRuntimeSession(session);
                     this.destroySession(sessionId);
                     console.log(`[ws] Clear context: destroyed session ${sessionId}`);
                     const newId = this.sessionManager.create(projectPath, {
@@ -3388,9 +3445,11 @@ export class BridgeWebSocketServer {
                             : {}),
                         permissionMode,
                         initialInput: planText || undefined,
+                        additionalDirectories: workspace?.rootPaths.slice(1),
                     }, undefined, worktreePath
                         ? { existingWorktreePath: worktreePath, worktreeBranch }
                         : undefined);
+                    this.attachWorkspaceToRuntimeSession(newId, workspace);
                     console.log(`[ws] Clear context: created new session ${newId} (CLI session: ${claudeSessionId ?? "new"})`);
                     // Notify all clients. Broadcast is used so reconnecting clients also receive it.
                     const newSession = this.sessionManager.get(newId);
@@ -3576,7 +3635,7 @@ export class BridgeWebSocketServer {
                     this.send(ws, {
                         type: "session_context",
                         sessionId: msg.sessionId,
-                        context: { ...context },
+                        context: { ...this.runtimeSessionWithWorkspace(context) },
                     });
                 }
                 else {
@@ -3830,6 +3889,8 @@ export class BridgeWebSocketServer {
                         limit: msg.limit,
                         offset: msg.offset,
                         projectPath: msg.projectPath,
+                        projectId: msg.projectId,
+                        workspaceKind: msg.workspaceKind,
                         requestScope: msg.requestScope,
                         requestId: msg.requestId,
                     });
@@ -3844,6 +3905,8 @@ export class BridgeWebSocketServer {
                         message: `Failed to list recent sessions: ${err}`,
                         errorCode: "recent_sessions_failed",
                         path: msg.projectPath,
+                        projectId: msg.projectId,
+                        workspaceKind: msg.workspaceKind,
                         requestId: msg.requestId,
                         requestScope: msg.requestScope,
                         offset: msg.offset,
@@ -3904,9 +3967,41 @@ export class BridgeWebSocketServer {
             }
             case "resume_session": {
                 const resumeStartedAt = Date.now();
-                console.log(`[ws] resume_session: sessionId=${msg.sessionId} projectPath=${msg.projectPath} provider=${msg.provider ?? "claude"}`);
-                const resumeProjectPath = resolvePlatformPath(msg.projectPath, this.platform);
                 const provider = msg.provider ?? "claude";
+                const storedAssignment = this.workspaceStore?.getAssignment(provider, msg.sessionId);
+                const requestedProject = !storedAssignment && msg.projectId
+                    ? this.workspaceStore?.getProject(msg.projectId)
+                    : undefined;
+                const assignedProject = storedAssignment?.projectId
+                    ? this.workspaceStore?.getProject(storedAssignment.projectId)
+                    : undefined;
+                const resumeRoots = storedAssignment?.rootPaths ?? requestedProject?.rootPaths;
+                console.log(`[ws] resume_session: sessionId=${msg.sessionId} projectPath=${msg.projectPath} provider=${msg.provider ?? "claude"}`);
+                // A stored assignment supplies the root snapshot and secondary roots,
+                // while the recent-session path may be a worktree cwd that must win.
+                const resumeProjectPath = resolvePlatformPath(storedAssignment
+                    ? msg.projectPath
+                    : (resumeRoots?.[0] ?? msg.projectPath), this.platform);
+                const resumeAdditionalRoots = resumeRoots?.slice(1) ?? msg.additionalWritableRoots;
+                const resolvedResumeWorkspace = storedAssignment
+                    ? {
+                        kind: storedAssignment.kind,
+                        ...(storedAssignment.projectId
+                            ? { projectId: storedAssignment.projectId }
+                            : {}),
+                        ...(assignedProject
+                            ? { projectName: assignedProject.name }
+                            : {}),
+                        rootPaths: storedAssignment.rootPaths,
+                    }
+                    : requestedProject
+                        ? {
+                            kind: "project",
+                            projectId: requestedProject.id,
+                            projectName: requestedProject.name,
+                            rootPaths: requestedProject.rootPaths,
+                        }
+                        : undefined;
                 if (!this.isPathAllowed(resumeProjectPath)) {
                     this.sendResumeFailed(ws, {
                         provider,
@@ -3917,6 +4012,13 @@ export class BridgeWebSocketServer {
                     this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
                     break;
                 }
+                if (resolvedResumeWorkspace &&
+                    !storedAssignment &&
+                    this.workspaceStore) {
+                    void this.workspaceStore.assignSession(provider, msg.sessionId, resolvedResumeWorkspace).catch((error) => {
+                        console.error("[workspace] Failed to persist resume assignment:", error);
+                    });
+                }
                 const normalizedCodexPermissionsMode = provider === "codex"
                     ? normalizeCodexPermissionsMode(msg.codexPermissionsMode)
                     : undefined;
@@ -3960,7 +4062,7 @@ export class BridgeWebSocketServer {
                     const effectiveProfile = msg.profile
                         ? await this.resolveCodexResumeProfile(msg.profile, sessionRefId, effectiveProjectPath)
                         : undefined;
-                    const additionalWritableRoots = this.normalizeAdditionalWritableRoots(msg.additionalWritableRoots, effectiveProjectPath);
+                    const additionalWritableRoots = this.normalizeAdditionalWritableRoots(resumeAdditionalRoots, effectiveProjectPath);
                     if (additionalWritableRoots.deniedRoot) {
                         this.sendResumeFailed(ws, {
                             provider,
@@ -4031,9 +4133,18 @@ export class BridgeWebSocketServer {
                             collaborationMode: planMode
                                 ? "plan"
                                 : "default",
-                        }));
+                        }), { deferProcessMessages: true });
+                        if (!this.attachProvisionalResumeSession(resumeOperation.key, resumeOperation.operationId, sessionId)) {
+                            this.sessionManager.destroy(sessionId);
+                            break;
+                        }
                         sessionCreateMs = Date.now() - createStartedAt;
                         const createdSession = this.sessionManager.get(sessionId);
+                        const waitUntilReady = createdSession?.process?.waitUntilReady;
+                        if (!waitUntilReady) {
+                            throw new Error("Codex session readiness is unavailable");
+                        }
+                        await waitUntilReady.call(createdSession?.process);
                         if (createdSession) {
                             // get_history immediately follows session_created on the app.
                             // Reuse the canonical history loaded above instead of issuing a
@@ -4080,6 +4191,7 @@ export class BridgeWebSocketServer {
                             this.sessionManager.destroy(sessionId);
                             break;
                         }
+                        this.sessionManager.releaseDeferredProcessMessages(sessionId);
                         this.broadcastSessionList();
                         this.debugEvents.set(sessionId, []);
                         this.recordDebugEvent(sessionId, {
@@ -4088,7 +4200,9 @@ export class BridgeWebSocketServer {
                             type: "session_resumed",
                             detail: `provider=codex thread=${sessionRefId}`,
                         });
-                        this.projectHistory?.addProject(effectiveProjectPath);
+                        if (!resolvedResumeWorkspace) {
+                            this.projectHistory?.addProject(effectiveProjectPath);
+                        }
                         console.info(formatResumePerformanceLog({
                             provider: "codex",
                             sourceSessionId: sessionRefId,
@@ -4114,11 +4228,29 @@ export class BridgeWebSocketServer {
                             nameLoadMs,
                             totalMs: Date.now() - resumeStartedAt,
                         }));
-                        this.failResumeOperation(resumeOperation.key, resumeOperation.operationId, `Failed to load Codex session history: ${err}`);
+                        const activeWriterConflict = isCodexThreadWriterConflict(err);
+                        this.failResumeOperation(resumeOperation.key, resumeOperation.operationId, activeWriterConflict
+                            ? codexErrorMessage(err)
+                            : historyLoaded
+                                ? `Failed to restore Codex session: ${err}`
+                                : `Failed to load Codex session history: ${err}`, activeWriterConflict
+                            ? "codex_thread_writer_conflict"
+                            : undefined);
                     }
                     break;
                 }
                 const claudeSessionId = sessionRefId;
+                const additionalDirectories = this.normalizeAdditionalWritableRoots(resumeAdditionalRoots, resumeProjectPath);
+                if (additionalDirectories.deniedRoot) {
+                    this.sendResumeFailed(ws, {
+                        provider,
+                        sourceSessionId: sessionRefId,
+                        projectPath: resumeProjectPath,
+                        resumeRequestId: msg.resumeRequestId,
+                    });
+                    this.send(ws, this.buildPathNotAllowedError(additionalDirectories.deniedRoot));
+                    break;
+                }
                 // Look up worktree mapping for this Claude session
                 const wtMapping = this.worktreeStore.get(claudeSessionId);
                 let worktreeOpts;
@@ -4173,6 +4305,7 @@ export class BridgeWebSocketServer {
                             ...(msg.sandboxMode
                                 ? { sandboxEnabled: msg.sandboxMode === "on" }
                                 : {}),
+                            additionalDirectories: additionalDirectories.roots,
                         },
                         pastMessages,
                         worktreeOptions: worktreeOpts,
@@ -4243,7 +4376,9 @@ export class BridgeWebSocketServer {
                         type: "session_resumed",
                         detail: `provider=claude session=${claudeSessionId}`,
                     });
-                    this.projectHistory?.addProject(resumeProjectPath);
+                    if (!resolvedResumeWorkspace) {
+                        this.projectHistory?.addProject(resumeProjectPath);
+                    }
                 })
                     .catch((err) => {
                     if (!historyLoaded) {
@@ -4330,16 +4465,104 @@ export class BridgeWebSocketServer {
                 break;
             }
             case "list_project_history": {
-                const projects = this.projectHistory?.getProjects() ?? [];
+                const projects = this.legacyProjectHistoryProjects();
                 this.send(ws, { type: "project_history", projects });
                 break;
             }
             case "remove_project_history": {
                 this.projectHistory?.removeProject(msg.projectPath);
-                const projects = this.projectHistory?.getProjects() ?? [];
+                const projects = this.legacyProjectHistoryProjects();
                 this.send(ws, { type: "project_history", projects });
                 break;
             }
+            case "list_projects": {
+                this.send(ws, this.projectsMessage(msg.requestId));
+                break;
+            }
+            case "create_project": {
+                if (!this.workspaceStore) {
+                    this.send(ws, {
+                        type: "error",
+                        requestId: msg.requestId,
+                        errorCode: "projects_unavailable",
+                        message: "Project storage is unavailable",
+                    });
+                    break;
+                }
+                const normalized = this.normalizeWorkspaceRoots(msg.rootPaths);
+                if (normalized.deniedRoot || !normalized.roots) {
+                    this.send(ws, this.buildPathNotAllowedError(normalized.deniedRoot ?? msg.rootPaths[0]));
+                    break;
+                }
+                try {
+                    await this.workspaceStore.createProject(msg.name, normalized.roots);
+                    this.broadcast(this.projectsMessage(msg.requestId));
+                }
+                catch (error) {
+                    this.sendWorkspaceMutationError(ws, msg.requestId, "create Project", error);
+                }
+                break;
+            }
+            case "update_project": {
+                if (!this.workspaceStore) {
+                    this.send(ws, {
+                        type: "error",
+                        requestId: msg.requestId,
+                        errorCode: "projects_unavailable",
+                        message: "Project storage is unavailable",
+                    });
+                    break;
+                }
+                const normalized = this.normalizeWorkspaceRoots(msg.rootPaths);
+                if (normalized.deniedRoot || !normalized.roots) {
+                    this.send(ws, this.buildPathNotAllowedError(normalized.deniedRoot ?? msg.rootPaths[0]));
+                    break;
+                }
+                let updated;
+                try {
+                    updated = await this.workspaceStore.updateProject(msg.projectId, msg.name, normalized.roots);
+                }
+                catch (error) {
+                    this.sendWorkspaceMutationError(ws, msg.requestId, "update Project", error);
+                    break;
+                }
+                if (!updated) {
+                    this.send(ws, {
+                        type: "error",
+                        requestId: msg.requestId,
+                        errorCode: "project_not_found",
+                        message: `Project not found: ${msg.projectId}`,
+                    });
+                    break;
+                }
+                this.broadcast(this.projectsMessage(msg.requestId));
+                break;
+            }
+            case "remove_project": {
+                if (!this.workspaceStore) {
+                    this.sendWorkspaceMutationError(ws, msg.requestId, "remove Project", new Error("Project storage is unavailable"));
+                    break;
+                }
+                let removed;
+                try {
+                    removed = await this.workspaceStore.removeProject(msg.projectId);
+                }
+                catch (error) {
+                    this.sendWorkspaceMutationError(ws, msg.requestId, "remove Project", error);
+                    break;
+                }
+                if (!removed) {
+                    this.send(ws, {
+                        type: "error",
+                        requestId: msg.requestId,
+                        errorCode: "project_not_found",
+                        message: `Project not found: ${msg.projectId}`,
+                    });
+                    break;
+                }
+                this.broadcast(this.projectsMessage(msg.requestId));
+                break;
+            }
             case "list_directory": {
                 try {
                     const listing = await listAllowedDirectories(msg.path, this.allowedDirs, this.platform, msg.includeHidden ?? false);
@@ -6007,6 +6230,7 @@ export class BridgeWebSocketServer {
             return false;
         if (operation.timeout)
             clearTimeout(operation.timeout);
+        operation.provisionalSessionId = undefined;
         operation.completed = {
             sessionId,
             message,
@@ -6025,16 +6249,36 @@ export class BridgeWebSocketServer {
         this.pruneCompletedResumeOperations();
         return true;
     }
-    failResumeOperation(key, operationId, message) {
+    failResumeOperation(key, operationId, message, errorCode) {
         const operation = this.resumeOperations.get(key);
         if (!operation || operation.id !== operationId)
             return;
+        if (operation.provisionalSessionId) {
+            this.sessionManager.destroy(operation.provisionalSessionId);
+            operation.provisionalSessionId = undefined;
+        }
         this.clearResumeOperation(key, operation);
         for (const waiter of operation.waiters) {
             this.rejectPendingClaudeResumeInputs(waiter, operation.sourceSessionId);
             this.sendResumeFailed(waiter, operation);
-            this.send(waiter, { type: "error", message });
+            this.send(waiter, {
+                type: "error",
+                message,
+                sessionId: operation.sourceSessionId,
+                ...(operation.resumeRequestId
+                    ? { requestId: operation.resumeRequestId }
+                    : {}),
+                ...(errorCode ? { errorCode } : {}),
+            });
+        }
+    }
+    attachProvisionalResumeSession(key, operationId, sessionId) {
+        const operation = this.resumeOperations.get(key);
+        if (!operation || operation.id !== operationId || operation.completed) {
+            return false;
         }
+        operation.provisionalSessionId = sessionId;
+        return true;
     }
     sendResumeFailed(ws, resume) {
         this.send(ws, {
@@ -6166,7 +6410,7 @@ export class BridgeWebSocketServer {
     }
     sendSessionList(ws) {
         this.pruneDebugEvents();
-        const sessions = this.sessionManager.list();
+        const sessions = this.runtimeSessionsWithWorkspaces();
         this.send(ws, {
             type: "session_list",
             sessions,
@@ -6204,7 +6448,7 @@ export class BridgeWebSocketServer {
     /** Broadcast session list to all connected clients. */
     broadcastSessionList() {
         this.pruneDebugEvents();
-        const sessions = this.sessionManager.list();
+        const sessions = this.runtimeSessionsWithWorkspaces();
         this.broadcast({
             type: "session_list",
             sessions,
@@ -6226,6 +6470,18 @@ export class BridgeWebSocketServer {
             ],
         });
     }
+    runtimeSessionsWithWorkspaces() {
+        return this.sessionManager
+            .list()
+            .map((summary) => this.runtimeSessionWithWorkspace(summary));
+    }
+    runtimeSessionWithWorkspace(summary) {
+        const session = this.sessionManager.get(summary.id);
+        const workspace = session
+            ? this.workspaceForRuntimeSession(session)
+            : undefined;
+        return workspace ? { ...summary, workspace } : summary;
+    }
     broadcastPromptHistoryStatus() {
         if (!this.promptHistoryStore)
             return;
@@ -6352,6 +6608,7 @@ export class BridgeWebSocketServer {
     }
     destroySession(sessionId) {
         this.flushSessionDeltaBatches(sessionId);
+        this.pendingSessionWorkspaces.delete(sessionId);
         this.sessionManager.destroy(sessionId);
     }
     trackSessionMessage(sessionId, msg) {
@@ -6395,6 +6652,128 @@ export class BridgeWebSocketServer {
         }
     }
     async listRecentSessions(msg) {
+        const primaryProjectIds = new Set(msg.projectPath === undefined
+            ? []
+            : (this.workspaceStore?.listProjects() ?? [])
+                .filter((project) => project.rootPaths[0] === msg.projectPath)
+                .map((project) => project.id));
+        const workspaceFilterRequested = msg.projectId !== undefined ||
+            msg.workspaceKind !== undefined ||
+            primaryProjectIds.size > 0;
+        if (!workspaceFilterRequested) {
+            const rawResult = await this.listRecentSessionsRaw(msg);
+            const enriched = rawResult.sessions.map((session) => this.enrichRecentSessionWorkspace(session));
+            return { sessions: enriched, hasMore: rawResult.hasMore };
+        }
+        const matchesWorkspace = (session) => {
+            const value = session;
+            const workspace = value.workspace;
+            if (msg.projectId && workspace?.projectId !== msg.projectId)
+                return false;
+            if (msg.workspaceKind && workspace?.kind !== msg.workspaceKind)
+                return false;
+            if (msg.projectPath !== undefined) {
+                const matchesPrimaryProject = typeof workspace?.projectId === "string" &&
+                    primaryProjectIds.has(workspace.projectId);
+                if (value.projectPath !== msg.projectPath &&
+                    !matchesPrimaryProject) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        const offset = msg.offset ?? 0;
+        const limit = msg.limit ?? 20;
+        const requiredMatches = offset + limit + 1;
+        let filtered;
+        if (msg.provider === "codex") {
+            filtered = await this.listWorkspaceFilteredCodexSessions(msg, matchesWorkspace, requiredMatches);
+        }
+        else if (msg.provider === "claude") {
+            filtered = await this.listWorkspaceFilteredIndexedSessions(msg, matchesWorkspace, requiredMatches);
+        }
+        else {
+            // The filesystem index includes both providers and is also the fallback
+            // for Codex rollouts not returned by app-server. Merge it with one
+            // cursor-preserving app-server scan for the freshest Codex metadata.
+            const [indexed, codex] = await Promise.all([
+                this.listWorkspaceFilteredIndexedSessions(msg, matchesWorkspace, requiredMatches),
+                this.listWorkspaceFilteredCodexSessions({ ...msg, provider: "codex" }, matchesWorkspace, requiredMatches),
+            ]);
+            filtered = mergeRecentSessionPages([...codex, ...indexed]);
+        }
+        return {
+            sessions: filtered.slice(offset, offset + limit),
+            hasMore: filtered.length > offset + limit,
+        };
+    }
+    async listWorkspaceFilteredIndexedSessions(msg, matchesWorkspace, limit) {
+        const result = await getAllRecentSessions({
+            limit,
+            offset: 0,
+            // Project identity is authoritative. Do not pre-filter by the current
+            // primary root: assignments may retain an older snapshot or worktree cwd.
+            provider: msg.provider,
+            namedOnly: msg.namedOnly,
+            searchQuery: msg.searchQuery,
+            archivedSessionIds: this.archiveStore.archivedIds(),
+            sessionFilter: (session) => matchesWorkspace(this.enrichRecentSessionWorkspace(session)),
+        });
+        return result.sessions.map((session) => this.enrichRecentSessionWorkspace(session));
+    }
+    async listWorkspaceFilteredCodexSessions(msg, matchesWorkspace, limit) {
+        try {
+            return await this.listWorkspaceFilteredCodexThreads(msg, matchesWorkspace, limit);
+        }
+        catch (err) {
+            console.warn(`[ws] Codex thread/list failed, falling back to rollout scan: ${err}`);
+            return this.listWorkspaceFilteredIndexedSessions({ ...msg, provider: "codex" }, matchesWorkspace, limit);
+        }
+    }
+    async listWorkspaceFilteredCodexThreads(msg, matchesWorkspace, limit) {
+        const activeProcess = this.getActiveCodexProcess();
+        const process = activeProcess ?? (await this.createStandaloneCodexProcess(undefined));
+        const isStandalone = activeProcess === null;
+        try {
+            const archivedIds = this.archiveStore.archivedIds();
+            const matchingThreads = [];
+            let cursor;
+            do {
+                const request = {
+                    limit: 500,
+                    searchTerm: msg.searchQuery,
+                    sourceKinds: CODEX_RECENT_THREAD_SOURCE_KINDS,
+                };
+                if (cursor != null)
+                    request.cursor = cursor;
+                const result = await process.listThreads(request);
+                for (const thread of result.data) {
+                    if (archivedIds.has(thread.id))
+                        continue;
+                    if (msg.namedOnly && !thread.name)
+                        continue;
+                    const workspaceProbe = this.enrichRecentSessionWorkspace({
+                        provider: "codex",
+                        sessionId: thread.id,
+                        projectPath: thread.cwd,
+                    });
+                    if (!matchesWorkspace(workspaceProbe))
+                        continue;
+                    matchingThreads.push(thread);
+                    if (matchingThreads.length >= limit)
+                        break;
+                }
+                cursor = result.nextCursor;
+            } while (matchingThreads.length < limit && cursor != null);
+            const indexedById = await getCodexSessionIndexMetadata(matchingThreads.map((thread) => thread.id));
+            return matchingThreads.map((thread) => this.enrichRecentSessionWorkspace(codexThreadToRecentSession(thread, indexedById.get(thread.id))));
+        }
+        finally {
+            if (isStandalone)
+                process.stop();
+        }
+    }
+    async listRecentSessionsRaw(msg) {
         if (msg.provider === "codex") {
             return this.listRecentCodexSessions(msg);
         }
@@ -6411,11 +6790,105 @@ export class BridgeWebSocketServer {
             archivedSessionIds: this.archiveStore.archivedIds(),
         });
     }
+    enrichRecentSessionWorkspace(session) {
+        if (!session || typeof session !== "object")
+            return session;
+        const value = session;
+        const provider = value.provider;
+        const providerSessionId = value.sessionId;
+        const projectPath = value.projectPath;
+        if ((provider !== "claude" && provider !== "codex") ||
+            typeof providerSessionId !== "string" ||
+            typeof projectPath !== "string") {
+            return session;
+        }
+        const workspace = this.workspaceStore?.resolveRecentWorkspace(provider, providerSessionId);
+        return {
+            ...value,
+            workspace: workspace ?? {
+                kind: "unassigned",
+                rootPaths: projectPath ? [projectPath] : [],
+            },
+        };
+    }
+    normalizeWorkspaceRoots(rootPaths) {
+        const roots = [];
+        const seen = new Set();
+        for (const rawPath of rootPaths) {
+            const path = resolvePlatformPath(rawPath, this.platform);
+            if (!this.isPathAllowed(path))
+                return { deniedRoot: rawPath };
+            if (!seen.has(path)) {
+                seen.add(path);
+                roots.push(path);
+            }
+        }
+        return roots.length > 0 ? { roots } : {};
+    }
+    async persistPendingSessionWorkspace(sessionId) {
+        const workspace = this.pendingSessionWorkspaces.get(sessionId);
+        const session = this.sessionManager.get(sessionId);
+        if (!workspace || !session?.claudeSessionId || !this.workspaceStore)
+            return;
+        try {
+            await this.workspaceStore.assignSession(session.provider, session.claudeSessionId, workspace);
+            this.pendingSessionWorkspaces.delete(sessionId);
+        }
+        catch (error) {
+            console.error("[workspace] Failed to persist session assignment:", error);
+        }
+    }
+    workspaceForRuntimeSession(session) {
+        const pending = this.pendingSessionWorkspaces.get(session.id);
+        if (pending) {
+            return { ...pending, rootPaths: [...pending.rootPaths] };
+        }
+        if (!session.claudeSessionId || !this.workspaceStore)
+            return undefined;
+        const assignment = this.workspaceStore.getAssignment(session.provider, session.claudeSessionId);
+        if (!assignment)
+            return undefined;
+        const project = assignment.projectId
+            ? this.workspaceStore.getProject(assignment.projectId)
+            : undefined;
+        return {
+            kind: assignment.kind,
+            ...(assignment.projectId ? { projectId: assignment.projectId } : {}),
+            ...(project ? { projectName: project.name } : {}),
+            rootPaths: [...assignment.rootPaths],
+        };
+    }
+    attachWorkspaceToRuntimeSession(sessionId, workspace) {
+        if (!workspace)
+            return;
+        this.pendingSessionWorkspaces.set(sessionId, workspace);
+        void this.persistPendingSessionWorkspace(sessionId);
+    }
+    projectsMessage(requestId) {
+        return {
+            type: "projects",
+            projects: this.workspaceStore?.listProjects() ?? [],
+            ...(requestId ? { requestId } : {}),
+        };
+    }
+    sendWorkspaceMutationError(ws, requestId, action, error) {
+        this.send(ws, {
+            type: "error",
+            requestId,
+            errorCode: "workspace_write_failed",
+            message: `Failed to ${action}: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+    legacyProjectHistoryProjects() {
+        return this.projectHistory?.getProjects() ?? [];
+    }
     listRecentSessionsCoalesced(msg) {
         const key = JSON.stringify({
             limit: msg.limit ?? null,
             offset: msg.offset ?? null,
             projectPath: msg.projectPath ?? null,
+            projectId: msg.projectId ?? null,
+            workspaceKind: msg.workspaceKind ?? null,
             provider: msg.provider ?? null,
             namedOnly: msg.namedOnly ?? null,
             searchQuery: msg.searchQuery ?? null,