@ccpocket/bridge 1.63.4 → 1.63.6

package/dist/websocket.js

@@ -14,7 +14,7 @@ import { getAllRecentSessions, getCodexSessionHistory, getSessionHistory, codexU
 import { ArchiveStore } from "./archive-store.js";
 import { WorktreeStore } from "./worktree-store.js";
 import { listWorktrees, removeWorktree, worktreeExists, getMainBranch, } from "./worktree.js";
-import { stageFiles, stageHunks, unstageFiles, unstageHunks, gitCommit, gitPush, listProjectFilesAndDirectories, listBranches, createBranch, checkoutBranch, revertFiles, revertHunks, gitFetch, gitPull, gitRemoteStatus, gitStatus, } from "./git-operations.js";
+import { stageFiles, stageHunks, unstageFiles, unstageHunks, gitCommit, gitPush, listProjectFilesAndDirectoriesForClient, listBranches, createBranch, checkoutBranch, revertFiles, revertHunks, gitFetch, gitPull, gitRemoteStatus, gitStatus, } from "./git-operations.js";
 import { generateCommitMessage } from "./git-assist.js";
 import { listWindows, takeScreenshot } from "./screenshot.js";
 import { DebugTraceStore } from "./debug-trace-store.js";
@@ -23,6 +23,7 @@ import { normalizePushLocale, t } from "./push-i18n.js";
 import { fetchAllUsage } from "./usage.js";
 import { getPackageVersion } from "./version.js";
 import { isPathWithinAllowedDirectory, resolvePlatformPath, resolvePlatformPathFrom, } from "./path-utils.js";
+import { deriveCodexPermissionsMode, normalizeCodexPermissionsMode, withDerivedCodexPermissionsMode, } from "./codex-permissions.js";
 // ---- Available model lists (delivered to clients via session_list) ----
 const FALLBACK_CLAUDE_MODELS = [
     "claude-opus-4-7",
@@ -207,17 +208,6 @@ function normalizeCodexApprovalPolicy(value) {
             return "on-request";
     }
 }
-function normalizeCodexPermissionsMode(value) {
-    switch (value) {
-        case "default":
-        case "autoReview":
-        case "fullAccess":
-        case "custom":
-            return value;
-        default:
-            return undefined;
-    }
-}
 function sanitizeCodexModel(model) {
     if (typeof model !== "string")
         return undefined;
@@ -253,21 +243,6 @@ function codexSettingsFromPermissionsMode(mode) {
             return { codexPermissionsMode: mode };
     }
 }
-function inferCodexPermissionsMode(params) {
-    const approvalPolicy = params.approvalPolicy;
-    const approvalsReviewer = params.approvalsReviewer ?? "user";
-    const sandboxMode = params.sandboxMode;
-    if (approvalPolicy === "never" && sandboxMode === "danger-full-access") {
-        return "fullAccess";
-    }
-    if (approvalPolicy === "on-request" && sandboxMode === "workspace-write") {
-        return approvalsReviewer === "auto_review" ||
-            approvalsReviewer === "guardian_subagent"
-            ? "autoReview"
-            : "default";
-    }
-    return undefined;
-}
 function errorMessageOf(err) {
     return err instanceof Error ? err.message : String(err);
 }
@@ -344,15 +319,51 @@ function envFlagEnabled(name) {
     const value = process.env[name]?.trim().toLowerCase();
     return value === "1" || value === "true" || value === "yes" || value === "on";
 }
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+function positiveEnvInt(name, fallback) {
+    const raw = process.env[name]?.trim();
+    if (!raw)
+        return fallback;
+    const value = Number(raw);
+    return Number.isSafeInteger(value) && value > 0 ? value : fallback;
+}
+function nonNegativeEnvInt(name, fallback) {
+    const raw = process.env[name]?.trim();
+    if (!raw)
+        return fallback;
+    const value = Number(raw);
+    return Number.isSafeInteger(value) &&
+        value >= 0 &&
+        value <= MAX_TIMER_DELAY_MS
+        ? value
+        : fallback;
+}
+function normalizePositiveLimit(value, fallback) {
+    return value !== undefined && Number.isSafeInteger(value) && value > 0
+        ? value
+        : fallback;
+}
+function normalizeNonNegativeLimit(value, fallback) {
+    return value !== undefined &&
+        Number.isSafeInteger(value) &&
+        value >= 0 &&
+        value <= MAX_TIMER_DELAY_MS
+        ? value
+        : fallback;
+}
 function codexThreadToRecentSession(thread, indexed) {
+    // thread/list only exposes a single preview blob; prefer the real
+    // first/last/summary texts parsed from the rollout file so display-mode
+    // switches (first prompt / last prompt / summary) show distinct content.
     return {
         sessionId: thread.id,
         provider: "codex",
         ...(thread.name ? { name: thread.name } : {}),
         ...(thread.agentNickname ? { agentNickname: thread.agentNickname } : {}),
         ...(thread.agentRole ? { agentRole: thread.agentRole } : {}),
-        summary: thread.preview || undefined,
-        firstPrompt: thread.preview || "",
+        summary: indexed?.summary || thread.preview || undefined,
+        firstPrompt: indexed?.firstPrompt || thread.preview || "",
+        ...(indexed?.lastPrompt ? { lastPrompt: indexed.lastPrompt } : {}),
         created: threadTimestampToIso(thread.createdAt),
         modified: threadTimestampToIso(thread.updatedAt),
         gitBranch: thread.gitBranch ?? "",
@@ -387,6 +398,11 @@ function mergeRecentSessionPages(sessions) {
 export class BridgeWebSocketServer {
     static MAX_DEBUG_EVENTS = 800;
     static MAX_HISTORY_SUMMARY_ITEMS = 300;
+    static CONNECT_METADATA_REFRESH_COOLDOWN_MS = 5 * 60 * 1000;
+    static DEFAULT_FILE_LIST_MAX_ENTRIES = 5000;
+    static DEFAULT_FILE_LIST_MAX_BYTES = 512 * 1024;
+    static DEFAULT_DELTA_BATCH_MS = 100;
+    static DEFAULT_DELTA_BATCH_MAX_CHARS = 4096;
     wss;
     sessionManager;
     apiKey;
@@ -406,7 +422,8 @@ export class BridgeWebSocketServer {
     archiveStore;
     codexProfiles = [];
     defaultCodexProfile;
-    codexProfilesRequest = null;
+    codexMetadataRequest = null;
+    lastConnectMetadataRefreshAt = null;
     claudeModels = FALLBACK_CLAUDE_MODELS;
     claudeModelEfforts = {
         ...FALLBACK_CLAUDE_MODEL_EFFORTS,
@@ -417,16 +434,21 @@ export class BridgeWebSocketServer {
         model,
         FALLBACK_CODEX_REASONING_EFFORTS,
     ]));
-    codexModelsRequest = null;
     /** FCM token → push notification locale */
     tokenLocales = new Map();
     tokenPrivacyMode = new Map();
     failSetPermissionMode = envFlagEnabled("BRIDGE_FAIL_SET_PERMISSION_MODE");
     failSetSandboxMode = envFlagEnabled("BRIDGE_FAIL_SET_SANDBOX_MODE");
+    fileListMaxEntries;
+    fileListMaxBytes;
+    deltaBatchMs;
+    deltaBatchMaxChars;
+    deltaBatches = new Map();
     platform;
     clientSupportedServerMessages = new WeakMap();
+    pendingClaudeResumeInputs = new WeakMap();
     constructor(options) {
-        const { server, apiKey, allowedDirs, imageStore, galleryStore, projectHistory, debugTraceStore, recordingStore, firebaseAuth, promptHistoryBackup, promptHistoryStore, platform, } = options;
+        const { server, apiKey, allowedDirs, imageStore, galleryStore, projectHistory, debugTraceStore, recordingStore, firebaseAuth, promptHistoryBackup, promptHistoryStore, platform, fileListMaxEntries, fileListMaxBytes, deltaBatchMs, deltaBatchMaxChars, } = options;
         this.apiKey = apiKey ?? null;
         this.allowedDirs = allowedDirs ?? [];
         this.imageStore = imageStore ?? null;
@@ -439,6 +461,10 @@ export class BridgeWebSocketServer {
         this.promptHistoryBackup = promptHistoryBackup ?? null;
         this.promptHistoryStore = promptHistoryStore ?? null;
         this.platform = platform ?? process.platform;
+        this.fileListMaxEntries = normalizePositiveLimit(fileListMaxEntries, positiveEnvInt("BRIDGE_FILE_LIST_MAX_ENTRIES", BridgeWebSocketServer.DEFAULT_FILE_LIST_MAX_ENTRIES));
+        this.fileListMaxBytes = normalizePositiveLimit(fileListMaxBytes, positiveEnvInt("BRIDGE_FILE_LIST_MAX_BYTES", BridgeWebSocketServer.DEFAULT_FILE_LIST_MAX_BYTES));
+        this.deltaBatchMs = normalizeNonNegativeLimit(deltaBatchMs, nonNegativeEnvInt("BRIDGE_DELTA_BATCH_MS", BridgeWebSocketServer.DEFAULT_DELTA_BATCH_MS));
+        this.deltaBatchMaxChars = normalizePositiveLimit(deltaBatchMaxChars, positiveEnvInt("BRIDGE_DELTA_BATCH_MAX_CHARS", BridgeWebSocketServer.DEFAULT_DELTA_BATCH_MAX_CHARS));
         this.archiveStore = new ArchiveStore();
         void this.debugTraceStore.init().catch((err) => {
             console.error("[ws] Failed to initialize debug trace store:", err);
@@ -525,6 +551,9 @@ export class BridgeWebSocketServer {
     }
     buildSessionCreatedMessage(params) {
         const { sessionId, provider, projectPath, session, permissionMode, executionMode, planMode, approvalsReviewer, codexPermissionsMode, sandboxMode, slashCommands, skills, skillMetadata, apps, appMetadata, plugins, pluginMetadata, sourceSessionId, } = params;
+        const derivedCodexSettings = provider === "codex"
+            ? withDerivedCodexPermissionsMode(session?.codexSettings)
+            : session?.codexSettings;
         const msg = {
             type: "system",
             subtype: "session_created",
@@ -536,15 +565,15 @@ export class BridgeWebSocketServer {
                     permissionMode: permissionMode,
                 }
                 : {}),
-            ...((approvalsReviewer ?? session?.codexSettings?.approvalsReviewer)
+            ...((approvalsReviewer ?? derivedCodexSettings?.approvalsReviewer)
                 ? {
-                    approvalsReviewer: approvalsReviewer ?? session?.codexSettings?.approvalsReviewer,
+                    approvalsReviewer: approvalsReviewer ?? derivedCodexSettings?.approvalsReviewer,
                 }
                 : {}),
-            ...((codexPermissionsMode ?? session?.codexSettings?.codexPermissionsMode)
+            ...((codexPermissionsMode ?? derivedCodexSettings?.codexPermissionsMode)
                 ? {
                     codexPermissionsMode: (codexPermissionsMode ??
-                        session?.codexSettings?.codexPermissionsMode),
+                        derivedCodexSettings?.codexPermissionsMode),
                 }
                 : {}),
             ...((executionMode ??
@@ -617,28 +646,28 @@ export class BridgeWebSocketServer {
                 : {}),
             ...(sourceSessionId ? { sourceSessionId } : {}),
         };
-        if (provider === "codex" && session?.codexSettings) {
-            if (session.codexSettings.model !== undefined) {
-                msg.model = session.codexSettings.model;
+        if (provider === "codex" && derivedCodexSettings) {
+            if (derivedCodexSettings.model !== undefined) {
+                msg.model = derivedCodexSettings.model;
             }
-            if (session.codexSettings.approvalPolicy !== undefined) {
-                msg.approvalPolicy = session.codexSettings.approvalPolicy;
+            if (derivedCodexSettings.approvalPolicy !== undefined) {
+                msg.approvalPolicy = derivedCodexSettings.approvalPolicy;
             }
-            if (session.codexSettings.codexPermissionsMode !== undefined) {
-                msg.codexPermissionsMode = session.codexSettings.codexPermissionsMode;
+            if (derivedCodexSettings.codexPermissionsMode !== undefined) {
+                msg.codexPermissionsMode = derivedCodexSettings.codexPermissionsMode;
             }
-            if (session.codexSettings.modelReasoningEffort !== undefined) {
-                msg.modelReasoningEffort = session.codexSettings.modelReasoningEffort;
+            if (derivedCodexSettings.modelReasoningEffort !== undefined) {
+                msg.modelReasoningEffort = derivedCodexSettings.modelReasoningEffort;
             }
-            if (session.codexSettings.networkAccessEnabled !== undefined) {
-                msg.networkAccessEnabled = session.codexSettings.networkAccessEnabled;
+            if (derivedCodexSettings.networkAccessEnabled !== undefined) {
+                msg.networkAccessEnabled = derivedCodexSettings.networkAccessEnabled;
             }
-            if (session.codexSettings.webSearchMode !== undefined) {
-                msg.webSearchMode = session.codexSettings.webSearchMode;
+            if (derivedCodexSettings.webSearchMode !== undefined) {
+                msg.webSearchMode = derivedCodexSettings.webSearchMode;
             }
-            if (session.codexSettings.additionalWritableRoots !== undefined) {
+            if (derivedCodexSettings.additionalWritableRoots !== undefined) {
                 msg.additionalWritableRoots =
-                    session.codexSettings.additionalWritableRoots;
+                    derivedCodexSettings.additionalWritableRoots;
             }
         }
         return msg;
@@ -737,7 +766,7 @@ export class BridgeWebSocketServer {
             expectedUserTurns: targetOrdinal - 1,
             fallback: buildCodexHistoryPrefix(session, targetOrdinal - 1),
         });
-        this.sessionManager.destroy(sessionId);
+        this.destroySession(sessionId);
         const newSessionId = this.sessionManager.create(projectPath, undefined, pastMessages, worktreeOpts, "codex", {
             ...(codexSettings ?? {}),
             threadId,
@@ -1341,7 +1370,9 @@ export class BridgeWebSocketServer {
     }
     close() {
         console.log("[ws] Shutting down...");
+        this.flushAllDeltaBatches();
         this.sessionManager.destroyAll();
+        this.flushAllDeltaBatches();
         stopManagedCodexAppServers();
         this.debugEvents.clear();
         this.wss.close();
@@ -1356,9 +1387,7 @@ export class BridgeWebSocketServer {
     }
     handleConnection(ws) {
         // Send session list and project history on connect
-        void this.refreshCodexProfiles();
-        void this.refreshCodexModels();
-        void this.refreshClaudeModels();
+        this.refreshConnectionMetadata();
         this.sendSessionList(ws);
         const projects = this.projectHistory?.getProjects() ?? [];
         this.send(ws, { type: "project_history", projects });
@@ -1389,11 +1418,25 @@ export class BridgeWebSocketServer {
         });
         ws.on("close", () => {
             console.log("[ws] Client disconnected");
+            this.discardClientDeltaBatches(ws);
+            this.clearPendingClaudeResumeInputs(ws);
         });
         ws.on("error", (err) => {
             console.error("[ws] Client error:", err.message);
         });
     }
+    refreshConnectionMetadata(now = Date.now()) {
+        const lastRefreshAt = this.lastConnectMetadataRefreshAt;
+        if (lastRefreshAt !== null &&
+            now >= lastRefreshAt &&
+            now - lastRefreshAt <
+                BridgeWebSocketServer.CONNECT_METADATA_REFRESH_COOLDOWN_MS) {
+            return;
+        }
+        this.lastConnectMetadataRefreshAt = now;
+        void this.refreshCodexMetadata();
+        void this.refreshClaudeModels();
+    }
     async handleClientMessage(msg, ws) {
         if (msg.type === "client_capabilities") {
             this.clientSupportedServerMessages.set(ws, new Set(msg.supportedServerMessages ?? []));
@@ -1573,7 +1616,7 @@ export class BridgeWebSocketServer {
                         }));
                         this.broadcastSessionList();
                         if (provider === "codex") {
-                            void this.refreshCodexModels(projectPath);
+                            void this.refreshCodexMetadata(projectPath);
                         }
                         else {
                             void this.refreshClaudeModels(projectPath);
@@ -1612,6 +1655,13 @@ export class BridgeWebSocketServer {
             case "input": {
                 const session = this.resolveSession(msg.sessionId);
                 if (!session) {
+                    const pendingInputs = msg.sessionId
+                        ? this.pendingClaudeResumeInputs.get(ws)?.get(msg.sessionId)
+                        : undefined;
+                    if (pendingInputs) {
+                        pendingInputs.push(msg);
+                        return;
+                    }
                     this.send(ws, {
                         type: "error",
                         message: "No active session. Send 'start' first.",
@@ -1810,11 +1860,20 @@ export class BridgeWebSocketServer {
                 // Claude Code input path — enqueue first, then interrupt if busy
                 const claudeProc = session.process;
                 let wasQueued = false;
+                let shouldInterrupt = false;
                 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;
+                    if (typeof claudeProc.dispatchInputWithImages === "function") {
+                        const result = claudeProc.dispatchInputWithImages(text, images);
+                        wasQueued = result.queued;
+                        shouldInterrupt = result.shouldInterrupt;
+                    }
+                    else {
+                        const result = claudeProc.sendInputWithImages(text, images);
+                        wasQueued =
+                            typeof result === "boolean" ? result : isAgentBusySnapshot;
+                        shouldInterrupt = wasQueued;
+                    }
                 }
                 // Legacy imageId mode (backward compatibility)
                 else if (msg.imageId && this.galleryStore) {
@@ -1830,39 +1889,74 @@ export class BridgeWebSocketServer {
                         .then((imageData) => {
                         let queuedAfterResolve = false;
                         if (imageData) {
-                            const result = claudeProc.sendInputWithImages(text, [
-                                imageData,
-                            ]);
-                            queuedAfterResolve =
-                                typeof result === "boolean" ? result : isAgentBusySnapshot;
+                            if (typeof claudeProc.dispatchInputWithImages === "function") {
+                                const result = claudeProc.dispatchInputWithImages(text, [
+                                    imageData,
+                                ]);
+                                queuedAfterResolve = result.queued;
+                                if (result.shouldInterrupt)
+                                    claudeProc.interrupt();
+                            }
+                            else {
+                                const result = claudeProc.sendInputWithImages(text, [
+                                    imageData,
+                                ]);
+                                queuedAfterResolve =
+                                    typeof result === "boolean"
+                                        ? result
+                                        : isAgentBusySnapshot;
+                                if (queuedAfterResolve)
+                                    claudeProc.interrupt();
+                            }
                         }
                         else {
                             console.warn(`[ws] Image not found: ${msg.imageId}`);
-                            const result = session.process.sendInput(text);
-                            queuedAfterResolve =
-                                typeof result === "boolean" ? result : isAgentBusySnapshot;
-                        }
-                        if (queuedAfterResolve) {
-                            console.log(`[ws] Agent is busy — will queue input and interrupt current turn`);
-                            claudeProc.interrupt();
+                            if (typeof claudeProc.dispatchInput === "function") {
+                                const result = claudeProc.dispatchInput(text);
+                                queuedAfterResolve = result.queued;
+                                if (result.shouldInterrupt)
+                                    claudeProc.interrupt();
+                            }
+                            else {
+                                const result = session.process.sendInput(text);
+                                queuedAfterResolve =
+                                    typeof result === "boolean"
+                                        ? result
+                                        : isAgentBusySnapshot;
+                                if (queuedAfterResolve)
+                                    claudeProc.interrupt();
+                            }
                         }
                     })
                         .catch((err) => {
                         console.error(`[ws] Failed to load image: ${err}`);
-                        const result = session.process.sendInput(text);
-                        const queuedAfterResolve = typeof result === "boolean" ? result : isAgentBusySnapshot;
-                        if (queuedAfterResolve) {
-                            console.log(`[ws] Agent is busy — will queue input and interrupt current turn`);
-                            claudeProc.interrupt();
+                        if (typeof claudeProc.dispatchInput === "function") {
+                            const result = claudeProc.dispatchInput(text);
+                            if (result.shouldInterrupt)
+                                claudeProc.interrupt();
+                        }
+                        else {
+                            const result = session.process.sendInput(text);
+                            const queuedAfterResolve = typeof result === "boolean" ? result : isAgentBusySnapshot;
+                            if (queuedAfterResolve)
+                                claudeProc.interrupt();
                         }
                     });
                     break;
                 }
                 // Text-only message
                 else {
-                    const result = session.process.sendInput(text);
-                    wasQueued =
-                        typeof result === "boolean" ? result : isAgentBusySnapshot;
+                    if (typeof claudeProc.dispatchInput === "function") {
+                        const result = claudeProc.dispatchInput(text);
+                        wasQueued = result.queued;
+                        shouldInterrupt = result.shouldInterrupt;
+                    }
+                    else {
+                        const result = session.process.sendInput(text);
+                        wasQueued =
+                            typeof result === "boolean" ? result : isAgentBusySnapshot;
+                        shouldInterrupt = wasQueued;
+                    }
                 }
                 // Acknowledge receipt so the client can mark the message state.
                 // queued=true means the input was enqueued instead of being consumed
@@ -1874,7 +1968,7 @@ export class BridgeWebSocketServer {
                     acceptedSeq,
                     queued: wasQueued,
                 });
-                if (wasQueued) {
+                if (shouldInterrupt) {
                     console.log(`[ws] Agent is busy — will queue input and interrupt current turn`);
                     claudeProc.interrupt();
                 }
@@ -2055,7 +2149,7 @@ export class BridgeWebSocketServer {
                         : currentSandboxMode;
                     const newPermissionsMode = codexPermissionSettings?.codexPermissionsMode ??
                         (collaborationOnlyChange ? currentPermissionsMode : undefined) ??
-                        inferCodexPermissionsMode({
+                        deriveCodexPermissionsMode({
                             approvalPolicy: newApproval,
                             approvalsReviewer: codexPermissionSettings?.approvalsReviewer ??
                                 msg.approvalsReviewer ??
@@ -2129,7 +2223,7 @@ export class BridgeWebSocketServer {
                     const worktreePath = session.worktreePath;
                     const worktreeBranch = session.worktreeBranch;
                     const sessionName = session.name;
-                    this.sessionManager.destroy(oldSessionId);
+                    this.destroySession(oldSessionId);
                     console.log(`[ws] Permission mode change: destroyed session ${oldSessionId}`);
                     const hasUserMessages = session.history?.some((m) => m.type === "user_input" || m.type === "assistant") ||
                         (session.pastMessages && session.pastMessages.length > 0);
@@ -2360,7 +2454,7 @@ export class BridgeWebSocketServer {
                     const sessionName = session.name;
                     const permissionMode = session.process.permissionMode;
                     const model = session.process.model;
-                    this.sessionManager.destroy(oldSessionId);
+                    this.destroySession(oldSessionId);
                     console.log(`[ws] Claude sandbox change: destroyed session ${oldSessionId}`);
                     const newId = this.sessionManager.create(projectPath, {
                         sessionId: claudeSessionId,
@@ -2416,7 +2510,7 @@ export class BridgeWebSocketServer {
                 const executionMode = oldSettings.approvalPolicy === "never" ? "fullAccess" : "default";
                 const planMode = collaborationMode === "plan";
                 const legacyPermissionMode = modesToLegacyPermissionMode("codex", executionMode, planMode);
-                this.sessionManager.destroy(oldSessionId);
+                this.destroySession(oldSessionId);
                 console.log(`[ws] Sandbox mode change: destroyed session ${oldSessionId}`);
                 // Check if the user actually exchanged messages in this session.
                 // session.history always contains system events (init, status, etc.)
@@ -2553,7 +2647,7 @@ export class BridgeWebSocketServer {
                     const permissionMode = sdkProc.permissionMode;
                     const worktreePath = session.worktreePath;
                     const worktreeBranch = session.worktreeBranch;
-                    this.sessionManager.destroy(sessionId);
+                    this.destroySession(sessionId);
                     console.log(`[ws] Clear context: destroyed session ${sessionId}`);
                     const newId = this.sessionManager.create(projectPath, {
                         ...(claudeSessionId
@@ -2638,7 +2732,7 @@ export class BridgeWebSocketServer {
                         subtype: "stopped",
                         sessionId: session.claudeSessionId,
                     });
-                    this.sessionManager.destroy(msg.sessionId);
+                    this.destroySession(msg.sessionId);
                     this.recordDebugEvent(msg.sessionId, {
                         direction: "internal",
                         channel: "bridge",
@@ -3061,6 +3155,19 @@ export class BridgeWebSocketServer {
                 }
                 const claudeSessionId = sessionRefId;
                 const cached = this.sessionManager.getCachedCommands(resumeProjectPath);
+                let pendingResumes = this.pendingClaudeResumeInputs.get(ws);
+                if (!pendingResumes) {
+                    pendingResumes = new Map();
+                    this.pendingClaudeResumeInputs.set(ws, pendingResumes);
+                }
+                if (pendingResumes.has(claudeSessionId)) {
+                    this.send(ws, {
+                        type: "error",
+                        message: `Session resume already in progress: ${claudeSessionId}`,
+                    });
+                    break;
+                }
+                pendingResumes.set(claudeSessionId, []);
                 // Look up worktree mapping for this Claude session
                 const wtMapping = this.worktreeStore.get(claudeSessionId);
                 let worktreeOpts;
@@ -3102,7 +3209,7 @@ export class BridgeWebSocketServer {
                         worktreeOptions: worktreeOpts,
                     });
                     const createdSession = this.sessionManager.get(sessionId);
-                    void this.loadAndSetSessionName(createdSession, "claude", resumeProjectPath, claudeSessionId).then(() => {
+                    const finishResume = () => {
                         this.send(ws, {
                             ...this.buildSessionCreatedMessage({
                                 sessionId,
@@ -3133,10 +3240,19 @@ export class BridgeWebSocketServer {
                             }),
                             claudeSessionId,
                         });
+                        const queuedInputs = pendingResumes.get(claudeSessionId) ?? [];
+                        pendingResumes.delete(claudeSessionId);
+                        for (const input of queuedInputs) {
+                            void this.handleClientMessage({ ...input, sessionId }, ws);
+                        }
                         this.broadcastSessionList();
                         if (autoFallbackUsed) {
                             this.sendTip(ws, sessionId, "auto_mode_fallback_default", createdSession);
                         }
+                    };
+                    void this.loadAndSetSessionName(createdSession, "claude", resumeProjectPath, claudeSessionId).then(finishResume, (err) => {
+                        console.error("[ws] Failed to load resumed session name:", err);
+                        finishResume();
                     });
                     this.debugEvents.set(sessionId, []);
                     this.recordDebugEvent(sessionId, {
@@ -3148,6 +3264,18 @@ export class BridgeWebSocketServer {
                     this.projectHistory?.addProject(resumeProjectPath);
                 })
                     .catch((err) => {
+                    const queuedInputs = pendingResumes.get(claudeSessionId) ?? [];
+                    pendingResumes.delete(claudeSessionId);
+                    for (const input of queuedInputs) {
+                        if (input.clientMessageId) {
+                            this.send(ws, {
+                                type: "input_rejected",
+                                sessionId: claudeSessionId,
+                                clientMessageId: input.clientMessageId,
+                                reason: "Session resume failed",
+                            });
+                        }
+                    }
                     this.send(ws, {
                         type: "error",
                         message: `Failed to load session history: ${err}`,
@@ -3385,8 +3513,16 @@ export class BridgeWebSocketServer {
                 }
                 void (async () => {
                     try {
-                        const files = await listProjectFilesAndDirectories(msg.projectPath);
-                        this.send(ws, { type: "file_list", files });
+                        const result = await listProjectFilesAndDirectoriesForClient(msg.projectPath, {
+                            maxEntries: this.fileListMaxEntries,
+                            maxBytes: this.fileListMaxBytes,
+                        });
+                        this.send(ws, {
+                            type: "file_list",
+                            files: result.files,
+                            totalFiles: result.totalFiles,
+                            truncated: result.truncated,
+                        });
                     }
                     catch (err) {
                         const message = err instanceof Error ? err.message : String(err);
@@ -4057,6 +4193,7 @@ export class BridgeWebSocketServer {
                 else if (msg.mode === "conversation") {
                     // Conversation-only rewind: restart session at the target UUID
                     try {
+                        this.flushSessionDeltaBatches(msg.sessionId);
                         this.sessionManager.rewindConversation(msg.sessionId, msg.targetUuid, (newSessionId) => {
                             this.send(ws, {
                                 type: "rewind_result",
@@ -4098,6 +4235,7 @@ export class BridgeWebSocketServer {
                             return;
                         }
                         try {
+                            this.flushSessionDeltaBatches(msg.sessionId);
                             this.sessionManager.rewindConversation(msg.sessionId, msg.targetUuid, (newSessionId) => {
                                 this.send(ws, {
                                     type: "rewind_result",
@@ -4446,6 +4584,10 @@ export class BridgeWebSocketServer {
             }
         }
     }
+    clearPendingClaudeResumeInputs(ws) {
+        this.pendingClaudeResumeInputs.get(ws)?.clear();
+        this.pendingClaudeResumeInputs.delete(ws);
+    }
     /**
      * Load the saved session name from CLI storage and set it on the SessionInfo.
      * Called after SessionManager.create() so that session_created carries the name.
@@ -4588,6 +4730,121 @@ export class BridgeWebSocketServer {
         });
     }
     broadcastSessionMessage(sessionId, msg, exclude) {
+        if (this.shouldBatchDelta(msg, exclude)) {
+            this.trackSessionMessage(sessionId, msg);
+            const chunks = this.splitDeltaText(msg.text);
+            for (const client of this.wss.clients) {
+                if (client.readyState !== WebSocket.OPEN)
+                    continue;
+                if (!this.shouldSendToClient(client, msg))
+                    continue;
+                this.queueDeltaForClient(client, sessionId, msg.type, chunks);
+            }
+            return;
+        }
+        this.flushSessionDeltaBatches(sessionId);
+        this.trackSessionMessage(sessionId, msg);
+        this.broadcastSessionMessageNow(sessionId, msg, exclude);
+    }
+    shouldBatchDelta(msg, exclude) {
+        if (this.deltaBatchMs === 0 || exclude)
+            return false;
+        return msg.type === "stream_delta" || msg.type === "thinking_delta";
+    }
+    queueDeltaForClient(client, sessionId, type, chunks) {
+        for (const chunk of chunks) {
+            let batch = this.deltaBatches.get(client)?.get(sessionId);
+            if (batch &&
+                batch.charCount > 0 &&
+                batch.charCount + chunk.charCount > this.deltaBatchMaxChars) {
+                this.flushClientDeltaBatch(client, sessionId);
+                batch = undefined;
+            }
+            if (!batch) {
+                const clientBatches = this.deltaBatches.get(client) ?? new Map();
+                batch = {
+                    messages: [],
+                    charCount: 0,
+                    timer: setTimeout(() => {
+                        this.flushClientDeltaBatch(client, sessionId);
+                    }, this.deltaBatchMs),
+                };
+                clientBatches.set(sessionId, batch);
+                this.deltaBatches.set(client, clientBatches);
+            }
+            const last = batch.messages.at(-1);
+            if (last?.type === type) {
+                last.text += chunk.text;
+            }
+            else {
+                batch.messages.push({ type, text: chunk.text });
+            }
+            batch.charCount += chunk.charCount;
+            if (batch.charCount >= this.deltaBatchMaxChars) {
+                this.flushClientDeltaBatch(client, sessionId);
+            }
+        }
+    }
+    splitDeltaText(text) {
+        if (text.length === 0)
+            return [{ text, charCount: 0 }];
+        const chunks = [];
+        let chars = [];
+        let charCount = 0;
+        for (const char of text) {
+            chars.push(char);
+            charCount += 1;
+            if (charCount >= this.deltaBatchMaxChars) {
+                chunks.push({ text: chars.join(""), charCount });
+                chars = [];
+                charCount = 0;
+            }
+        }
+        if (chars.length > 0) {
+            chunks.push({ text: chars.join(""), charCount });
+        }
+        return chunks;
+    }
+    flushSessionDeltaBatches(sessionId) {
+        for (const client of Array.from(this.deltaBatches.keys())) {
+            this.flushClientDeltaBatch(client, sessionId);
+        }
+    }
+    flushAllDeltaBatches() {
+        for (const [client, batches] of Array.from(this.deltaBatches.entries())) {
+            for (const sessionId of Array.from(batches.keys())) {
+                this.flushClientDeltaBatch(client, sessionId);
+            }
+        }
+    }
+    flushClientDeltaBatch(client, sessionId) {
+        const clientBatches = this.deltaBatches.get(client);
+        const batch = clientBatches?.get(sessionId);
+        if (!batch)
+            return;
+        clearTimeout(batch.timer);
+        clientBatches?.delete(sessionId);
+        if (clientBatches?.size === 0)
+            this.deltaBatches.delete(client);
+        if (client.readyState !== WebSocket.OPEN)
+            return;
+        for (const msg of batch.messages) {
+            client.send(JSON.stringify({ ...msg, sessionId }));
+        }
+    }
+    discardClientDeltaBatches(client) {
+        const batches = this.deltaBatches.get(client);
+        if (!batches)
+            return;
+        for (const batch of batches.values())
+            clearTimeout(batch.timer);
+        this.deltaBatches.delete(client);
+    }
+    destroySession(sessionId) {
+        this.flushSessionDeltaBatches(sessionId);
+        this.sessionManager.destroy(sessionId);
+    }
+    trackSessionMessage(sessionId, msg) {
         this.maybeSendPushNotification(sessionId, msg);
         this.recordDebugEvent(sessionId, {
             direction: "outgoing",
@@ -4610,7 +4867,8 @@ export class BridgeWebSocketServer {
                 });
             }
         }
-        // Wrap the message with sessionId
+    }
+    broadcastSessionMessageNow(sessionId, msg, exclude) {
         const data = JSON.stringify({ ...msg, sessionId });
         for (const client of this.wss.clients) {
             if (client === exclude)
@@ -4687,28 +4945,58 @@ export class BridgeWebSocketServer {
             });
         }
     }
-    async refreshCodexModels(projectPath) {
-        if (this.codexModelsRequest)
-            return this.codexModelsRequest;
-        this.codexModelsRequest = this.loadCodexModels(projectPath)
-            .then((models) => {
-            if (models.length > 0) {
-                this.applyCodexModels(models);
-            }
-            else {
-                this.applyFallbackCodexModels();
+    async refreshCodexMetadata(projectPath) {
+        if (this.codexMetadataRequest) {
+            if (projectPath) {
+                return this.codexMetadataRequest.then(() => this.refreshCodexMetadata(projectPath));
             }
-            this.broadcastSessionList();
-        })
+            return this.codexMetadataRequest;
+        }
+        this.codexMetadataRequest = this.loadAndApplyCodexMetadata(projectPath)
             .catch((err) => {
-            console.warn(`[ws] Failed to load Codex models: ${err}`);
+            console.warn(`[ws] Failed to load Codex metadata: ${err}`);
+            this.codexProfiles = [];
+            this.defaultCodexProfile = undefined;
             this.applyFallbackCodexModels();
             this.broadcastSessionList();
         })
             .finally(() => {
-            this.codexModelsRequest = null;
+            this.codexMetadataRequest = null;
         });
-        return this.codexModelsRequest;
+        return this.codexMetadataRequest;
+    }
+    async loadAndApplyCodexMetadata(projectPath) {
+        const activeProcess = this.getActiveCodexProcess();
+        const codexProcess = activeProcess ?? (await this.createStandaloneCodexProcess(projectPath));
+        try {
+            const [profileResult, modelResult] = await Promise.allSettled([
+                codexProcess.readProfileConfig(projectPath),
+                this.readCodexModels(codexProcess),
+            ]);
+            if (profileResult.status === "fulfilled") {
+                this.codexProfiles = profileResult.value.profiles;
+                this.defaultCodexProfile = profileResult.value.defaultProfile;
+            }
+            else {
+                console.warn(`[ws] Failed to load Codex profiles: ${profileResult.reason}`);
+                this.codexProfiles = [];
+                this.defaultCodexProfile = undefined;
+            }
+            if (modelResult.status === "fulfilled" && modelResult.value.length > 0) {
+                this.applyCodexModels(modelResult.value);
+            }
+            else {
+                if (modelResult.status === "rejected") {
+                    console.warn(`[ws] Failed to load Codex models: ${modelResult.reason}`);
+                }
+                this.applyFallbackCodexModels();
+            }
+            this.broadcastSessionList();
+        }
+        finally {
+            if (!activeProcess)
+                codexProcess.stop();
+        }
     }
     async refreshClaudeModels(projectPath) {
         if (this.claudeModelsRequest)
@@ -4752,28 +5040,18 @@ export class BridgeWebSocketServer {
         this.claudeModels = FALLBACK_CLAUDE_MODELS;
         this.claudeModelEfforts = { ...FALLBACK_CLAUDE_MODEL_EFFORTS };
     }
-    async loadCodexModels(projectPath) {
-        const process = this.getActiveCodexProcess() ??
-            (await this.createStandaloneCodexProcess(projectPath));
-        const isStandalone = process !== this.getActiveCodexProcess();
-        try {
-            const modelSource = process;
-            if (typeof modelSource.listAvailableModelMetadata === "function") {
-                return await modelSource.listAvailableModelMetadata();
-            }
-            const models = typeof modelSource.listAvailableModels === "function"
-                ? await modelSource.listAvailableModels()
-                : [];
-            return models.map((model) => ({
-                model,
-                supportedReasoningEfforts: FALLBACK_CODEX_REASONING_EFFORTS,
-            }));
-        }
-        finally {
-            if (isStandalone) {
-                process.stop();
-            }
+    async readCodexModels(codexProcess) {
+        const modelSource = codexProcess;
+        if (typeof modelSource.listAvailableModelMetadata === "function") {
+            return modelSource.listAvailableModelMetadata();
         }
+        const models = typeof modelSource.listAvailableModels === "function"
+            ? await modelSource.listAvailableModels()
+            : [];
+        return models.map((model) => ({
+            model,
+            supportedReasoningEfforts: FALLBACK_CODEX_REASONING_EFFORTS,
+        }));
     }
     applyCodexModels(models) {
         this.codexModels = models.map((model) => model.model);
@@ -4791,25 +5069,6 @@ export class BridgeWebSocketServer {
             FALLBACK_CODEX_REASONING_EFFORTS,
         ]));
     }
-    async refreshCodexProfiles(projectPath) {
-        if (this.codexProfilesRequest)
-            return this.codexProfilesRequest;
-        this.codexProfilesRequest = this.loadCodexProfiles(projectPath)
-            .then(({ profiles, defaultProfile }) => {
-            this.codexProfiles = profiles;
-            this.defaultCodexProfile = defaultProfile;
-            this.broadcastSessionList();
-        })
-            .catch((err) => {
-            console.warn(`[ws] Failed to load Codex profiles: ${err}`);
-            this.codexProfiles = [];
-            this.defaultCodexProfile = undefined;
-        })
-            .finally(() => {
-            this.codexProfilesRequest = null;
-        });
-        return this.codexProfilesRequest;
-    }
     async loadCodexProfiles(projectPath) {
         const process = this.getActiveCodexProcess() ??
             (await this.createStandaloneCodexProcess(projectPath));
@@ -4921,8 +5180,14 @@ export class BridgeWebSocketServer {
     }
     async createStandaloneCodexProcess(projectPath) {
         const proc = new CodexProcess();
-        await proc.initializeOnly(projectPath ?? process.cwd());
-        return proc;
+        try {
+            await proc.initializeOnly(projectPath ?? process.cwd());
+            return proc;
+        }
+        catch (err) {
+            proc.stop();
+            throw err;
+        }
     }
     /** Extract a short project label from the full projectPath (last directory name). */
     projectLabel(sessionId) {