@ccpocket/bridge 1.26.0 → 1.27.0

package/dist/websocket.js

@@ -38,6 +38,39 @@ const CODEX_MODELS = [
 function permissionModeToApprovalPolicy(mode) {
     return mode === "bypassPermissions" ? "never" : "on-request";
 }
+function deriveExecutionMode(params) {
+    if (params.executionMode === "default" ||
+        params.executionMode === "acceptEdits" ||
+        params.executionMode === "fullAccess") {
+        return params.executionMode;
+    }
+    if (params.permissionMode === "bypassPermissions" ||
+        params.approvalPolicy === "never") {
+        return "fullAccess";
+    }
+    if (params.permissionMode === "acceptEdits") {
+        return params.provider === "codex" ? "default" : "acceptEdits";
+    }
+    return "default";
+}
+function derivePlanMode(params) {
+    return params.planMode ??
+        ((params.permissionMode === "plan") ||
+            (params.collaborationMode === "plan"));
+}
+function modesToLegacyPermissionMode(provider, executionMode, planMode) {
+    if (planMode)
+        return "plan";
+    switch (executionMode) {
+        case "fullAccess":
+            return "bypassPermissions";
+        case "acceptEdits":
+            return "acceptEdits";
+        case "default":
+        default:
+            return provider === "codex" ? "acceptEdits" : "default";
+    }
+}
 /** Map simplified SandboxMode (on/off) to Codex internal sandbox mode. */
 function sandboxModeToInternal(mode) {
     switch (mode) {
@@ -58,6 +91,10 @@ function sandboxModeToExternal(mode) {
 function threadTimestampToIso(value) {
     return value > 0 ? new Date(value * 1000).toISOString() : "";
 }
+function envFlagEnabled(name) {
+    const value = process.env[name]?.trim().toLowerCase();
+    return value === "1" || value === "true" || value === "yes" || value === "on";
+}
 function codexThreadToRecentSession(thread, indexed) {
     return {
         sessionId: thread.id,
@@ -98,6 +135,8 @@ export class BridgeWebSocketServer {
     /** FCM token → push notification locale */
     tokenLocales = new Map();
     tokenPrivacyMode = new Map();
+    failSetPermissionMode = envFlagEnabled("BRIDGE_FAIL_SET_PERMISSION_MODE");
+    failSetSandboxMode = envFlagEnabled("BRIDGE_FAIL_SET_SANDBOX_MODE");
     constructor(options) {
         const { server, apiKey, allowedDirs, imageStore, galleryStore, projectHistory, debugTraceStore, recordingStore, firebaseAuth, promptHistoryBackup } = options;
         this.apiKey = apiKey ?? null;
@@ -176,6 +215,91 @@ export class BridgeWebSocketServer {
             errorCode: "path_not_allowed",
         };
     }
+    buildSessionCreatedMessage(params) {
+        const { sessionId, provider, projectPath, session, permissionMode, executionMode, planMode, sandboxMode, slashCommands, skills, skillMetadata, sourceSessionId, } = params;
+        const msg = {
+            type: "system",
+            subtype: "session_created",
+            sessionId,
+            provider,
+            projectPath,
+            ...(permissionMode ? { permissionMode: permissionMode } : {}),
+            ...((executionMode ?? (session?.process instanceof SdkProcess
+                ? session.process.permissionMode === "bypassPermissions"
+                    ? "fullAccess"
+                    : session.process.permissionMode === "acceptEdits"
+                        ? "acceptEdits"
+                        : "default"
+                : session?.process instanceof CodexProcess
+                    ? session.process.approvalPolicy === "never"
+                        ? "fullAccess"
+                        : "default"
+                    : undefined))
+                ? {
+                    executionMode: (executionMode ?? (session?.process instanceof SdkProcess
+                        ? session.process.permissionMode === "bypassPermissions"
+                            ? "fullAccess"
+                            : session.process.permissionMode === "acceptEdits"
+                                ? "acceptEdits"
+                                : "default"
+                        : session?.process instanceof CodexProcess
+                            ? session.process.approvalPolicy === "never"
+                                ? "fullAccess"
+                                : "default"
+                            : undefined)),
+                }
+                : {}),
+            ...((planMode ??
+                (session?.process instanceof SdkProcess
+                    ? session.process.permissionMode === "plan"
+                    : session?.process instanceof CodexProcess
+                        ? session.process.collaborationMode === "plan"
+                        : undefined)) !=
+                null
+                ? {
+                    planMode: planMode ??
+                        (session?.process instanceof SdkProcess
+                            ? session.process.permissionMode === "plan"
+                            : session?.process instanceof CodexProcess
+                                ? session.process.collaborationMode === "plan"
+                                : false),
+                }
+                : {}),
+            ...(sandboxMode ? { sandboxMode } : {}),
+            ...(slashCommands ? { slashCommands } : {}),
+            ...(skills ? { skills } : {}),
+            ...(skillMetadata
+                ? {
+                    skillMetadata: skillMetadata,
+                }
+                : {}),
+            ...(session?.worktreePath
+                ? {
+                    worktreePath: session.worktreePath,
+                    worktreeBranch: session.worktreeBranch,
+                }
+                : {}),
+            ...(sourceSessionId ? { sourceSessionId } : {}),
+        };
+        if (provider === "codex" && session?.codexSettings) {
+            if (session.codexSettings.model !== undefined) {
+                msg.model = session.codexSettings.model;
+            }
+            if (session.codexSettings.approvalPolicy !== undefined) {
+                msg.approvalPolicy = session.codexSettings.approvalPolicy;
+            }
+            if (session.codexSettings.modelReasoningEffort !== undefined) {
+                msg.modelReasoningEffort = session.codexSettings.modelReasoningEffort;
+            }
+            if (session.codexSettings.networkAccessEnabled !== undefined) {
+                msg.networkAccessEnabled = session.codexSettings.networkAccessEnabled;
+            }
+            if (session.codexSettings.webSearchMode !== undefined) {
+                msg.webSearchMode = session.codexSettings.webSearchMode;
+            }
+        }
+        return msg;
+    }
     close() {
         console.log("[ws] Shutting down...");
         this.sessionManager.destroyAll();
@@ -244,14 +368,24 @@ export class BridgeWebSocketServer {
                 }
                 try {
                     const provider = msg.provider ?? "claude";
+                    const executionMode = deriveExecutionMode({
+                        provider,
+                        permissionMode: msg.permissionMode,
+                        executionMode: msg.executionMode,
+                    });
+                    const planMode = derivePlanMode({
+                        permissionMode: msg.permissionMode,
+                        planMode: msg.planMode,
+                    });
+                    const legacyPermissionMode = modesToLegacyPermissionMode(provider, executionMode, planMode);
                     if (provider === "codex") {
-                        console.log(`[ws] start(codex): permissionMode=${msg.permissionMode} → collaboration=${msg.permissionMode === "plan" ? "plan" : "default"}`);
+                        console.log(`[ws] start(codex): execution=${executionMode} plan=${planMode}`);
                     }
                     const cached = provider === "claude" ? this.sessionManager.getCachedCommands(msg.projectPath) : undefined;
                     const sessionId = this.sessionManager.create(msg.projectPath, {
                         sessionId: msg.sessionId,
                         continueMode: msg.continue,
-                        permissionMode: msg.permissionMode,
+                        permissionMode: legacyPermissionMode,
                         model: msg.model,
                         effort: msg.effort,
                         maxTurns: msg.maxTurns,
@@ -269,33 +403,38 @@ export class BridgeWebSocketServer {
                         existingWorktreePath: msg.existingWorktreePath,
                     }, provider, provider === "codex"
                         ? {
-                            approvalPolicy: permissionModeToApprovalPolicy(msg.permissionMode),
+                            approvalPolicy: executionMode === "fullAccess" ? "never" : "on-request",
                             sandboxMode: sandboxModeToInternal(msg.sandboxMode),
                             model: msg.model,
                             modelReasoningEffort: msg.modelReasoningEffort ?? undefined,
                             networkAccessEnabled: msg.networkAccessEnabled,
                             webSearchMode: msg.webSearchMode ?? undefined,
                             threadId: msg.sessionId,
-                            collaborationMode: msg.permissionMode === "plan" ? "plan" : "default",
+                            collaborationMode: planMode ? "plan" : "default",
                         }
                         : undefined);
                     const createdSession = this.sessionManager.get(sessionId);
                     // Load saved session name from CLI storage (for resumed sessions)
                     void this.loadAndSetSessionName(createdSession, provider, msg.projectPath, msg.sessionId).then(() => {
-                        this.send(ws, {
-                            type: "system",
-                            subtype: "session_created",
+                        this.send(ws, this.buildSessionCreatedMessage({
                             sessionId,
                             provider,
                             projectPath: msg.projectPath,
-                            ...(msg.permissionMode ? { permissionMode: msg.permissionMode } : {}),
-                            ...(msg.sandboxMode ? { sandboxMode: msg.sandboxMode } : {}),
-                            ...(cached ? { slashCommands: cached.slashCommands, skills: cached.skills, ...(cached.skillMetadata ? { skillMetadata: cached.skillMetadata } : {}) } : {}),
-                            ...(createdSession?.worktreePath ? {
-                                worktreePath: createdSession.worktreePath,
-                                worktreeBranch: createdSession.worktreeBranch,
-                            } : {}),
-                        });
+                            session: createdSession,
+                            permissionMode: legacyPermissionMode,
+                            executionMode,
+                            planMode,
+                            sandboxMode: msg.sandboxMode,
+                            ...(cached
+                                ? {
+                                    slashCommands: cached.slashCommands,
+                                    skills: cached.skills,
+                                    ...(cached.skillMetadata
+                                        ? { skillMetadata: cached.skillMetadata }
+                                        : {}),
+                                }
+                                : {}),
+                        }));
                         this.broadcastSessionList();
                         // Send a gentle tip when the project is not a git repository
                         if (createdSession && !createdSession.gitBranch) {
@@ -510,6 +649,14 @@ export class BridgeWebSocketServer {
                 break;
             }
             case "set_permission_mode": {
+                if (this.failSetPermissionMode) {
+                    this.send(ws, {
+                        type: "error",
+                        message: "Failed to set permission mode: forced test failure",
+                        errorCode: "set_permission_mode_rejected",
+                    });
+                    break;
+                }
                 const session = this.resolveSession(msg.sessionId);
                 if (!session) {
                     this.send(ws, { type: "error", message: "No active session." });
@@ -519,14 +666,52 @@ export class BridgeWebSocketServer {
                     // Permission mode for Codex requires a session restart (like sandbox mode).
                     // approvalPolicy and collaborationMode are thread-level settings that
                     // only take effect reliably at thread/start or thread/resume time.
-                    const newApproval = permissionModeToApprovalPolicy(msg.mode);
-                    const newCollaboration = msg.mode === "plan" ? "plan" : "default";
+                    const executionMode = deriveExecutionMode({
+                        provider: "codex",
+                        permissionMode: msg.mode,
+                        executionMode: msg.executionMode,
+                    });
+                    const planMode = derivePlanMode({
+                        permissionMode: msg.mode,
+                        planMode: msg.planMode,
+                    });
+                    const legacyPermissionMode = modesToLegacyPermissionMode("codex", executionMode, planMode);
+                    const newApproval = executionMode === "fullAccess" ? "never" : "on-request";
+                    const newCollaboration = planMode ? "plan" : "default";
                     const currentApproval = session.process.approvalPolicy;
                     const currentCollaboration = session.process.collaborationMode;
                     if (newApproval === currentApproval && newCollaboration === currentCollaboration) {
                         break; // No change needed
                     }
-                    console.log(`[ws] set_permission_mode(codex): mode=${msg.mode} → approval=${newApproval}, collaboration=${newCollaboration} (restart)`);
+                    const canApplyModeInPlace = session.status === "idle";
+                    if (canApplyModeInPlace) {
+                        const process = session.process;
+                        if (newApproval !== currentApproval) {
+                            process.setApprovalPolicy(newApproval);
+                        }
+                        if (newCollaboration !== currentCollaboration) {
+                            process.setCollaborationMode(newCollaboration);
+                        }
+                        session.lastActivityAt = new Date();
+                        this.broadcast({
+                            type: "system",
+                            subtype: "set_permission_mode",
+                            sessionId: session.id,
+                            permissionMode: legacyPermissionMode,
+                            executionMode,
+                            planMode,
+                        });
+                        this.broadcastSessionList();
+                        this.recordDebugEvent(session.id, {
+                            direction: "internal",
+                            channel: "bridge",
+                            type: "permission_mode_changed",
+                            detail: `mode=${msg.mode} approval=${newApproval} collaboration=${newCollaboration} applied=in-place`,
+                        });
+                        console.log(`[ws] set_permission_mode(codex): execution=${executionMode} plan=${planMode} → approval=${newApproval}, collaboration=${newCollaboration} (in-place)`);
+                        break;
+                    }
+                    console.log(`[ws] set_permission_mode(codex): execution=${executionMode} plan=${planMode} → approval=${newApproval}, collaboration=${newCollaboration} (restart)`);
                     const oldSessionId = session.id;
                     const threadId = session.claudeSessionId;
                     const projectPath = session.projectPath;
@@ -550,17 +735,19 @@ export class BridgeWebSocketServer {
                         const newSession = this.sessionManager.get(newId);
                         if (newSession && sessionName)
                             newSession.name = sessionName;
-                        this.broadcast({
-                            type: "system",
-                            subtype: "session_created",
+                        this.broadcast(this.buildSessionCreatedMessage({
                             sessionId: newId,
                             provider: "codex",
                             projectPath,
-                            permissionMode: msg.mode,
-                            ...(oldSettings.sandboxMode ? { sandboxMode: sandboxModeToExternal(oldSettings.sandboxMode) } : {}),
+                            session: newSession,
+                            permissionMode: legacyPermissionMode,
+                            executionMode,
+                            planMode,
+                            sandboxMode: oldSettings.sandboxMode
+                                ? sandboxModeToExternal(oldSettings.sandboxMode)
+                                : undefined,
                             sourceSessionId: oldSessionId,
-                            ...(newSession?.worktreePath ? { worktreePath: newSession.worktreePath, worktreeBranch: newSession.worktreeBranch } : {}),
-                        });
+                        }));
                         this.broadcastSessionList();
                         console.log(`[ws] Permission mode change (no thread): created new session ${newId} (mode=${msg.mode})`);
                         break;
@@ -596,20 +783,19 @@ export class BridgeWebSocketServer {
                             newSession.name = sessionName;
                         }
                         void this.loadAndSetSessionName(newSession, "codex", effectiveProjectPath, threadId).then(() => {
-                            this.broadcast({
-                                type: "system",
-                                subtype: "session_created",
+                            this.broadcast(this.buildSessionCreatedMessage({
                                 sessionId: newId,
                                 provider: "codex",
                                 projectPath: effectiveProjectPath,
-                                permissionMode: msg.mode,
-                                ...(oldSettings.sandboxMode ? { sandboxMode: sandboxModeToExternal(oldSettings.sandboxMode) } : {}),
+                                session: newSession,
+                                permissionMode: legacyPermissionMode,
+                                executionMode,
+                                planMode,
+                                sandboxMode: oldSettings.sandboxMode
+                                    ? sandboxModeToExternal(oldSettings.sandboxMode)
+                                    : undefined,
                                 sourceSessionId: oldSessionId,
-                                ...(newSession?.worktreePath ? {
-                                    worktreePath: newSession.worktreePath,
-                                    worktreeBranch: newSession.worktreeBranch,
-                                } : {}),
-                            });
+                            }));
                             this.broadcastSessionList();
                         });
                         this.debugEvents.set(newId, []);
@@ -634,6 +820,14 @@ export class BridgeWebSocketServer {
                 break;
             }
             case "set_sandbox_mode": {
+                if (this.failSetSandboxMode) {
+                    this.send(ws, {
+                        type: "error",
+                        message: "Failed to set sandbox mode: forced test failure",
+                        errorCode: "set_sandbox_mode_rejected",
+                    });
+                    break;
+                }
                 const session = this.resolveSession(msg.sessionId);
                 if (!session) {
                     this.send(ws, { type: "error", message: "No active session." });
@@ -670,19 +864,14 @@ export class BridgeWebSocketServer {
                     if (newSession && sessionName)
                         newSession.name = sessionName;
                     void this.loadAndSetSessionName(newSession, "claude", projectPath, claudeSessionId).then(() => {
-                        this.broadcast({
-                            type: "system",
-                            subtype: "session_created",
+                        this.broadcast(this.buildSessionCreatedMessage({
                             sessionId: newId,
                             provider: "claude",
                             projectPath,
+                            session: newSession,
                             sandboxMode: msg.sandboxMode,
                             sourceSessionId: oldSessionId,
-                            ...(newSession?.worktreePath ? {
-                                worktreePath: newSession.worktreePath,
-                                worktreeBranch: newSession.worktreeBranch,
-                            } : {}),
-                        });
+                        }));
                         this.broadcastSessionList();
                     });
                     this.debugEvents.set(newId, []);
@@ -713,6 +902,9 @@ export class BridgeWebSocketServer {
                 const worktreeBranch = session.worktreeBranch;
                 const sessionName = session.name;
                 const collaborationMode = session.process.collaborationMode;
+                const executionMode = oldSettings.approvalPolicy === "never" ? "fullAccess" : "default";
+                const planMode = collaborationMode === "plan";
+                const legacyPermissionMode = modesToLegacyPermissionMode("codex", executionMode, planMode);
                 this.sessionManager.destroy(oldSessionId);
                 console.log(`[ws] Sandbox mode change: destroyed session ${oldSessionId}`);
                 // Check if the user actually exchanged messages in this session.
@@ -737,16 +929,17 @@ export class BridgeWebSocketServer {
                     const newSession = this.sessionManager.get(newId);
                     if (newSession && sessionName)
                         newSession.name = sessionName;
-                    this.broadcast({
-                        type: "system",
-                        subtype: "session_created",
+                    this.broadcast(this.buildSessionCreatedMessage({
                         sessionId: newId,
                         provider: "codex",
                         projectPath,
+                        session: newSession,
+                        permissionMode: legacyPermissionMode,
+                        executionMode,
+                        planMode,
                         sandboxMode: sandboxModeToExternal(newSandboxMode),
                         sourceSessionId: oldSessionId,
-                        ...(newSession?.worktreePath ? { worktreePath: newSession.worktreePath, worktreeBranch: newSession.worktreeBranch } : {}),
-                    });
+                    }));
                     this.broadcastSessionList();
                     console.log(`[ws] Sandbox mode change (no thread): created new session ${newId} (sandbox=${newSandboxMode})`);
                     break;
@@ -783,19 +976,17 @@ export class BridgeWebSocketServer {
                         newSession.name = sessionName;
                     }
                     void this.loadAndSetSessionName(newSession, "codex", effectiveProjectPath, threadId).then(() => {
-                        this.broadcast({
-                            type: "system",
-                            subtype: "session_created",
+                        this.broadcast(this.buildSessionCreatedMessage({
                             sessionId: newId,
                             provider: "codex",
                             projectPath: effectiveProjectPath,
+                            session: newSession,
+                            permissionMode: legacyPermissionMode,
+                            executionMode,
+                            planMode,
                             sandboxMode: sandboxModeToExternal(newSandboxMode),
                             sourceSessionId: oldSessionId,
-                            ...(newSession?.worktreePath ? {
-                                worktreePath: newSession.worktreePath,
-                                worktreeBranch: newSession.worktreeBranch,
-                            } : {}),
-                        });
+                        }));
                         this.broadcastSessionList();
                     });
                     this.debugEvents.set(newId, []);
@@ -856,16 +1047,15 @@ export class BridgeWebSocketServer {
                     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);
-                    this.broadcast({
-                        type: "system",
-                        subtype: "session_created",
+                    const createdMsg = this.buildSessionCreatedMessage({
                         sessionId: newId,
                         provider: newSession?.provider ?? "claude",
                         projectPath,
-                        ...(permissionMode ? { permissionMode } : {}),
-                        clearContext: true,
+                        session: newSession,
+                        permissionMode,
                         sourceSessionId: sessionId,
                     });
+                    this.broadcast({ ...createdMsg, clearContext: true });
                     this.broadcastSessionList();
                 }
                 else {
@@ -1109,6 +1299,16 @@ export class BridgeWebSocketServer {
                     break;
                 }
                 const provider = msg.provider ?? "claude";
+                const executionMode = deriveExecutionMode({
+                    provider,
+                    permissionMode: msg.permissionMode,
+                    executionMode: msg.executionMode,
+                });
+                const planMode = derivePlanMode({
+                    permissionMode: msg.permissionMode,
+                    planMode: msg.planMode,
+                });
+                const legacyPermissionMode = modesToLegacyPermissionMode(provider, executionMode, planMode);
                 const sessionRefId = msg.sessionId;
                 // Resume flow: keep past history in SessionInfo and deliver it only
                 // via get_history(sessionId) to avoid duplicate/missed replay races.
@@ -1133,29 +1333,28 @@ export class BridgeWebSocketServer {
                     getCodexSessionHistory(sessionRefId).then((pastMessages) => {
                         const sessionId = this.sessionManager.create(effectiveProjectPath, undefined, pastMessages, worktreeOpts, "codex", {
                             threadId: sessionRefId,
-                            approvalPolicy: permissionModeToApprovalPolicy(msg.permissionMode),
+                            approvalPolicy: executionMode === "fullAccess" ? "never" : "on-request",
                             sandboxMode: sandboxModeToInternal(msg.sandboxMode),
                             model: msg.model,
                             modelReasoningEffort: msg.modelReasoningEffort ?? undefined,
                             networkAccessEnabled: msg.networkAccessEnabled,
                             webSearchMode: msg.webSearchMode ?? undefined,
-                            collaborationMode: msg.permissionMode === "plan" ? "plan" : "default",
+                            collaborationMode: planMode ? "plan" : "default",
                         });
                         const createdSession = this.sessionManager.get(sessionId);
                         void this.loadAndSetSessionName(createdSession, "codex", effectiveProjectPath, sessionRefId).then(() => {
-                            this.send(ws, {
-                                type: "system",
-                                subtype: "session_created",
+                            this.send(ws, this.buildSessionCreatedMessage({
                                 sessionId,
                                 provider: "codex",
                                 projectPath: effectiveProjectPath,
-                                ...(createdSession?.codexSettings?.sandboxMode ? { sandboxMode: sandboxModeToExternal(createdSession.codexSettings.sandboxMode) } : {}),
-                                ...(msg.permissionMode ? { permissionMode: msg.permissionMode } : {}),
-                                ...(createdSession?.worktreePath ? {
-                                    worktreePath: createdSession.worktreePath,
-                                    worktreeBranch: createdSession.worktreeBranch,
-                                } : {}),
-                            });
+                                session: createdSession,
+                                sandboxMode: createdSession?.codexSettings?.sandboxMode
+                                    ? sandboxModeToExternal(createdSession.codexSettings.sandboxMode)
+                                    : undefined,
+                                permissionMode: legacyPermissionMode,
+                                executionMode,
+                                planMode,
+                            }));
                             this.broadcastSessionList();
                         });
                         this.debugEvents.set(sessionId, []);
@@ -1192,7 +1391,7 @@ export class BridgeWebSocketServer {
                 getSessionHistory(claudeSessionId).then((pastMessages) => {
                     const sessionId = this.sessionManager.create(msg.projectPath, {
                         sessionId: claudeSessionId,
-                        permissionMode: msg.permissionMode,
+                        permissionMode: legacyPermissionMode,
                         model: msg.model,
                         effort: msg.effort,
                         maxTurns: msg.maxTurns,
@@ -1205,19 +1404,26 @@ export class BridgeWebSocketServer {
                     const createdSession = this.sessionManager.get(sessionId);
                     void this.loadAndSetSessionName(createdSession, "claude", msg.projectPath, claudeSessionId).then(() => {
                         this.send(ws, {
-                            type: "system",
-                            subtype: "session_created",
-                            sessionId,
+                            ...this.buildSessionCreatedMessage({
+                                sessionId,
+                                provider: "claude",
+                                projectPath: msg.projectPath,
+                                session: createdSession,
+                                permissionMode: legacyPermissionMode,
+                                executionMode,
+                                planMode,
+                                sandboxMode: msg.sandboxMode,
+                                ...(cached
+                                    ? {
+                                        slashCommands: cached.slashCommands,
+                                        skills: cached.skills,
+                                        ...(cached.skillMetadata
+                                            ? { skillMetadata: cached.skillMetadata }
+                                            : {}),
+                                    }
+                                    : {}),
+                            }),
                             claudeSessionId,
-                            provider: "claude",
-                            projectPath: msg.projectPath,
-                            ...(msg.permissionMode ? { permissionMode: msg.permissionMode } : {}),
-                            ...(msg.sandboxMode ? { sandboxMode: msg.sandboxMode } : {}),
-                            ...(cached ? { slashCommands: cached.slashCommands, skills: cached.skills, ...(cached.skillMetadata ? { skillMetadata: cached.skillMetadata } : {}) } : {}),
-                            ...(createdSession?.worktreePath ? {
-                                worktreePath: createdSession.worktreePath,
-                                worktreeBranch: createdSession.worktreeBranch,
-                            } : {}),
                         });
                         this.broadcastSessionList();
                     });
@@ -1527,15 +1733,14 @@ export class BridgeWebSocketServer {
                             // Notify the new session ID
                             const newSession = this.sessionManager.get(newSessionId);
                             const rewindPermMode = newSession?.process instanceof SdkProcess ? newSession.process.permissionMode : undefined;
-                            this.send(ws, {
-                                type: "system",
-                                subtype: "session_created",
+                            this.send(ws, this.buildSessionCreatedMessage({
                                 sessionId: newSessionId,
                                 provider: newSession?.provider ?? "claude",
                                 projectPath: newSession?.projectPath ?? "",
-                                ...(rewindPermMode ? { permissionMode: rewindPermMode } : {}),
+                                session: newSession,
+                                permissionMode: rewindPermMode,
                                 sourceSessionId: msg.sessionId,
-                            });
+                            }));
                             this.sendSessionList(ws);
                         });
                     }
@@ -1555,15 +1760,14 @@ export class BridgeWebSocketServer {
                                 this.send(ws, { type: "rewind_result", success: true, mode: "both" });
                                 const newSession = this.sessionManager.get(newSessionId);
                                 const rewindPermMode2 = newSession?.process instanceof SdkProcess ? newSession.process.permissionMode : undefined;
-                                this.send(ws, {
-                                    type: "system",
-                                    subtype: "session_created",
+                                this.send(ws, this.buildSessionCreatedMessage({
                                     sessionId: newSessionId,
                                     provider: newSession?.provider ?? "claude",
                                     projectPath: newSession?.projectPath ?? "",
-                                    ...(rewindPermMode2 ? { permissionMode: rewindPermMode2 } : {}),
+                                    session: newSession,
+                                    permissionMode: rewindPermMode2,
                                     sourceSessionId: msg.sessionId,
-                                });
+                                }));
                                 this.sendSessionList(ws);
                             });
                         }