@ccpocket/bridge 1.29.1 → 1.31.0

package/dist/websocket.js

@@ -7,11 +7,13 @@ import { WebSocketServer, WebSocket } from "ws";
 import { SessionManager } from "./session.js";
 import { SdkProcess } from "./sdk-process.js";
 import { CodexProcess } from "./codex-process.js";
-import { parseClientMessage } from "./parser.js";
-import { getAllRecentSessions, getCodexSessionHistory, getSessionHistory, findSessionsByClaudeIds, extractMessageImages, getClaudeSessionName, loadCodexSessionNames, renameClaudeSession, renameCodexSession } from "./sessions-index.js";
+import { parseClientMessage, } from "./parser.js";
+import { getAllRecentSessions, getCodexSessionHistory, getSessionHistory, findSessionsByClaudeIds, extractMessageImages, getClaudeSessionName, loadCodexSessionNames, renameClaudeSession, renameCodexSession, } from "./sessions-index.js";
 import { ArchiveStore } from "./archive-store.js";
 import { WorktreeStore } from "./worktree-store.js";
-import { listWorktrees, removeWorktree, worktreeExists, getMainBranch } from "./worktree.js";
+import { listWorktrees, removeWorktree, worktreeExists, getMainBranch, } from "./worktree.js";
+import { stageFiles, stageHunks, unstageFiles, unstageHunks, gitCommit, gitPush, listBranches, createBranch, checkoutBranch, revertFiles, revertHunks, gitFetch, gitPull, gitRemoteStatus, } from "./git-operations.js";
+import { generateCommitMessage } from "./git-assist.js";
 import { listWindows, takeScreenshot } from "./screenshot.js";
 import { DebugTraceStore } from "./debug-trace-store.js";
 import { PushRelayClient } from "./push-relay.js";
@@ -54,9 +56,8 @@ function deriveExecutionMode(params) {
     return "default";
 }
 function derivePlanMode(params) {
-    return params.planMode ??
-        ((params.permissionMode === "plan") ||
-            (params.collaborationMode === "plan"));
+    return (params.planMode ??
+        (params.permissionMode === "plan" || params.collaborationMode === "plan"));
 }
 function modesToLegacyPermissionMode(provider, executionMode, planMode) {
     if (planMode)
@@ -138,7 +139,7 @@ export class BridgeWebSocketServer {
     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;
+        const { server, apiKey, allowedDirs, imageStore, galleryStore, projectHistory, debugTraceStore, recordingStore, firebaseAuth, promptHistoryBackup, } = options;
         this.apiKey = apiKey ?? null;
         this.allowedDirs = allowedDirs ?? [];
         this.imageStore = imageStore ?? null;
@@ -223,30 +224,36 @@ export class BridgeWebSocketServer {
             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))
+            ...(permissionMode
                 ? {
-                    executionMode: (executionMode ?? (session?.process instanceof SdkProcess
-                        ? session.process.permissionMode === "bypassPermissions"
+                    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"
-                            : session.process.permissionMode === "acceptEdits"
-                                ? "acceptEdits"
-                                : "default"
-                        : session?.process instanceof CodexProcess
-                            ? session.process.approvalPolicy === "never"
+                            : "default"
+                        : undefined))
+                ? {
+                    executionMode: (executionMode ??
+                        (session?.process instanceof SdkProcess
+                            ? session.process.permissionMode === "bypassPermissions"
                                 ? "fullAccess"
-                                : "default"
-                            : undefined)),
+                                : session.process.permissionMode === "acceptEdits"
+                                    ? "acceptEdits"
+                                    : "default"
+                            : session?.process instanceof CodexProcess
+                                ? session.process.approvalPolicy === "never"
+                                    ? "fullAccess"
+                                    : "default"
+                                : undefined)),
                 }
                 : {}),
             ...((planMode ??
@@ -254,8 +261,7 @@ export class BridgeWebSocketServer {
                     ? session.process.permissionMode === "plan"
                     : session?.process instanceof CodexProcess
                         ? session.process.collaborationMode === "plan"
-                        : undefined)) !=
-                null
+                        : undefined)) != null
                 ? {
                     planMode: planMode ??
                         (session?.process instanceof SdkProcess
@@ -327,9 +333,12 @@ export class BridgeWebSocketServer {
                 // handle the unsupported message (suppress vs show update hint).
                 let rawType;
                 try {
-                    rawType = JSON.parse(raw)?.type;
+                    rawType = JSON.parse(raw)
+                        ?.type;
+                }
+                catch {
+                    /* ignore */
                 }
-                catch { /* ignore */ }
                 console.error("[ws] Unsupported message:", rawType ?? raw.slice(0, 200));
                 this.send(ws, {
                     type: "error",
@@ -350,7 +359,8 @@ export class BridgeWebSocketServer {
     }
     async handleClientMessage(msg, ws) {
         const incomingSessionId = this.extractSessionIdFromClientMessage(msg);
-        const isActiveRuntimeSession = incomingSessionId != null && this.sessionManager.get(incomingSessionId) != null;
+        const isActiveRuntimeSession = incomingSessionId != null &&
+            this.sessionManager.get(incomingSessionId) != null;
         if (incomingSessionId && isActiveRuntimeSession) {
             this.recordDebugEvent(incomingSessionId, {
                 direction: "incoming",
@@ -381,7 +391,9 @@ export class BridgeWebSocketServer {
                     if (provider === "codex") {
                         console.log(`[ws] start(codex): execution=${executionMode} plan=${planMode}`);
                     }
-                    const cached = provider === "claude" ? this.sessionManager.getCachedCommands(msg.projectPath) : undefined;
+                    const cached = provider === "claude"
+                        ? this.sessionManager.getCachedCommands(msg.projectPath)
+                        : undefined;
                     const sessionId = this.sessionManager.create(msg.projectPath, {
                         sessionId: msg.sessionId,
                         continueMode: msg.continue,
@@ -408,9 +420,12 @@ export class BridgeWebSocketServer {
                             model: msg.model,
                             modelReasoningEffort: msg.modelReasoningEffort ?? undefined,
                             networkAccessEnabled: msg.networkAccessEnabled,
-                            webSearchMode: msg.webSearchMode ?? undefined,
+                            webSearchMode: msg.webSearchMode ??
+                                undefined,
                             threadId: msg.sessionId,
-                            collaborationMode: planMode ? "plan" : "default",
+                            collaborationMode: planMode
+                                ? "plan"
+                                : "default",
                         }
                         : undefined);
                     const createdSession = this.sessionManager.get(sessionId);
@@ -464,20 +479,31 @@ export class BridgeWebSocketServer {
                 }
                 catch (err) {
                     console.error(`[ws] Failed to start session:`, err);
-                    this.send(ws, { type: "error", message: `Failed to start session: ${err.message}` });
+                    this.send(ws, {
+                        type: "error",
+                        message: `Failed to start session: ${err.message}`,
+                    });
                 }
                 break;
             }
             case "input": {
                 const session = this.resolveSession(msg.sessionId);
                 if (!session) {
-                    this.send(ws, { type: "error", message: "No active session. Send 'start' first." });
+                    this.send(ws, {
+                        type: "error",
+                        message: "No active session. Send 'start' first.",
+                    });
                     return;
                 }
                 const text = msg.text;
                 // Codex: reject if the process is not waiting for input (turn-based, no internal queue)
-                if (session.provider === "codex" && !session.process.isWaitingForInput) {
-                    this.send(ws, { type: "input_rejected", sessionId: session.id, reason: "Process is busy" });
+                if (session.provider === "codex" &&
+                    !session.process.isWaitingForInput) {
+                    this.send(ws, {
+                        type: "input_rejected",
+                        sessionId: session.id,
+                        reason: "Process is busy",
+                    });
                     break;
                 }
                 // Snapshot busy state before dispatch. We prefer the actual enqueue
@@ -522,20 +548,28 @@ export class BridgeWebSocketServer {
                 // Persist images to Gallery Store asynchronously (fire-and-forget)
                 if (images.length > 0 && this.galleryStore && session.projectPath) {
                     for (const img of images) {
-                        this.galleryStore.addImageFromBase64(img.base64, img.mimeType, session.projectPath, msg.sessionId).catch((err) => {
+                        this.galleryStore
+                            .addImageFromBase64(img.base64, img.mimeType, session.projectPath, msg.sessionId)
+                            .catch((err) => {
                             console.warn(`[ws] Failed to persist image to gallery: ${err}`);
                         });
                     }
                 }
                 // Codex input path
                 if (session.provider === "codex") {
-                    this.send(ws, { type: "input_ack", sessionId: session.id, queued: false });
+                    this.send(ws, {
+                        type: "input_ack",
+                        sessionId: session.id,
+                        queued: false,
+                    });
                     const codexProc = session.process;
                     if (images.length > 0) {
                         codexProc.sendInputWithImages(text, images);
                     }
                     else if (msg.imageId && this.galleryStore) {
-                        this.galleryStore.getImageAsBase64(msg.imageId).then((imageData) => {
+                        this.galleryStore
+                            .getImageAsBase64(msg.imageId)
+                            .then((imageData) => {
                             if (imageData) {
                                 codexProc.sendInputWithImages(text, [imageData]);
                             }
@@ -543,7 +577,8 @@ export class BridgeWebSocketServer {
                                 console.warn(`[ws] Image not found: ${msg.imageId}`);
                                 codexProc.sendInput(text);
                             }
-                        }).catch((err) => {
+                        })
+                            .catch((err) => {
                             console.error(`[ws] Failed to load image: ${err}`);
                             codexProc.sendInput(text);
                         });
@@ -562,7 +597,8 @@ export class BridgeWebSocketServer {
                 if (images.length > 0) {
                     console.log(`[ws] Sending message with ${images.length} inline Base64 image(s)`);
                     const result = claudeProc.sendInputWithImages(text, images);
-                    wasQueued = typeof result === "boolean" ? result : isAgentBusySnapshot;
+                    wasQueued =
+                        typeof result === "boolean" ? result : isAgentBusySnapshot;
                 }
                 // Legacy imageId mode (backward compatibility)
                 else if (msg.imageId && this.galleryStore) {
@@ -571,22 +607,29 @@ export class BridgeWebSocketServer {
                         sessionId: session.id,
                         queued: isAgentBusySnapshot,
                     });
-                    this.galleryStore.getImageAsBase64(msg.imageId).then((imageData) => {
+                    this.galleryStore
+                        .getImageAsBase64(msg.imageId)
+                        .then((imageData) => {
                         let queuedAfterResolve = false;
                         if (imageData) {
-                            const result = claudeProc.sendInputWithImages(text, [imageData]);
-                            queuedAfterResolve = typeof result === "boolean" ? result : isAgentBusySnapshot;
+                            const result = claudeProc.sendInputWithImages(text, [
+                                imageData,
+                            ]);
+                            queuedAfterResolve =
+                                typeof result === "boolean" ? result : isAgentBusySnapshot;
                         }
                         else {
                             console.warn(`[ws] Image not found: ${msg.imageId}`);
                             const result = session.process.sendInput(text);
-                            queuedAfterResolve = typeof result === "boolean" ? result : isAgentBusySnapshot;
+                            queuedAfterResolve =
+                                typeof result === "boolean" ? result : isAgentBusySnapshot;
                         }
                         if (queuedAfterResolve) {
                             console.log(`[ws] Agent is busy — will queue input and interrupt current turn`);
                             claudeProc.interrupt();
                         }
-                    }).catch((err) => {
+                    })
+                        .catch((err) => {
                         console.error(`[ws] Failed to load image: ${err}`);
                         const result = session.process.sendInput(text);
                         const queuedAfterResolve = typeof result === "boolean" ? result : isAgentBusySnapshot;
@@ -600,12 +643,17 @@ export class BridgeWebSocketServer {
                 // Text-only message
                 else {
                     const result = session.process.sendInput(text);
-                    wasQueued = typeof result === "boolean" ? result : isAgentBusySnapshot;
+                    wasQueued =
+                        typeof result === "boolean" ? result : isAgentBusySnapshot;
                 }
                 // Acknowledge receipt so the client can mark the message state.
                 // queued=true means the input was enqueued instead of being consumed
                 // immediately by the SDK stream.
-                this.send(ws, { type: "input_ack", sessionId: session.id, queued: wasQueued });
+                this.send(ws, {
+                    type: "input_ack",
+                    sessionId: session.id,
+                    queued: wasQueued,
+                });
                 if (wasQueued) {
                     console.log(`[ws] Agent is busy — will queue input and interrupt current turn`);
                     claudeProc.interrupt();
@@ -617,34 +665,52 @@ export class BridgeWebSocketServer {
                 const privacyMode = msg.privacyMode === true;
                 console.log(`[ws] push_register received (platform: ${msg.platform}, locale: ${locale}, privacy: ${privacyMode}, configured: ${this.pushRelay.isConfigured})`);
                 if (!this.pushRelay.isConfigured) {
-                    this.send(ws, { type: "error", message: "Push relay is not configured on bridge" });
+                    this.send(ws, {
+                        type: "error",
+                        message: "Push relay is not configured on bridge",
+                    });
                     return;
                 }
                 this.tokenLocales.set(msg.token, locale);
                 this.tokenPrivacyMode.set(msg.token, privacyMode);
-                this.pushRelay.registerToken(msg.token, msg.platform, locale).then(() => {
+                this.pushRelay
+                    .registerToken(msg.token, msg.platform, locale)
+                    .then(() => {
                     console.log("[ws] push_register: token registered successfully");
-                }).catch((err) => {
+                })
+                    .catch((err) => {
                     const detail = err instanceof Error ? err.message : String(err);
                     console.error(`[ws] push_register failed: ${detail}`);
-                    this.send(ws, { type: "error", message: `Failed to register push token: ${detail}` });
+                    this.send(ws, {
+                        type: "error",
+                        message: `Failed to register push token: ${detail}`,
+                    });
                 });
                 break;
             }
             case "push_unregister": {
                 console.log("[ws] push_unregister received");
                 if (!this.pushRelay.isConfigured) {
-                    this.send(ws, { type: "error", message: "Push relay is not configured on bridge" });
+                    this.send(ws, {
+                        type: "error",
+                        message: "Push relay is not configured on bridge",
+                    });
                     return;
                 }
                 this.tokenLocales.delete(msg.token);
                 this.tokenPrivacyMode.delete(msg.token);
-                this.pushRelay.unregisterToken(msg.token).then(() => {
+                this.pushRelay
+                    .unregisterToken(msg.token)
+                    .then(() => {
                     console.log("[ws] push_unregister: token unregistered successfully");
-                }).catch((err) => {
+                })
+                    .catch((err) => {
                     const detail = err instanceof Error ? err.message : String(err);
                     console.error(`[ws] push_unregister failed: ${detail}`);
-                    this.send(ws, { type: "error", message: `Failed to unregister push token: ${detail}` });
+                    this.send(ws, {
+                        type: "error",
+                        message: `Failed to unregister push token: ${detail}`,
+                    });
                 });
                 break;
             }
@@ -677,10 +743,15 @@ export class BridgeWebSocketServer {
                     });
                     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) {
+                    const newCollaboration = planMode
+                        ? "plan"
+                        : "default";
+                    const currentApproval = session.process
+                        .approvalPolicy;
+                    const currentCollaboration = session.process
+                        .collaborationMode;
+                    if (newApproval === currentApproval &&
+                        newCollaboration === currentCollaboration) {
                         break; // No change needed
                     }
                     const canApplyModeInPlace = session.status === "idle";
@@ -721,9 +792,12 @@ export class BridgeWebSocketServer {
                     const sessionName = session.name;
                     this.sessionManager.destroy(oldSessionId);
                     console.log(`[ws] Permission mode change: destroyed session ${oldSessionId}`);
-                    const hasUserMessages = session.history?.some((m) => m.type === "user_input" || m.type === "assistant") || (session.pastMessages && session.pastMessages.length > 0);
+                    const hasUserMessages = session.history?.some((m) => m.type === "user_input" || m.type === "assistant") ||
+                        (session.pastMessages && session.pastMessages.length > 0);
                     if (!threadId || !hasUserMessages) {
-                        const newId = this.sessionManager.create(projectPath, undefined, undefined, worktreePath ? { existingWorktreePath: worktreePath, worktreeBranch } : undefined, "codex", {
+                        const newId = this.sessionManager.create(projectPath, undefined, undefined, worktreePath
+                            ? { existingWorktreePath: worktreePath, worktreeBranch }
+                            : undefined, "codex", {
                             approvalPolicy: newApproval,
                             sandboxMode: oldSettings.sandboxMode,
                             model: oldSettings.model,
@@ -758,16 +832,26 @@ export class BridgeWebSocketServer {
                     let worktreeOpts;
                     if (wtMapping) {
                         if (worktreeExists(wtMapping.worktreePath)) {
-                            worktreeOpts = { existingWorktreePath: wtMapping.worktreePath, worktreeBranch: wtMapping.worktreeBranch };
+                            worktreeOpts = {
+                                existingWorktreePath: wtMapping.worktreePath,
+                                worktreeBranch: wtMapping.worktreeBranch,
+                            };
                         }
                         else {
-                            worktreeOpts = { useWorktree: true, worktreeBranch: wtMapping.worktreeBranch };
+                            worktreeOpts = {
+                                useWorktree: true,
+                                worktreeBranch: wtMapping.worktreeBranch,
+                            };
                         }
                     }
                     else if (worktreePath) {
-                        worktreeOpts = { existingWorktreePath: worktreePath, worktreeBranch };
+                        worktreeOpts = {
+                            existingWorktreePath: worktreePath,
+                            worktreeBranch,
+                        };
                     }
-                    getCodexSessionHistory(threadId).then((pastMessages) => {
+                    getCodexSessionHistory(threadId)
+                        .then((pastMessages) => {
                         const newId = this.sessionManager.create(effectiveProjectPath, undefined, pastMessages, worktreeOpts, "codex", {
                             threadId,
                             approvalPolicy: newApproval,
@@ -806,12 +890,18 @@ export class BridgeWebSocketServer {
                             detail: `mode=${msg.mode} approval=${newApproval} collaboration=${newCollaboration} thread=${threadId} oldSession=${oldSessionId}`,
                         });
                         console.log(`[ws] Permission mode change: created new session ${newId} (thread=${threadId}, mode=${msg.mode})`);
-                    }).catch((err) => {
-                        this.send(ws, { type: "error", message: `Failed to restart session for permission mode change: ${err}` });
+                    })
+                        .catch((err) => {
+                        this.send(ws, {
+                            type: "error",
+                            message: `Failed to restart session for permission mode change: ${err}`,
+                        });
                     });
                     break;
                 }
-                session.process.setPermissionMode(msg.mode).catch((err) => {
+                session.process
+                    .setPermissionMode(msg.mode)
+                    .catch((err) => {
                     this.send(ws, {
                         type: "error",
                         message: `Failed to set permission mode: ${err instanceof Error ? err.message : String(err)}`,
@@ -834,7 +924,10 @@ export class BridgeWebSocketServer {
                     return;
                 }
                 if (msg.sandboxMode !== "on" && msg.sandboxMode !== "off") {
-                    this.send(ws, { type: "error", message: `Invalid sandbox mode: ${msg.sandboxMode}` });
+                    this.send(ws, {
+                        type: "error",
+                        message: `Invalid sandbox mode: ${msg.sandboxMode}`,
+                    });
                     return;
                 }
                 // ---- Claude sandbox toggle ----
@@ -859,7 +952,9 @@ export class BridgeWebSocketServer {
                         permissionMode,
                         model,
                         sandboxEnabled: newEnabled,
-                    }, undefined, worktreePath ? { existingWorktreePath: worktreePath, worktreeBranch } : undefined, "claude");
+                    }, undefined, worktreePath
+                        ? { existingWorktreePath: worktreePath, worktreeBranch }
+                        : undefined, "claude");
                     const newSession = this.sessionManager.get(newId);
                     if (newSession && sessionName)
                         newSession.name = sessionName;
@@ -901,7 +996,8 @@ export class BridgeWebSocketServer {
                 const worktreePath = session.worktreePath;
                 const worktreeBranch = session.worktreeBranch;
                 const sessionName = session.name;
-                const collaborationMode = session.process.collaborationMode;
+                const collaborationMode = session.process
+                    .collaborationMode;
                 const executionMode = oldSettings.approvalPolicy === "never" ? "fullAccess" : "default";
                 const planMode = collaborationMode === "plan";
                 const legacyPermissionMode = modesToLegacyPermissionMode("codex", executionMode, planMode);
@@ -911,13 +1007,16 @@ export class BridgeWebSocketServer {
                 // session.history always contains system events (init, status, etc.)
                 // even before the first user turn, so we check for user_input/assistant
                 // messages specifically.
-                const hasUserMessages = session.history?.some((m) => m.type === "user_input" || m.type === "assistant") || (session.pastMessages && session.pastMessages.length > 0);
+                const hasUserMessages = session.history?.some((m) => m.type === "user_input" || m.type === "assistant") ||
+                    (session.pastMessages && session.pastMessages.length > 0);
                 if (!threadId || !hasUserMessages) {
                     // Session has no thread yet, or has a thread but no messages exchanged.
                     // Create a fresh session with the new sandbox — no resume needed.
                     // (A thread with no messages cannot be resumed — Codex returns
                     // "no rollout found for thread id".)
-                    const newId = this.sessionManager.create(projectPath, undefined, undefined, worktreePath ? { existingWorktreePath: worktreePath, worktreeBranch } : undefined, "codex", {
+                    const newId = this.sessionManager.create(projectPath, undefined, undefined, worktreePath
+                        ? { existingWorktreePath: worktreePath, worktreeBranch }
+                        : undefined, "codex", {
                         approvalPolicy: oldSettings.approvalPolicy,
                         sandboxMode: newSandboxMode,
                         model: oldSettings.model,
@@ -950,16 +1049,23 @@ export class BridgeWebSocketServer {
                 let worktreeOpts;
                 if (wtMapping) {
                     if (worktreeExists(wtMapping.worktreePath)) {
-                        worktreeOpts = { existingWorktreePath: wtMapping.worktreePath, worktreeBranch: wtMapping.worktreeBranch };
+                        worktreeOpts = {
+                            existingWorktreePath: wtMapping.worktreePath,
+                            worktreeBranch: wtMapping.worktreeBranch,
+                        };
                     }
                     else {
-                        worktreeOpts = { useWorktree: true, worktreeBranch: wtMapping.worktreeBranch };
+                        worktreeOpts = {
+                            useWorktree: true,
+                            worktreeBranch: wtMapping.worktreeBranch,
+                        };
                     }
                 }
                 else if (worktreePath) {
                     worktreeOpts = { existingWorktreePath: worktreePath, worktreeBranch };
                 }
-                getCodexSessionHistory(threadId).then((pastMessages) => {
+                getCodexSessionHistory(threadId)
+                    .then((pastMessages) => {
                     const newId = this.sessionManager.create(effectiveProjectPath, undefined, pastMessages, worktreeOpts, "codex", {
                         threadId,
                         approvalPolicy: oldSettings.approvalPolicy,
@@ -997,8 +1103,12 @@ export class BridgeWebSocketServer {
                         detail: `sandbox=${newSandboxMode} thread=${threadId} oldSession=${oldSessionId}`,
                     });
                     console.log(`[ws] Sandbox mode change: created new session ${newId} (thread=${threadId}, sandbox=${newSandboxMode})`);
-                }).catch((err) => {
-                    this.send(ws, { type: "error", message: `Failed to restart session for sandbox mode change: ${err}` });
+                })
+                    .catch((err) => {
+                    this.send(ws, {
+                        type: "error",
+                        message: `Failed to restart session for sandbox mode change: ${err}`,
+                    });
                 });
                 break;
             }
@@ -1043,7 +1153,9 @@ export class BridgeWebSocketServer {
                             : {}),
                         permissionMode,
                         initialInput: planText || undefined,
-                    }, undefined, worktreePath ? { existingWorktreePath: worktreePath, worktreeBranch } : undefined);
+                    }, undefined, worktreePath
+                        ? { existingWorktreePath: worktreePath, worktreeBranch }
+                        : undefined);
                     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);
@@ -1126,7 +1238,10 @@ export class BridgeWebSocketServer {
                     this.sendSessionList(ws);
                 }
                 else {
-                    this.send(ws, { type: "error", message: `Session ${msg.sessionId} not found` });
+                    this.send(ws, {
+                        type: "error",
+                        message: `Session ${msg.sessionId} not found`,
+                    });
                 }
                 break;
             }
@@ -1142,8 +1257,16 @@ export class BridgeWebSocketServer {
                             messages: session.pastMessages,
                         });
                     }
-                    this.send(ws, { type: "history", messages: session.history, sessionId: msg.sessionId });
-                    this.send(ws, { type: "status", status: session.status, sessionId: msg.sessionId });
+                    this.send(ws, {
+                        type: "history",
+                        messages: session.history,
+                        sessionId: msg.sessionId,
+                    });
+                    this.send(ws, {
+                        type: "status",
+                        status: session.status,
+                        sessionId: msg.sessionId,
+                    });
                     // Send cached slash commands so the client can restore them even when
                     // the original init/supported_commands message was evicted from the
                     // in-memory history (MAX_HISTORY_PER_SESSION overflow).
@@ -1155,12 +1278,17 @@ export class BridgeWebSocketServer {
                             sessionId: msg.sessionId,
                             slashCommands: cached.slashCommands,
                             skills: cached.skills,
-                            ...(cached.skillMetadata ? { skillMetadata: cached.skillMetadata } : {}),
+                            ...(cached.skillMetadata
+                                ? { skillMetadata: cached.skillMetadata }
+                                : {}),
                         });
                     }
                 }
                 else {
-                    this.send(ws, { type: "error", message: `Session ${msg.sessionId} not found` });
+                    this.send(ws, {
+                        type: "error",
+                        message: `Session ${msg.sessionId} not found`,
+                    });
                 }
                 break;
             }
@@ -1171,10 +1299,13 @@ export class BridgeWebSocketServer {
                     let branch = "";
                     try {
                         branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-                            cwd, encoding: "utf-8",
+                            cwd,
+                            encoding: "utf-8",
                         }).trim();
                     }
-                    catch { /* not a git repo */ }
+                    catch {
+                        /* not a git repo */
+                    }
                     // Update stored branch so future session_list responses are also current
                     session.gitBranch = branch;
                     this.send(ws, {
@@ -1184,14 +1315,20 @@ export class BridgeWebSocketServer {
                     });
                 }
                 else {
-                    this.send(ws, { type: "error", message: `Session ${msg.sessionId} not found` });
+                    this.send(ws, {
+                        type: "error",
+                        message: `Session ${msg.sessionId} not found`,
+                    });
                 }
                 break;
             }
             case "get_debug_bundle": {
                 const session = this.sessionManager.get(msg.sessionId);
                 if (!session) {
-                    this.send(ws, { type: "error", message: `Session ${msg.sessionId} not found` });
+                    this.send(ws, {
+                        type: "error",
+                        message: `Session ${msg.sessionId} not found`,
+                    });
                     return;
                 }
                 const emitBundle = (diff, diffError) => {
@@ -1239,30 +1376,46 @@ export class BridgeWebSocketServer {
                 break;
             }
             case "get_usage": {
-                fetchAllUsage().then((providers) => {
+                fetchAllUsage()
+                    .then((providers) => {
                     this.send(ws, { type: "usage_result", providers });
-                }).catch((err) => {
-                    this.send(ws, { type: "error", message: `Failed to fetch usage: ${err}` });
+                })
+                    .catch((err) => {
+                    this.send(ws, {
+                        type: "error",
+                        message: `Failed to fetch usage: ${err}`,
+                    });
                 });
                 break;
             }
             case "list_recent_sessions": {
                 const requestId = ++this.recentSessionsRequestId;
-                this.listRecentSessions(msg).then(({ sessions, hasMore }) => {
+                this.listRecentSessions(msg)
+                    .then(({ sessions, hasMore }) => {
                     // Drop stale responses when rapid filter switches cause out-of-order completion
                     if (requestId !== this.recentSessionsRequestId)
                         return;
-                    this.send(ws, { type: "recent_sessions", sessions, hasMore });
-                }).catch((err) => {
+                    this.send(ws, {
+                        type: "recent_sessions",
+                        sessions,
+                        hasMore,
+                    });
+                })
+                    .catch((err) => {
                     if (requestId !== this.recentSessionsRequestId)
                         return;
-                    this.send(ws, { type: "error", message: `Failed to list recent sessions: ${err}` });
+                    this.send(ws, {
+                        type: "error",
+                        message: `Failed to list recent sessions: ${err}`,
+                    });
                 });
                 break;
             }
             case "archive_session": {
                 const { sessionId, provider, projectPath } = msg;
-                this.archiveStore.archive(sessionId, provider, projectPath).then(() => {
+                this.archiveStore
+                    .archive(sessionId, provider, projectPath)
+                    .then(() => {
                     // For Codex sessions, also call thread/archive RPC (best-effort).
                     // Requires a running Codex app-server process; skip if none active.
                     if (provider === "codex") {
@@ -1271,7 +1424,9 @@ export class BridgeWebSocketServer {
                         if (codexSession) {
                             const session = this.sessionManager.get(codexSession.id);
                             if (session) {
-                                session.process.archiveThread(sessionId).catch((err) => {
+                                session.process
+                                    .archiveThread(sessionId)
+                                    .catch((err) => {
                                     console.warn(`[ws] Codex thread/archive failed (non-fatal): ${err}`);
                                 });
                             }
@@ -1282,7 +1437,8 @@ export class BridgeWebSocketServer {
                         sessionId,
                         success: true,
                     });
-                }).catch((err) => {
+                })
+                    .catch((err) => {
                     this.send(ws, {
                         type: "archive_result",
                         sessionId,
@@ -1330,7 +1486,8 @@ export class BridgeWebSocketServer {
                             };
                         }
                     }
-                    getCodexSessionHistory(sessionRefId).then((pastMessages) => {
+                    getCodexSessionHistory(sessionRefId)
+                        .then((pastMessages) => {
                         const sessionId = this.sessionManager.create(effectiveProjectPath, undefined, pastMessages, worktreeOpts, "codex", {
                             threadId: sessionRefId,
                             approvalPolicy: executionMode === "fullAccess" ? "never" : "on-request",
@@ -1338,8 +1495,11 @@ export class BridgeWebSocketServer {
                             model: msg.model,
                             modelReasoningEffort: msg.modelReasoningEffort ?? undefined,
                             networkAccessEnabled: msg.networkAccessEnabled,
-                            webSearchMode: msg.webSearchMode ?? undefined,
-                            collaborationMode: planMode ? "plan" : "default",
+                            webSearchMode: msg.webSearchMode ??
+                                undefined,
+                            collaborationMode: planMode
+                                ? "plan"
+                                : "default",
                         });
                         const createdSession = this.sessionManager.get(sessionId);
                         void this.loadAndSetSessionName(createdSession, "codex", effectiveProjectPath, sessionRefId).then(() => {
@@ -1365,8 +1525,12 @@ export class BridgeWebSocketServer {
                             detail: `provider=codex thread=${sessionRefId}`,
                         });
                         this.projectHistory?.addProject(effectiveProjectPath);
-                    }).catch((err) => {
-                        this.send(ws, { type: "error", message: `Failed to load Codex session history: ${err}` });
+                    })
+                        .catch((err) => {
+                        this.send(ws, {
+                            type: "error",
+                            message: `Failed to load Codex session history: ${err}`,
+                        });
                     });
                     break;
                 }
@@ -1385,10 +1549,14 @@ export class BridgeWebSocketServer {
                     }
                     else {
                         // Worktree was deleted — recreate on the same branch
-                        worktreeOpts = { useWorktree: true, worktreeBranch: wtMapping.worktreeBranch };
+                        worktreeOpts = {
+                            useWorktree: true,
+                            worktreeBranch: wtMapping.worktreeBranch,
+                        };
                     }
                 }
-                getSessionHistory(claudeSessionId).then((pastMessages) => {
+                getSessionHistory(claudeSessionId)
+                    .then((pastMessages) => {
                     const sessionId = this.sessionManager.create(msg.projectPath, {
                         sessionId: claudeSessionId,
                         permissionMode: legacyPermissionMode,
@@ -1399,7 +1567,9 @@ export class BridgeWebSocketServer {
                         fallbackModel: msg.fallbackModel,
                         forkSession: msg.forkSession,
                         persistSession: msg.persistSession,
-                        ...(msg.sandboxMode ? { sandboxEnabled: msg.sandboxMode === "on" } : {}),
+                        ...(msg.sandboxMode
+                            ? { sandboxEnabled: msg.sandboxMode === "on" }
+                            : {}),
                     }, pastMessages, worktreeOpts);
                     const createdSession = this.sessionManager.get(sessionId);
                     void this.loadAndSetSessionName(createdSession, "claude", msg.projectPath, claudeSessionId).then(() => {
@@ -1435,8 +1605,12 @@ export class BridgeWebSocketServer {
                         detail: `provider=claude session=${claudeSessionId}`,
                     });
                     this.projectHistory?.addProject(msg.projectPath);
-                }).catch((err) => {
-                    this.send(ws, { type: "error", message: `Failed to load session history: ${err}` });
+                })
+                    .catch((err) => {
+                    this.send(ws, {
+                        type: "error",
+                        message: `Failed to load session history: ${err}`,
+                    });
                 });
                 break;
             }
@@ -1454,7 +1628,8 @@ export class BridgeWebSocketServer {
                 break;
             }
             case "get_message_images": {
-                void extractMessageImages(msg.claudeSessionId, msg.messageUuid).then((images) => {
+                void extractMessageImages(msg.claudeSessionId, msg.messageUuid)
+                    .then((images) => {
                     const refs = [];
                     if (this.imageStore) {
                         for (const img of images) {
@@ -1463,10 +1638,19 @@ export class BridgeWebSocketServer {
                                 refs.push(ref);
                         }
                     }
-                    this.send(ws, { type: "message_images_result", messageUuid: msg.messageUuid, images: refs });
-                }).catch((err) => {
+                    this.send(ws, {
+                        type: "message_images_result",
+                        messageUuid: msg.messageUuid,
+                        images: refs,
+                    });
+                })
+                    .catch((err) => {
                     console.error("[ws] Failed to extract message images:", err);
-                    this.send(ws, { type: "message_images_result", messageUuid: msg.messageUuid, images: [] });
+                    this.send(ws, {
+                        type: "message_images_result",
+                        messageUuid: msg.messageUuid,
+                        images: [],
+                    });
                 });
                 break;
             }
@@ -1490,6 +1674,93 @@ export class BridgeWebSocketServer {
                 this.send(ws, { type: "project_history", projects });
                 break;
             }
+            case "read_file": {
+                const absPath = resolve(msg.projectPath, msg.filePath);
+                if (!this.isPathAllowed(absPath)) {
+                    this.send(ws, {
+                        type: "file_content",
+                        filePath: msg.filePath,
+                        content: "",
+                        error: "Path not allowed",
+                    });
+                    break;
+                }
+                void (async () => {
+                    try {
+                        if (!existsSync(absPath)) {
+                            this.send(ws, {
+                                type: "file_content",
+                                filePath: msg.filePath,
+                                content: "",
+                                error: "File not found",
+                            });
+                            return;
+                        }
+                        const maxLines = typeof msg.maxLines === "number" && msg.maxLines > 0
+                            ? msg.maxLines
+                            : 5000;
+                        const raw = await readFile(absPath, "utf-8");
+                        const ext = extname(absPath).replace(/^\./, "").toLowerCase();
+                        const languageMap = {
+                            ts: "typescript",
+                            tsx: "typescript",
+                            js: "javascript",
+                            jsx: "javascript",
+                            py: "python",
+                            rb: "ruby",
+                            rs: "rust",
+                            go: "go",
+                            java: "java",
+                            kt: "kotlin",
+                            swift: "swift",
+                            dart: "dart",
+                            c: "c",
+                            cpp: "cpp",
+                            h: "c",
+                            hpp: "cpp",
+                            cs: "csharp",
+                            sh: "bash",
+                            zsh: "bash",
+                            yml: "yaml",
+                            yaml: "yaml",
+                            json: "json",
+                            toml: "toml",
+                            md: "markdown",
+                            html: "html",
+                            css: "css",
+                            scss: "css",
+                            sql: "sql",
+                            xml: "xml",
+                            dockerfile: "dockerfile",
+                            makefile: "makefile",
+                            gradle: "groovy",
+                        };
+                        const language = languageMap[ext] ?? (ext || undefined);
+                        const lines = raw.split("\n");
+                        const truncated = lines.length > maxLines;
+                        const content = truncated
+                            ? lines.slice(0, maxLines).join("\n")
+                            : raw;
+                        this.send(ws, {
+                            type: "file_content",
+                            filePath: msg.filePath,
+                            content,
+                            language,
+                            totalLines: lines.length,
+                            truncated,
+                        });
+                    }
+                    catch (err) {
+                        this.send(ws, {
+                            type: "file_content",
+                            filePath: msg.filePath,
+                            content: "",
+                            error: `Failed to read file: ${err}`,
+                        });
+                    }
+                })();
+                break;
+            }
             case "list_files": {
                 if (!this.isPathAllowed(msg.projectPath)) {
                     this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
@@ -1502,7 +1773,10 @@ export class BridgeWebSocketServer {
                             this.send(ws, { type: "file_list", files: [] });
                         }
                         else {
-                            this.send(ws, { type: "error", message: `Failed to list files: ${err.message}` });
+                            this.send(ws, {
+                                type: "error",
+                                message: `Failed to list files: ${err.message}`,
+                            });
                         }
                         return;
                     }
@@ -1568,15 +1842,27 @@ export class BridgeWebSocketServer {
             }
             case "get_recording": {
                 if (!this.recordingStore) {
-                    this.send(ws, { type: "error", message: "Recording is not enabled on this server" });
+                    this.send(ws, {
+                        type: "error",
+                        message: "Recording is not enabled on this server",
+                    });
                     break;
                 }
-                void this.recordingStore.getRecordingContent(msg.sessionId).then((content) => {
+                void this.recordingStore
+                    .getRecordingContent(msg.sessionId)
+                    .then((content) => {
                     if (content !== null) {
-                        this.send(ws, { type: "recording_content", sessionId: msg.sessionId, content });
+                        this.send(ws, {
+                            type: "recording_content",
+                            sessionId: msg.sessionId,
+                            content,
+                        });
                     }
                     else {
-                        this.send(ws, { type: "error", message: `Recording ${msg.sessionId} not found` });
+                        this.send(ws, {
+                            type: "error",
+                            message: `Recording ${msg.sessionId} not found`,
+                        });
                     }
                 });
                 break;
@@ -1597,7 +1883,11 @@ export class BridgeWebSocketServer {
                             });
                         }
                         else {
-                            this.send(ws, { type: "diff_result", diff: "", error: `Failed to get diff: ${error}` });
+                            this.send(ws, {
+                                type: "diff_result",
+                                diff: "",
+                                error: `Failed to get diff: ${error}`,
+                            });
                         }
                         return;
                     }
@@ -1609,11 +1899,16 @@ export class BridgeWebSocketServer {
                             this.send(ws, { type: "diff_result", diff });
                         }
                     });
-                });
+                }, msg.staged === true
+                    ? { staged: true }
+                    : msg.staged === false
+                        ? { unstaged: true }
+                        : undefined);
                 break;
             }
             case "get_diff_image": {
-                if (!this.isPathAllowed(msg.projectPath) || !this.isPathAllowed(resolve(msg.projectPath, msg.filePath))) {
+                if (!this.isPathAllowed(msg.projectPath) ||
+                    !this.isPathAllowed(resolve(msg.projectPath, msg.filePath))) {
                     this.send(ws, { type: "error", message: `Path not allowed` });
                     break;
                 }
@@ -1645,7 +1940,12 @@ export class BridgeWebSocketServer {
                     void (async () => {
                         try {
                             const result = await this.loadDiffImageAsync(msg.projectPath, msg.filePath, version);
-                            this.send(ws, { type: "diff_image_result", filePath: msg.filePath, version, ...result });
+                            this.send(ws, {
+                                type: "diff_image_result",
+                                filePath: msg.filePath,
+                                version,
+                                ...result,
+                            });
                         }
                         catch {
                             // WebSocket may have closed; ignore send errors.
@@ -1665,7 +1965,10 @@ export class BridgeWebSocketServer {
                     this.send(ws, { type: "worktree_list", worktrees, mainBranch });
                 }
                 catch (err) {
-                    this.send(ws, { type: "error", message: `Failed to list worktrees: ${err}` });
+                    this.send(ws, {
+                        type: "error",
+                        message: `Failed to list worktrees: ${err}`,
+                    });
                 }
                 break;
             }
@@ -1677,20 +1980,334 @@ export class BridgeWebSocketServer {
                 try {
                     removeWorktree(msg.projectPath, msg.worktreePath);
                     this.worktreeStore.deleteByWorktreePath(msg.worktreePath);
-                    this.send(ws, { type: "worktree_removed", worktreePath: msg.worktreePath });
+                    this.send(ws, {
+                        type: "worktree_removed",
+                        worktreePath: msg.worktreePath,
+                    });
                 }
                 catch (err) {
-                    this.send(ws, { type: "error", message: `Failed to remove worktree: ${err}` });
+                    this.send(ws, {
+                        type: "error",
+                        message: `Failed to remove worktree: ${err}`,
+                    });
+                }
+                break;
+            }
+            // ---- Git Operations (Phase 1-3) ----
+            case "git_stage": {
+                if (!this.isPathAllowed(msg.projectPath)) {
+                    this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
+                    break;
+                }
+                try {
+                    if (msg.files?.length)
+                        stageFiles(msg.projectPath, msg.files);
+                    if (msg.hunks?.length)
+                        stageHunks(msg.projectPath, msg.hunks);
+                    this.send(ws, { type: "git_stage_result", success: true });
+                }
+                catch (err) {
+                    this.send(ws, {
+                        type: "git_stage_result",
+                        success: false,
+                        error: String(err),
+                    });
+                }
+                break;
+            }
+            case "git_unstage": {
+                if (!this.isPathAllowed(msg.projectPath)) {
+                    this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
+                    break;
+                }
+                try {
+                    unstageFiles(msg.projectPath, msg.files ?? []);
+                    this.send(ws, { type: "git_unstage_result", success: true });
+                }
+                catch (err) {
+                    this.send(ws, {
+                        type: "git_unstage_result",
+                        success: false,
+                        error: String(err),
+                    });
+                }
+                break;
+            }
+            case "git_unstage_hunks": {
+                if (!this.isPathAllowed(msg.projectPath)) {
+                    this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
+                    break;
+                }
+                try {
+                    unstageHunks(msg.projectPath, msg.hunks);
+                    this.send(ws, { type: "git_unstage_hunks_result", success: true });
+                }
+                catch (err) {
+                    this.send(ws, {
+                        type: "git_unstage_hunks_result",
+                        success: false,
+                        error: String(err),
+                    });
+                }
+                break;
+            }
+            case "git_commit": {
+                if (!this.isPathAllowed(msg.projectPath)) {
+                    this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
+                    break;
+                }
+                const session = msg.sessionId
+                    ? this.sessionManager.get(msg.sessionId)
+                    : undefined;
+                try {
+                    const message = msg.autoGenerate === true
+                        ? (() => {
+                            if (!msg.sessionId) {
+                                throw new Error("git_commit with autoGenerate=true requires sessionId");
+                            }
+                            if (!session) {
+                                throw new Error(`Session ${msg.sessionId} not found`);
+                            }
+                            const expectedPath = resolve(session.worktreePath ?? session.projectPath);
+                            const requestedPath = resolve(msg.projectPath);
+                            if (requestedPath !== expectedPath) {
+                                throw new Error("git_commit projectPath must match the active session cwd");
+                            }
+                            return generateCommitMessage({
+                                provider: session.provider,
+                                projectPath: msg.projectPath,
+                                model: session.provider === "claude"
+                                    ? session.process instanceof SdkProcess
+                                        ? session.process.model
+                                        : undefined
+                                    : session.codexSettings?.model,
+                            });
+                        })()
+                        : msg.message ?? "";
+                    const result = gitCommit(msg.projectPath, message);
+                    this.send(ws, {
+                        type: "git_commit_result",
+                        success: true,
+                        commitHash: result.hash,
+                        message: result.message,
+                    });
+                }
+                catch (err) {
+                    this.send(ws, {
+                        type: "git_commit_result",
+                        success: false,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                break;
+            }
+            case "git_push": {
+                if (!this.isPathAllowed(msg.projectPath)) {
+                    this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
+                    break;
+                }
+                try {
+                    gitPush(msg.projectPath);
+                    this.send(ws, {
+                        type: "git_push_result",
+                        success: true,
+                    });
+                }
+                catch (err) {
+                    this.send(ws, {
+                        type: "git_push_result",
+                        success: false,
+                        error: String(err),
+                    });
+                }
+                break;
+            }
+            case "git_branches": {
+                if (!this.isPathAllowed(msg.projectPath)) {
+                    this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
+                    break;
+                }
+                try {
+                    const result = listBranches(msg.projectPath);
+                    this.send(ws, {
+                        type: "git_branches_result",
+                        current: result.current,
+                        branches: result.branches,
+                        checkedOutBranches: result.checkedOutBranches,
+                        remoteStatusByBranch: result.remoteStatusByBranch,
+                    });
+                }
+                catch (err) {
+                    this.send(ws, {
+                        type: "git_branches_result",
+                        current: "",
+                        branches: [],
+                        remoteStatusByBranch: {},
+                        error: String(err),
+                    });
+                }
+                break;
+            }
+            case "git_create_branch": {
+                if (!this.isPathAllowed(msg.projectPath)) {
+                    this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
+                    break;
+                }
+                try {
+                    createBranch(msg.projectPath, msg.name, msg.checkout);
+                    this.send(ws, { type: "git_create_branch_result", success: true });
+                }
+                catch (err) {
+                    this.send(ws, {
+                        type: "git_create_branch_result",
+                        success: false,
+                        error: String(err),
+                    });
+                }
+                break;
+            }
+            case "git_checkout_branch": {
+                if (!this.isPathAllowed(msg.projectPath)) {
+                    this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
+                    break;
+                }
+                try {
+                    checkoutBranch(msg.projectPath, msg.branch);
+                    this.send(ws, { type: "git_checkout_branch_result", success: true });
+                }
+                catch (err) {
+                    this.send(ws, {
+                        type: "git_checkout_branch_result",
+                        success: false,
+                        error: String(err),
+                    });
+                }
+                break;
+            }
+            case "git_revert_file": {
+                if (!this.isPathAllowed(msg.projectPath)) {
+                    this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
+                    break;
+                }
+                try {
+                    revertFiles(msg.projectPath, msg.files);
+                    this.send(ws, { type: "git_revert_file_result", success: true });
+                }
+                catch (err) {
+                    this.send(ws, {
+                        type: "git_revert_file_result",
+                        success: false,
+                        error: String(err),
+                    });
+                }
+                break;
+            }
+            case "git_revert_hunks": {
+                if (!this.isPathAllowed(msg.projectPath)) {
+                    this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
+                    break;
+                }
+                try {
+                    revertHunks(msg.projectPath, msg.hunks);
+                    this.send(ws, { type: "git_revert_hunks_result", success: true });
+                }
+                catch (err) {
+                    this.send(ws, {
+                        type: "git_revert_hunks_result",
+                        success: false,
+                        error: String(err),
+                    });
+                }
+                break;
+            }
+            case "git_fetch": {
+                if (!this.isPathAllowed(msg.projectPath)) {
+                    this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
+                    break;
+                }
+                try {
+                    gitFetch(msg.projectPath);
+                    this.send(ws, { type: "git_fetch_result", success: true });
+                }
+                catch (err) {
+                    this.send(ws, {
+                        type: "git_fetch_result",
+                        success: false,
+                        error: String(err),
+                    });
+                }
+                break;
+            }
+            case "git_pull": {
+                if (!this.isPathAllowed(msg.projectPath)) {
+                    this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
+                    break;
+                }
+                try {
+                    const result = gitPull(msg.projectPath);
+                    if (result.success) {
+                        this.send(ws, {
+                            type: "git_pull_result",
+                            success: true,
+                            message: result.message,
+                        });
+                    }
+                    else {
+                        this.send(ws, {
+                            type: "git_pull_result",
+                            success: false,
+                            error: result.message,
+                        });
+                    }
+                }
+                catch (err) {
+                    this.send(ws, {
+                        type: "git_pull_result",
+                        success: false,
+                        error: String(err),
+                    });
+                }
+                break;
+            }
+            case "git_remote_status": {
+                if (!this.isPathAllowed(msg.projectPath)) {
+                    this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
+                    break;
+                }
+                try {
+                    const result = gitRemoteStatus(msg.projectPath);
+                    this.send(ws, {
+                        type: "git_remote_status_result",
+                        ahead: result.ahead,
+                        behind: result.behind,
+                        branch: result.branch,
+                        hasUpstream: result.hasUpstream,
+                    });
+                }
+                catch (err) {
+                    this.send(ws, {
+                        type: "git_remote_status_result",
+                        ahead: 0,
+                        behind: 0,
+                        branch: "",
+                        hasUpstream: false,
+                    });
                 }
                 break;
             }
             case "rewind_dry_run": {
                 const session = this.sessionManager.get(msg.sessionId);
                 if (!session) {
-                    this.send(ws, { type: "rewind_preview", canRewind: false, error: `Session ${msg.sessionId} not found` });
+                    this.send(ws, {
+                        type: "rewind_preview",
+                        canRewind: false,
+                        error: `Session ${msg.sessionId} not found`,
+                    });
                     return;
                 }
-                this.sessionManager.rewindFiles(msg.sessionId, msg.targetUuid, true).then((result) => {
+                this.sessionManager
+                    .rewindFiles(msg.sessionId, msg.targetUuid, true)
+                    .then((result) => {
                     this.send(ws, {
                         type: "rewind_preview",
                         canRewind: result.canRewind,
@@ -1699,40 +2316,73 @@ export class BridgeWebSocketServer {
                         deletions: result.deletions,
                         error: result.error,
                     });
-                }).catch((err) => {
-                    this.send(ws, { type: "rewind_preview", canRewind: false, error: `Dry run failed: ${err}` });
+                })
+                    .catch((err) => {
+                    this.send(ws, {
+                        type: "rewind_preview",
+                        canRewind: false,
+                        error: `Dry run failed: ${err}`,
+                    });
                 });
                 break;
             }
             case "rewind": {
                 const session = this.sessionManager.get(msg.sessionId);
                 if (!session) {
-                    this.send(ws, { type: "rewind_result", success: false, mode: msg.mode, error: `Session ${msg.sessionId} not found` });
+                    this.send(ws, {
+                        type: "rewind_result",
+                        success: false,
+                        mode: msg.mode,
+                        error: `Session ${msg.sessionId} not found`,
+                    });
                     return;
                 }
                 const handleError = (err) => {
                     const errMsg = err instanceof Error ? err.message : String(err);
-                    this.send(ws, { type: "rewind_result", success: false, mode: msg.mode, error: errMsg });
+                    this.send(ws, {
+                        type: "rewind_result",
+                        success: false,
+                        mode: msg.mode,
+                        error: errMsg,
+                    });
                 };
                 if (msg.mode === "code") {
                     // Code-only rewind: rewind files without restarting the conversation
-                    this.sessionManager.rewindFiles(msg.sessionId, msg.targetUuid).then((result) => {
+                    this.sessionManager
+                        .rewindFiles(msg.sessionId, msg.targetUuid)
+                        .then((result) => {
                         if (result.canRewind) {
-                            this.send(ws, { type: "rewind_result", success: true, mode: "code" });
+                            this.send(ws, {
+                                type: "rewind_result",
+                                success: true,
+                                mode: "code",
+                            });
                         }
                         else {
-                            this.send(ws, { type: "rewind_result", success: false, mode: "code", error: result.error ?? "Cannot rewind files" });
+                            this.send(ws, {
+                                type: "rewind_result",
+                                success: false,
+                                mode: "code",
+                                error: result.error ?? "Cannot rewind files",
+                            });
                         }
-                    }).catch(handleError);
+                    })
+                        .catch(handleError);
                 }
                 else if (msg.mode === "conversation") {
                     // Conversation-only rewind: restart session at the target UUID
                     try {
                         this.sessionManager.rewindConversation(msg.sessionId, msg.targetUuid, (newSessionId) => {
-                            this.send(ws, { type: "rewind_result", success: true, mode: "conversation" });
+                            this.send(ws, {
+                                type: "rewind_result",
+                                success: true,
+                                mode: "conversation",
+                            });
                             // Notify the new session ID
                             const newSession = this.sessionManager.get(newSessionId);
-                            const rewindPermMode = newSession?.process instanceof SdkProcess ? newSession.process.permissionMode : undefined;
+                            const rewindPermMode = newSession?.process instanceof SdkProcess
+                                ? newSession.process.permissionMode
+                                : undefined;
                             this.send(ws, this.buildSessionCreatedMessage({
                                 sessionId: newSessionId,
                                 provider: newSession?.provider ?? "claude",
@@ -1750,16 +2400,29 @@ export class BridgeWebSocketServer {
                 }
                 else {
                     // Both: rewind files first, then rewind conversation
-                    this.sessionManager.rewindFiles(msg.sessionId, msg.targetUuid).then((result) => {
+                    this.sessionManager
+                        .rewindFiles(msg.sessionId, msg.targetUuid)
+                        .then((result) => {
                         if (!result.canRewind) {
-                            this.send(ws, { type: "rewind_result", success: false, mode: "both", error: result.error ?? "Cannot rewind files" });
+                            this.send(ws, {
+                                type: "rewind_result",
+                                success: false,
+                                mode: "both",
+                                error: result.error ?? "Cannot rewind files",
+                            });
                             return;
                         }
                         try {
                             this.sessionManager.rewindConversation(msg.sessionId, msg.targetUuid, (newSessionId) => {
-                                this.send(ws, { type: "rewind_result", success: true, mode: "both" });
+                                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;
+                                const rewindPermMode2 = newSession?.process instanceof SdkProcess
+                                    ? newSession.process.permissionMode
+                                    : undefined;
                                 this.send(ws, this.buildSessionCreatedMessage({
                                     sessionId: newSessionId,
                                     provider: newSession?.provider ?? "claude",
@@ -1774,7 +2437,8 @@ export class BridgeWebSocketServer {
                         catch (err) {
                             handleError(err);
                         }
-                    }).catch(handleError);
+                    })
+                        .catch(handleError);
                 }
                 break;
             }
@@ -1815,7 +2479,11 @@ export class BridgeWebSocketServer {
                             const meta = await this.galleryStore.addImage(result.filePath, msg.projectPath, msg.sessionId);
                             if (meta) {
                                 const info = this.galleryStore.metaToInfo(meta);
-                                this.send(ws, { type: "screenshot_result", success: true, image: info });
+                                this.send(ws, {
+                                    type: "screenshot_result",
+                                    success: true,
+                                    image: info,
+                                });
                                 this.broadcast({ type: "gallery_new_image", image: info });
                                 return;
                             }
@@ -1842,23 +2510,44 @@ export class BridgeWebSocketServer {
             }
             case "backup_prompt_history": {
                 if (!this.promptHistoryBackup) {
-                    this.send(ws, { type: "prompt_history_backup_result", success: false, error: "Backup store not available" });
+                    this.send(ws, {
+                        type: "prompt_history_backup_result",
+                        success: false,
+                        error: "Backup store not available",
+                    });
                     break;
                 }
                 const buf = Buffer.from(msg.data, "base64");
-                this.promptHistoryBackup.save(buf, msg.appVersion, msg.dbVersion).then((meta) => {
-                    this.send(ws, { type: "prompt_history_backup_result", success: true, backedUpAt: meta.backedUpAt });
-                }).catch((err) => {
-                    this.send(ws, { type: "prompt_history_backup_result", success: false, error: err instanceof Error ? err.message : String(err) });
+                this.promptHistoryBackup
+                    .save(buf, msg.appVersion, msg.dbVersion)
+                    .then((meta) => {
+                    this.send(ws, {
+                        type: "prompt_history_backup_result",
+                        success: true,
+                        backedUpAt: meta.backedUpAt,
+                    });
+                })
+                    .catch((err) => {
+                    this.send(ws, {
+                        type: "prompt_history_backup_result",
+                        success: false,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
                 });
                 break;
             }
             case "restore_prompt_history": {
                 if (!this.promptHistoryBackup) {
-                    this.send(ws, { type: "prompt_history_restore_result", success: false, error: "Backup store not available" });
+                    this.send(ws, {
+                        type: "prompt_history_restore_result",
+                        success: false,
+                        error: "Backup store not available",
+                    });
                     break;
                 }
-                this.promptHistoryBackup.load().then((result) => {
+                this.promptHistoryBackup
+                    .load()
+                    .then((result) => {
                     if (result) {
                         this.send(ws, {
                             type: "prompt_history_restore_result",
@@ -1870,10 +2559,19 @@ export class BridgeWebSocketServer {
                         });
                     }
                     else {
-                        this.send(ws, { type: "prompt_history_restore_result", success: false, error: "No backup found" });
+                        this.send(ws, {
+                            type: "prompt_history_restore_result",
+                            success: false,
+                            error: "No backup found",
+                        });
                     }
-                }).catch((err) => {
-                    this.send(ws, { type: "prompt_history_restore_result", success: false, error: err instanceof Error ? err.message : String(err) });
+                })
+                    .catch((err) => {
+                    this.send(ws, {
+                        type: "prompt_history_restore_result",
+                        success: false,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
                 });
                 break;
             }
@@ -1882,15 +2580,28 @@ export class BridgeWebSocketServer {
                     this.send(ws, { type: "prompt_history_backup_info", exists: false });
                     break;
                 }
-                this.promptHistoryBackup.getMeta().then((meta) => {
+                this.promptHistoryBackup
+                    .getMeta()
+                    .then((meta) => {
                     if (meta) {
-                        this.send(ws, { type: "prompt_history_backup_info", exists: true, ...meta });
+                        this.send(ws, {
+                            type: "prompt_history_backup_info",
+                            exists: true,
+                            ...meta,
+                        });
                     }
                     else {
-                        this.send(ws, { type: "prompt_history_backup_info", exists: false });
+                        this.send(ws, {
+                            type: "prompt_history_backup_info",
+                            exists: false,
+                        });
                     }
-                }).catch(() => {
-                    this.send(ws, { type: "prompt_history_backup_info", exists: false });
+                })
+                    .catch(() => {
+                    this.send(ws, {
+                        type: "prompt_history_backup_info",
+                        exists: false,
+                    });
                 });
                 break;
             }
@@ -1937,10 +2648,12 @@ export class BridgeWebSocketServer {
         if (runningSession) {
             this.sessionManager.renameSession(sessionId, name);
             // Persist to provider storage
-            if (runningSession.provider === "claude" && runningSession.claudeSessionId) {
+            if (runningSession.provider === "claude" &&
+                runningSession.claudeSessionId) {
                 await renameClaudeSession(runningSession.worktreePath ?? runningSession.projectPath, runningSession.claudeSessionId, name);
             }
-            else if (runningSession.provider === "codex" && runningSession.process) {
+            else if (runningSession.provider === "codex" &&
+                runningSession.process) {
                 try {
                     await runningSession.process.renameThread(name ?? "");
                 }
@@ -1984,13 +2697,27 @@ export class BridgeWebSocketServer {
     sendSessionList(ws) {
         this.pruneDebugEvents();
         const sessions = this.sessionManager.list();
-        this.send(ws, { type: "session_list", sessions, allowedDirs: this.allowedDirs, claudeModels: CLAUDE_MODELS, codexModels: CODEX_MODELS, bridgeVersion: getPackageVersion() });
+        this.send(ws, {
+            type: "session_list",
+            sessions,
+            allowedDirs: this.allowedDirs,
+            claudeModels: CLAUDE_MODELS,
+            codexModels: CODEX_MODELS,
+            bridgeVersion: getPackageVersion(),
+        });
     }
     /** Broadcast session list to all connected clients. */
     broadcastSessionList() {
         this.pruneDebugEvents();
         const sessions = this.sessionManager.list();
-        this.broadcast({ type: "session_list", sessions, allowedDirs: this.allowedDirs, claudeModels: CLAUDE_MODELS, codexModels: CODEX_MODELS, bridgeVersion: getPackageVersion() });
+        this.broadcast({
+            type: "session_list",
+            sessions,
+            allowedDirs: this.allowedDirs,
+            claudeModels: CLAUDE_MODELS,
+            codexModels: CODEX_MODELS,
+            bridgeVersion: getPackageVersion(),
+        });
     }
     broadcastSessionMessage(sessionId, msg) {
         this.maybeSendPushNotification(sessionId, msg);
@@ -2002,7 +2729,9 @@ export class BridgeWebSocketServer {
         });
         this.recordingStore?.record(sessionId, "outgoing", msg);
         // Update recording meta with claudeSessionId when it becomes available
-        if ((msg.type === "system" || msg.type === "result") && "sessionId" in msg && msg.sessionId) {
+        if ((msg.type === "system" || msg.type === "result") &&
+            "sessionId" in msg &&
+            msg.sessionId) {
             const session = this.sessionManager.get(sessionId);
             if (session) {
                 this.recordingStore?.saveMeta(sessionId, {
@@ -2041,16 +2770,21 @@ export class BridgeWebSocketServer {
         });
     }
     getActiveCodexProcess() {
-        const summary = this.sessionManager.list().find((session) => session.provider === "codex");
+        const summary = this.sessionManager
+            .list()
+            .find((session) => session.provider === "codex");
         if (!summary)
             return null;
         const session = this.sessionManager.get(summary.id);
-        return session?.provider === "codex" ? session.process : null;
+        return session?.provider === "codex"
+            ? session.process
+            : null;
     }
     async listRecentCodexThreads(msg) {
         const limit = msg.limit ?? 20;
         const offset = msg.offset ?? 0;
-        const process = this.getActiveCodexProcess() ?? await this.createStandaloneCodexProcess(msg.projectPath);
+        const process = this.getActiveCodexProcess() ??
+            (await this.createStandaloneCodexProcess(msg.projectPath));
         const isStandalone = process !== this.getActiveCodexProcess();
         try {
             const result = await process.listThreads({
@@ -2135,7 +2869,9 @@ export class BridgeWebSocketServer {
             this.notifiedPermissionToolUses.set(sessionId, seen);
             const isAskUserQuestion = msg.toolName === "AskUserQuestion";
             const isExitPlanMode = msg.toolName === "ExitPlanMode";
-            const eventType = isAskUserQuestion ? "ask_user_question" : "approval_required";
+            const eventType = isAskUserQuestion
+                ? "ask_user_question"
+                : "approval_required";
             // Extract question text for AskUserQuestion (standard mode only)
             let questionText;
             if (!privacy && isAskUserQuestion) {
@@ -2158,30 +2894,38 @@ export class BridgeWebSocketServer {
                 let body;
                 if (isExitPlanMode) {
                     const titleKey = "plan_ready_title";
-                    title = label ? `${t(locale, titleKey)} - ${label}` : t(locale, titleKey);
+                    title = label
+                        ? `${t(locale, titleKey)} - ${label}`
+                        : t(locale, titleKey);
                     body = t(locale, "plan_ready_body");
                 }
                 else if (isAskUserQuestion) {
                     const titleKey = "ask_title";
-                    title = label ? `${t(locale, titleKey)} - ${label}` : t(locale, titleKey);
+                    title = label
+                        ? `${t(locale, titleKey)} - ${label}`
+                        : t(locale, titleKey);
                     body = privacy
                         ? t(locale, "ask_body_private")
                         : (questionText ?? t(locale, "ask_default_body"));
                 }
                 else {
                     const titleKey = "approval_title";
-                    title = label ? `${t(locale, titleKey)} - ${label}` : t(locale, titleKey);
+                    title = label
+                        ? `${t(locale, titleKey)} - ${label}`
+                        : t(locale, titleKey);
                     body = privacy
                         ? t(locale, "approval_body_private")
                         : t(locale, "approval_body", { toolName: msg.toolName });
                 }
-                void this.pushRelay.notify({
+                void this.pushRelay
+                    .notify({
                     eventType,
                     title,
                     body,
                     locale,
                     data,
-                }).catch((err) => {
+                })
+                    .catch((err) => {
                     const detail = err instanceof Error ? err.message : String(err);
                     console.warn(`[ws] Failed to send push notification (${eventType}, ${locale}): ${detail}`);
                 });
@@ -2216,12 +2960,18 @@ export class BridgeWebSocketServer {
         for (const locale of this.getRegisteredLocales()) {
             let title;
             if (privacy) {
-                title = isSuccess ? t(locale, "task_completed") : t(locale, "error_occurred");
+                title = isSuccess
+                    ? t(locale, "task_completed")
+                    : t(locale, "error_occurred");
             }
             else {
                 title = label
-                    ? (isSuccess ? `✅ ${label}` : `❌ ${label}`)
-                    : (isSuccess ? t(locale, "task_completed") : t(locale, "error_occurred"));
+                    ? isSuccess
+                        ? `✅ ${label}`
+                        : `❌ ${label}`
+                    : isSuccess
+                        ? t(locale, "task_completed")
+                        : t(locale, "error_occurred");
             }
             let body;
             if (privacy) {
@@ -2236,15 +2986,19 @@ export class BridgeWebSocketServer {
                     : `${t(locale, "session_completed")}${stats}`;
             }
             else {
-                body = msg.error ? msg.error.slice(0, 120) : t(locale, "session_failed");
+                body = msg.error
+                    ? msg.error.slice(0, 120)
+                    : t(locale, "session_failed");
             }
-            void this.pushRelay.notify({
+            void this.pushRelay
+                .notify({
                 eventType,
                 title,
                 body,
                 locale,
                 data,
-            }).catch((err) => {
+            })
+                .catch((err) => {
                 const detail = err instanceof Error ? err.message : String(err);
                 console.warn(`[ws] Failed to send push notification (${eventType}, ${locale}): ${detail}`);
             });
@@ -2276,34 +3030,89 @@ export class BridgeWebSocketServer {
     broadcastGalleryNewImage(image) {
         this.broadcast({ type: "gallery_new_image", image });
     }
-    collectGitDiff(cwd, callback) {
+    collectGitDiff(cwd, callback, options) {
         const execOpts = { cwd, maxBuffer: 10 * 1024 * 1024 };
-        // Collect untracked files so they appear in the diff.
-        let untrackedFiles = [];
+        // Staged only: git diff --cached
+        if (options?.staged) {
+            execFile("git", ["diff", "--cached", "--no-color"], execOpts, (err, stdout) => {
+                if (err) {
+                    callback({ diff: "", error: err.message });
+                    return;
+                }
+                callback({ diff: stdout });
+            });
+            return;
+        }
+        // Unstaged only: git diff (working tree vs index) — original behavior
+        if (options?.unstaged) {
+            // Collect untracked files so they appear in the diff.
+            let untrackedFiles = [];
+            try {
+                const out = execFileSync("git", ["ls-files", "--others", "--exclude-standard"], { cwd })
+                    .toString()
+                    .trim();
+                untrackedFiles = out ? out.split("\n") : [];
+            }
+            catch {
+                // Ignore errors: non-git directories are handled by git diff callback.
+            }
+            // Temporarily stage untracked files with --intent-to-add.
+            if (untrackedFiles.length > 0) {
+                try {
+                    execFileSync("git", ["add", "--intent-to-add", ...untrackedFiles], {
+                        cwd,
+                    });
+                }
+                catch {
+                    // Ignore staging errors.
+                }
+            }
+            execFile("git", ["diff", "--no-color"], execOpts, (err, stdout) => {
+                // Revert intent-to-add for untracked files.
+                if (untrackedFiles.length > 0) {
+                    try {
+                        execFileSync("git", ["reset", "--", ...untrackedFiles], { cwd });
+                    }
+                    catch {
+                        // Ignore reset errors.
+                    }
+                }
+                if (err) {
+                    callback({ diff: "", error: err.message });
+                    return;
+                }
+                callback({ diff: stdout });
+            });
+            return;
+        }
+        // All mode (no options): git diff HEAD — shows both staged and unstaged vs HEAD
+        let untrackedFilesAll = [];
         try {
-            const out = execFileSync("git", ["ls-files", "--others", "--exclude-standard"], { cwd }).toString().trim();
-            untrackedFiles = out ? out.split("\n") : [];
+            const out = execFileSync("git", ["ls-files", "--others", "--exclude-standard"], { cwd })
+                .toString()
+                .trim();
+            untrackedFilesAll = out ? out.split("\n") : [];
         }
         catch {
-            // Ignore errors: non-git directories are handled by git diff callback.
+            // Ignore
         }
-        // Temporarily stage untracked files with --intent-to-add.
-        if (untrackedFiles.length > 0) {
+        if (untrackedFilesAll.length > 0) {
             try {
-                execFileSync("git", ["add", "--intent-to-add", ...untrackedFiles], { cwd });
+                execFileSync("git", ["add", "--intent-to-add", ...untrackedFilesAll], {
+                    cwd,
+                });
             }
             catch {
-                // Ignore staging errors.
+                // Ignore
             }
         }
-        execFile("git", ["diff", "--no-color"], execOpts, (err, stdout) => {
-            // Revert intent-to-add for untracked files.
-            if (untrackedFiles.length > 0) {
+        execFile("git", ["diff", "HEAD", "--no-color"], execOpts, (err, stdout) => {
+            if (untrackedFilesAll.length > 0) {
                 try {
-                    execFileSync("git", ["reset", "--", ...untrackedFiles], { cwd });
+                    execFileSync("git", ["reset", "--", ...untrackedFilesAll], { cwd });
                 }
                 catch {
-                    // Ignore reset errors.
+                    // Ignore
                 }
             }
             if (err) {
@@ -2317,7 +3126,14 @@ export class BridgeWebSocketServer {
     // Image diff helpers
     // ---------------------------------------------------------------------------
     static IMAGE_EXTENSIONS = new Set([
-        ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".bmp", ".svg",
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".gif",
+        ".webp",
+        ".ico",
+        ".bmp",
+        ".svg",
     ]);
     // Image diff thresholds (configurable via environment variables)
     // - Auto-display: images ≤ threshold are sent inline as base64
@@ -2491,7 +3307,9 @@ export class BridgeWebSocketServer {
         }
     }
     extractSessionIdFromClientMessage(msg) {
-        return "sessionId" in msg && typeof msg.sessionId === "string" ? msg.sessionId : undefined;
+        return "sessionId" in msg && typeof msg.sessionId === "string"
+            ? msg.sessionId
+            : undefined;
     }
     extractSessionIdFromServerMessage(msg) {
         if ("sessionId" in msg && typeof msg.sessionId === "string")
@@ -2520,8 +3338,7 @@ export class BridgeWebSocketServer {
         return events.slice(-capped);
     }
     buildHistorySummary(history) {
-        const lines = history
-            .map((msg, index) => {
+        const lines = history.map((msg, index) => {
             const num = String(index + 1).padStart(3, "0");
             return `${num}. ${this.summarizeServerMessage(msg)}`;
         });
@@ -2576,7 +3393,10 @@ export class BridgeWebSocketServer {
                 return text ? `assistant: ${text}` : "assistant";
             }
             case "tool_result": {
-                const contentPreview = msg.content.replace(/\s+/g, " ").trim().slice(0, 100);
+                const contentPreview = msg.content
+                    .replace(/\s+/g, " ")
+                    .trim()
+                    .slice(0, 100);
                 return `${msg.toolName ?? "tool_result"}(${msg.toolUseId}) ${contentPreview}`;
             }
             case "permission_request":