@ccpocket/bridge 1.62.1 → 1.63.2

package/dist/websocket.js

@@ -50,6 +50,11 @@ const FALLBACK_CODEX_MODELS = [
     "gpt-5.3-codex-spark",
 ];
 const FALLBACK_CODEX_REASONING_EFFORTS = ["low", "medium", "high", "xhigh"];
+const CODEX_RECENT_THREAD_SOURCE_KINDS = [
+    "cli",
+    "vscode",
+    "appServer",
+];
 const CODEX_USER_TURN_UUID_RE = /^codex:user-turn:(\d+)$/;
 const OPT_IN_SERVER_MESSAGES = new Set([
     "conversation_queue",
@@ -213,6 +218,14 @@ function normalizeCodexPermissionsMode(value) {
             return undefined;
     }
 }
+function sanitizeCodexModel(model) {
+    if (typeof model !== "string")
+        return undefined;
+    const normalized = model.trim();
+    if (!normalized || normalized === "codex")
+        return undefined;
+    return normalized;
+}
 function codexSettingsFromPermissionsMode(mode) {
     switch (mode) {
         case "default":
@@ -841,37 +854,8 @@ export class BridgeWebSocketServer {
                 pastMessages.push(raw);
                 continue;
             }
-            const paths = new Set();
-            if (Array.isArray(msg.imagePaths)) {
-                for (const path of msg.imagePaths) {
-                    if (typeof path === "string" && path.length > 0)
-                        paths.add(path);
-                }
-            }
             const content = typeof msg.content === "string" ? msg.content : "";
-            if (this.imageStore && content) {
-                for (const path of this.imageStore.extractImagePaths(content)) {
-                    paths.add(path);
-                }
-            }
-            const images = this.imageStore && paths.size > 0
-                ? await this.imageStore.registerImages([...paths], session.projectPath)
-                : [];
-            if (this.imageStore && Array.isArray(msg.imageBase64)) {
-                for (const image of msg.imageBase64) {
-                    const rawImage = image;
-                    if (typeof rawImage.data !== "string"
-                        || typeof rawImage.mimeType !== "string") {
-                        continue;
-                    }
-                    const ref = this.imageStore.registerFromBase64(rawImage.data, rawImage.mimeType);
-                    if (ref)
-                        images.push(ref);
-                }
-            }
-            const existingImages = Array.isArray(msg.images)
-                ? msg.images
-                : [];
+            const images = await this.registerPastToolResultImages(session, msg);
             pastMessages.push({
                 role: "tool_result",
                 toolUseId: typeof msg.toolUseId === "string"
@@ -879,13 +863,308 @@ export class BridgeWebSocketServer {
                     : `past-tool-result-${pastMessages.length}`,
                 content,
                 ...(typeof msg.toolName === "string" ? { toolName: msg.toolName } : {}),
-                ...(existingImages.length > 0 || images.length > 0
-                    ? { images: [...existingImages, ...images] }
-                    : {}),
+                ...(images.length > 0 ? { images } : {}),
             });
         }
         return { pastMessages, historyMessages };
     }
+    codexThreadIdForSession(session) {
+        if (session.provider !== "codex")
+            return undefined;
+        if (session.claudeSessionId)
+            return session.claudeSessionId;
+        if (session.process instanceof CodexProcess) {
+            return session.process.sessionId ?? undefined;
+        }
+        return undefined;
+    }
+    async codexCanonicalHistoryEntries(session) {
+        const threadId = this.codexThreadIdForSession(session);
+        if (!threadId)
+            return null;
+        const history = await this.getCodexThreadHistory(threadId, session.projectPath);
+        session.claudeSessionId = threadId;
+        const messages = await this.codexHistoryToServerMessages(session, history);
+        const entries = messages.map((message, index) => ({
+            seq: index + 1,
+            message,
+        }));
+        this.applyCodexCanonicalHistoryBaseline(session, history, entries);
+        return [...entries, ...session.historyEntries];
+    }
+    applyCodexCanonicalHistoryBaseline(session, history, canonicalEntries) {
+        const liveEntries = session.historyEntries.map((entry) => ({
+            seq: entry.seq,
+            message: entry.message,
+        }));
+        const canonicalKeys = new Set();
+        const canonicalUserUuids = new Set();
+        for (const entry of canonicalEntries) {
+            for (const key of this.codexHistoryMessageIdentityKeys(entry.message)) {
+                canonicalKeys.add(key);
+            }
+            const message = entry.message;
+            if (message.type === "user_input" && message.userMessageUuid) {
+                canonicalUserUuids.add(message.userMessageUuid);
+            }
+        }
+        this.seedCodexCanonicalUserTurnUuidMap(session, history);
+        let nextSeq = canonicalEntries.at(-1)?.seq ?? 0;
+        const retainedMessages = [];
+        const retainedEntries = [];
+        for (const entry of liveEntries) {
+            if (!this.shouldRetainCodexLiveHistoryMessage(entry.message))
+                continue;
+            const keys = this.codexHistoryMessageIdentityKeys(entry.message);
+            if (keys.some((key) => canonicalKeys.has(key)))
+                continue;
+            const seq = ++nextSeq;
+            entry.message.historySeq = seq;
+            retainedMessages.push(entry.message);
+            retainedEntries.push({ seq, message: entry.message });
+        }
+        session.pastMessages = history;
+        session.history = retainedMessages;
+        session.historyEntries = retainedEntries;
+        session.historyRevision = nextSeq;
+        session.codexCanonicalHistoryRevision = canonicalEntries.at(-1)?.seq ?? 0;
+        session.historyLowWatermark =
+            retainedEntries[0]?.seq ?? session.historyRevision + 1;
+        if (session.pendingCodexUserEchoUuids) {
+            for (const uuid of canonicalUserUuids) {
+                session.pendingCodexUserEchoUuids.delete(uuid);
+            }
+            for (const uuid of [...session.pendingCodexUserEchoUuids]) {
+                const stillLive = retainedMessages.some((message) => message.type === "user_input" && message.userMessageUuid === uuid);
+                if (!stillLive)
+                    session.pendingCodexUserEchoUuids.delete(uuid);
+            }
+        }
+    }
+    seedCodexCanonicalUserTurnUuidMap(session, history) {
+        if (session.provider !== "codex")
+            return;
+        for (const message of history) {
+            if (message.role !== "user" ||
+                !message.rawItemId ||
+                !message.uuid) {
+                continue;
+            }
+            session.codexUserTurnUuidByRawId ??= new Map();
+            session.codexUserTurnUuidByRawId.set(message.rawItemId, message.uuid);
+        }
+    }
+    shouldRetainCodexLiveHistoryMessage(message) {
+        return !(message.type === "system" &&
+            message.subtype === "tip");
+    }
+    codexHistoryMessageIdentityKeys(message) {
+        if (message.type === "user_input") {
+            return message.userMessageUuid ? [`user:${message.userMessageUuid}`] : [];
+        }
+        if (message.type === "assistant") {
+            const assistantId = message.messageUuid ?? message.message.id;
+            if (assistantId)
+                return [`assistant:${assistantId}`];
+            return [
+                `assistant-content:${this.historyValueKey(message.message.content)}`,
+            ];
+        }
+        if (message.type === "tool_result") {
+            if (message.toolUseId) {
+                return [`tool-result:${message.toolUseId}:${message.toolName ?? ""}`];
+            }
+            return [
+                `tool-result-content:${message.toolName ?? ""}:${message.content}`,
+            ];
+        }
+        return [];
+    }
+    historyValueKey(value) {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    async sendCodexCanonicalHistorySnapshot(ws, sessionId, session, options = {}) {
+        try {
+            const entries = await this.codexCanonicalHistoryEntries(session);
+            if (!entries)
+                return false;
+            this.send(ws, {
+                type: "history_snapshot",
+                sessionId,
+                fromSeq: entries[0]?.seq ?? 1,
+                toSeq: entries.at(-1)?.seq ?? 0,
+                messages: entries,
+                status: session.status,
+                reason: "reset",
+            });
+            this.sendCodexQueueState(ws, sessionId, session);
+            if (options.includeCachedCommands) {
+                this.sendCachedCommands(ws, sessionId, session);
+            }
+            return true;
+        }
+        catch (err) {
+            this.send(ws, {
+                type: "error",
+                message: `Failed to read Codex thread history: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            return true;
+        }
+    }
+    async sendCodexCanonicalLegacyHistory(ws, sessionId, session) {
+        try {
+            const entries = await this.codexCanonicalHistoryEntries(session);
+            if (!entries)
+                return false;
+            this.send(ws, {
+                type: "history",
+                messages: entries.map((entry) => entry.message),
+                sessionId,
+            });
+            this.send(ws, {
+                type: "status",
+                status: session.status,
+                sessionId,
+            });
+            this.sendCodexQueueState(ws, sessionId, session);
+            this.sendCachedCommands(ws, sessionId, session);
+            return true;
+        }
+        catch (err) {
+            this.send(ws, {
+                type: "error",
+                message: `Failed to read Codex thread history: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            return true;
+        }
+    }
+    shouldResetCodexHistoryDelta(session, sinceSeq, resultKind) {
+        if (!this.codexThreadIdForSession(session))
+            return false;
+        if (typeof session.codexCanonicalHistoryRevision !== "number")
+            return true;
+        if (sinceSeq < session.codexCanonicalHistoryRevision)
+            return true;
+        return resultKind === "snapshot";
+    }
+    async codexHistoryToServerMessages(session, history) {
+        const messages = [];
+        for (const item of history) {
+            const converted = await this.codexHistoryMessageToServerMessage(session, item);
+            if (converted)
+                messages.push(converted);
+        }
+        return messages;
+    }
+    async codexHistoryMessageToServerMessage(session, item) {
+        if (item.role === "user") {
+            const images = await this.registerPastUserMessageImages(session, item);
+            const text = this.sessionHistoryText(item.content);
+            if (!text && item.imageCount == null && images.length === 0)
+                return null;
+            return {
+                type: "user_input",
+                text,
+                ...(item.uuid ? { userMessageUuid: item.uuid } : {}),
+                ...(item.isMeta ? { isMeta: true } : {}),
+                ...(item.imageCount != null || images.length > 0
+                    ? { imageCount: Math.max(item.imageCount ?? 0, images.length) }
+                    : {}),
+                ...(item.timestamp ? { timestamp: item.timestamp } : {}),
+                ...(images.length > 0 ? { images } : {}),
+            };
+        }
+        if (item.role === "assistant") {
+            const content = this.sessionHistoryAssistantContent(item.content);
+            if (content.length === 0)
+                return null;
+            const messageId = item.uuid ??
+                this.sessionHistorySingleToolUseId(item.content) ??
+                randomUUID();
+            return {
+                type: "assistant",
+                message: {
+                    id: messageId,
+                    role: "assistant",
+                    content,
+                    model: session.codexSettings?.model ?? "",
+                },
+                ...(item.uuid ? { messageUuid: item.uuid } : {}),
+            };
+        }
+        const images = await this.registerPastToolResultImages(session, item);
+        const content = this.sessionHistoryText(item.content);
+        if (!content && images.length === 0)
+            return null;
+        return {
+            type: "tool_result",
+            toolUseId: item.toolUseId ?? item.uuid ?? `codex-history-tool-${randomUUID()}`,
+            content,
+            ...(item.toolName ? { toolName: item.toolName } : {}),
+            ...(images.length > 0 ? { images } : {}),
+        };
+    }
+    sessionHistoryText(content) {
+        if (typeof content === "string")
+            return content;
+        if (!Array.isArray(content))
+            return "";
+        return content
+            .map((item) => {
+            if (item.type === "text" && typeof item.text === "string") {
+                return item.text;
+            }
+            if (item.type === "thinking" && typeof item.thinking === "string") {
+                return item.thinking;
+            }
+            return "";
+        })
+            .filter((text) => text.length > 0)
+            .join("\n");
+    }
+    sessionHistoryAssistantContent(content) {
+        if (typeof content === "string") {
+            return content.trim().length > 0
+                ? [{ type: "text", text: content }]
+                : [];
+        }
+        if (!Array.isArray(content))
+            return [];
+        const items = [];
+        for (const item of content) {
+            if (item.type === "text" && typeof item.text === "string") {
+                items.push({ type: "text", text: item.text });
+            }
+            else if (item.type === "thinking" &&
+                typeof item.thinking === "string") {
+                items.push({ type: "thinking", thinking: item.thinking });
+            }
+            else if (item.type === "tool_use" &&
+                typeof item.id === "string" &&
+                typeof item.name === "string") {
+                items.push({
+                    type: "tool_use",
+                    id: item.id,
+                    name: item.name,
+                    input: item.input ?? {},
+                });
+            }
+        }
+        return items;
+    }
+    sessionHistorySingleToolUseId(content) {
+        if (!Array.isArray(content) || content.length !== 1)
+            return undefined;
+        const item = content[0];
+        return item.type === "tool_use" && typeof item.id === "string"
+            ? item.id
+            : undefined;
+    }
     async registerPastUserMessageImages(session, msg) {
         if (!this.imageStore)
             return [];
@@ -893,6 +1172,12 @@ export class BridgeWebSocketServer {
             ? msg.images
             : [];
         const refs = [...existingImages];
+        if (Array.isArray(msg.imagePaths)) {
+            const paths = msg.imagePaths.filter((path) => typeof path === "string" && path.length > 0);
+            if (paths.length > 0) {
+                refs.push(...(await this.imageStore.registerImages(paths, session.projectPath)));
+            }
+        }
         if (Array.isArray(msg.imageBase64)) {
             for (const image of msg.imageBase64) {
                 const rawImage = image;
@@ -924,6 +1209,43 @@ export class BridgeWebSocketServer {
         }
         return refs;
     }
+    async registerPastToolResultImages(session, msg) {
+        const existingImages = Array.isArray(msg.images)
+            ? msg.images
+            : [];
+        if (!this.imageStore)
+            return [...existingImages];
+        const paths = new Set();
+        if (Array.isArray(msg.imagePaths)) {
+            for (const path of msg.imagePaths) {
+                if (typeof path === "string" && path.length > 0)
+                    paths.add(path);
+            }
+        }
+        const content = typeof msg.content === "string" ? msg.content : "";
+        if (content) {
+            for (const path of this.imageStore.extractImagePaths(content)) {
+                paths.add(path);
+            }
+        }
+        const refs = [...existingImages];
+        if (paths.size > 0) {
+            refs.push(...(await this.imageStore.registerImages([...paths], session.projectPath)));
+        }
+        if (Array.isArray(msg.imageBase64)) {
+            for (const image of msg.imageBase64) {
+                const rawImage = image;
+                if (typeof rawImage.data !== "string" ||
+                    typeof rawImage.mimeType !== "string") {
+                    continue;
+                }
+                const ref = this.imageStore.registerFromBase64(rawImage.data, rawImage.mimeType);
+                if (ref)
+                    refs.push(ref);
+            }
+        }
+        return refs;
+    }
     async getCodexThreadHistoryFromRpc(threadId, projectPath) {
         const activeProcess = this.getActiveCodexProcess();
         const process = activeProcess ?? (await this.createStandaloneCodexProcess(projectPath));
@@ -932,23 +1254,27 @@ export class BridgeWebSocketServer {
             const thread = await process.readThread(threadId, true);
             return codexThreadToSessionHistory(thread);
         }
+        catch (err) {
+            if (this.isCodexThreadNotMaterializedError(err))
+                return [];
+            throw err;
+        }
         finally {
             if (isStandalone) {
                 process.stop();
             }
         }
     }
+    isCodexThreadNotMaterializedError(err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return (message.includes("is not materialized yet") &&
+            message.includes("includeTurns is unavailable before first user message"));
+    }
     async getCodexThreadHistory(threadId, projectPath) {
         if (!this.getActiveCodexProcess() && process.env.NODE_ENV === "test") {
             return getCodexSessionHistory(threadId);
         }
-        try {
-            return await this.getCodexThreadHistoryFromRpc(threadId, projectPath);
-        }
-        catch (err) {
-            console.warn(`[ws] thread/read failed for ${threadId}; falling back to JSONL: ${err instanceof Error ? err.message : String(err)}`);
-            return getCodexSessionHistory(threadId);
-        }
+        return this.getCodexThreadHistoryFromRpc(threadId, projectPath);
     }
     codexHistoryFromThreadOrFallback(params) {
         const messages = codexThreadToSessionHistory(params.thread);
@@ -1311,7 +1637,7 @@ export class BridgeWebSocketServer {
                 }
                 if (clientMessageId &&
                     baseSeq !== undefined &&
-                    this.hasInputConflictSince(session.id, baseSeq)) {
+                    this.hasInputConflictSince(session, baseSeq)) {
                     this.send(ws, {
                         type: "input_rejected",
                         sessionId: session.id,
@@ -1917,6 +2243,65 @@ export class BridgeWebSocketServer {
                 });
                 break;
             }
+            case "set_codex_model": {
+                const session = this.resolveSession(msg.sessionId);
+                if (!session) {
+                    this.send(ws, { type: "error", message: "No active session." });
+                    return;
+                }
+                if (session.provider !== "codex") {
+                    this.send(ws, {
+                        type: "error",
+                        message: "Model switching is only supported for Codex sessions.",
+                        errorCode: "set_codex_model_unsupported",
+                    });
+                    break;
+                }
+                const model = sanitizeCodexModel(msg.model);
+                if (!model) {
+                    this.send(ws, {
+                        type: "error",
+                        message: `Invalid Codex model: ${msg.model}`,
+                        errorCode: "set_codex_model_rejected",
+                    });
+                    break;
+                }
+                const modelReasoningEffort = msg.modelReasoningEffort;
+                const currentModel = sanitizeCodexModel(session.codexSettings?.model);
+                const currentEffort = session.codexSettings?.modelReasoningEffort;
+                if (model === currentModel && modelReasoningEffort === currentEffort) {
+                    break;
+                }
+                const process = session.process;
+                process.setModel(model, modelReasoningEffort);
+                session.codexSettings = {
+                    ...(session.codexSettings ?? {}),
+                    model,
+                    ...(modelReasoningEffort !== undefined
+                        ? { modelReasoningEffort }
+                        : {}),
+                };
+                session.lastActivityAt = new Date();
+                this.broadcast({
+                    type: "system",
+                    subtype: "set_codex_model",
+                    sessionId: session.id,
+                    provider: "codex",
+                    model,
+                    ...(modelReasoningEffort !== undefined
+                        ? { modelReasoningEffort }
+                        : {}),
+                });
+                this.broadcastSessionList();
+                this.recordDebugEvent(session.id, {
+                    direction: "internal",
+                    channel: "bridge",
+                    type: "codex_model_changed",
+                    detail: `model=${model} effort=${modelReasoningEffort ?? ""}`,
+                });
+                console.log(`[ws] set_codex_model(codex): model=${model} effort=${modelReasoningEffort ?? ""}`);
+                break;
+            }
             case "set_sandbox_mode": {
                 if (this.failSetSandboxMode) {
                     this.send(ws, {
@@ -2252,6 +2637,12 @@ export class BridgeWebSocketServer {
             case "get_history": {
                 const session = this.sessionManager.get(msg.sessionId);
                 if (session) {
+                    if (session.provider === "codex") {
+                        const handled = await this.sendCodexCanonicalLegacyHistory(ws, msg.sessionId, session);
+                        if (handled) {
+                            break;
+                        }
+                    }
                     const splitPastHistory = session.pastMessages && session.pastMessages.length > 0
                         ? await this.splitPastHistoryMessages(session)
                         : { pastMessages: [], historyMessages: [] };
@@ -2275,56 +2666,9 @@ export class BridgeWebSocketServer {
                         sessionId: msg.sessionId,
                     });
                     if (session.provider === "codex") {
-                        const item = session.codexQueuedInput;
-                        this.sendConversationQueue(ws, {
-                            type: "conversation_queue",
-                            sessionId: msg.sessionId,
-                            limit: 1,
-                            items: item
-                                ? [
-                                    {
-                                        itemId: item.itemId,
-                                        text: item.text,
-                                        createdAt: item.createdAt,
-                                        ...(item.updatedAt ? { updatedAt: item.updatedAt } : {}),
-                                        ...(item.imageCount
-                                            ? { imageCount: item.imageCount }
-                                            : {}),
-                                        ...(item.skills?.length ? { skills: item.skills } : {}),
-                                        ...(item.mentions?.length
-                                            ? { mentions: item.mentions }
-                                            : {}),
-                                    },
-                                ]
-                                : [],
-                        });
-                    }
-                    // 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).
-                    const cached = this.sessionManager.getCachedCommands(session.projectPath);
-                    if (cached &&
-                        (cached.slashCommands.length > 0 ||
-                            cached.skills.length > 0 ||
-                            cached.apps.length > 0 ||
-                            cached.plugins.length > 0)) {
-                        this.send(ws, {
-                            type: "system",
-                            subtype: "supported_commands",
-                            sessionId: msg.sessionId,
-                            slashCommands: cached.slashCommands,
-                            skills: cached.skills,
-                            ...(cached.skillMetadata
-                                ? { skillMetadata: cached.skillMetadata }
-                                : {}),
-                            apps: cached.apps,
-                            ...(cached.appMetadata ? { appMetadata: cached.appMetadata } : {}),
-                            plugins: cached.plugins,
-                            ...(cached.pluginMetadata
-                                ? { pluginMetadata: cached.pluginMetadata }
-                                : {}),
-                        });
+                        this.sendCodexQueueState(ws, msg.sessionId, session);
                     }
+                    this.sendCachedCommands(ws, msg.sessionId, session);
                 }
                 else {
                     this.send(ws, {
@@ -2336,8 +2680,40 @@ export class BridgeWebSocketServer {
             }
             case "get_history_delta": {
                 const session = this.sessionManager.get(msg.sessionId);
-                const result = this.sessionManager.getHistorySince(msg.sessionId, msg.sinceSeq);
-                if (session && result) {
+                if (session?.provider === "codex") {
+                    const result = this.sessionManager.getHistorySince(msg.sessionId, msg.sinceSeq);
+                    if (!result) {
+                        this.send(ws, {
+                            type: "error",
+                            message: `Session ${msg.sessionId} not found`,
+                        });
+                        break;
+                    }
+                    if (this.shouldResetCodexHistoryDelta(session, msg.sinceSeq, result.kind)) {
+                        await this.sendCodexCanonicalHistorySnapshot(ws, msg.sessionId, session);
+                        break;
+                    }
+                    this.send(ws, {
+                        type: result.kind === "snapshot" ? "history_snapshot" : "history_delta",
+                        sessionId: msg.sessionId,
+                        fromSeq: result.fromSeq,
+                        toSeq: result.toSeq,
+                        messages: result.entries,
+                        status: session.status,
+                        ...(result.kind === "snapshot" ? { reason: result.reason } : {}),
+                    });
+                    this.sendCodexQueueState(ws, msg.sessionId, session);
+                    break;
+                }
+                if (session) {
+                    const result = this.sessionManager.getHistorySince(msg.sessionId, msg.sinceSeq);
+                    if (!result) {
+                        this.send(ws, {
+                            type: "error",
+                            message: `Session ${msg.sessionId} not found`,
+                        });
+                        break;
+                    }
                     if (session.pastMessages && session.pastMessages.length > 0) {
                         const splitPastHistory = await this.splitPastHistoryMessages(session);
                         if (splitPastHistory.pastMessages.length > 0) {
@@ -2360,31 +2736,6 @@ export class BridgeWebSocketServer {
                         status: session.status,
                         ...(result.kind === "snapshot" ? { reason: result.reason } : {}),
                     });
-                    if (session.provider === "codex") {
-                        const item = session.codexQueuedInput;
-                        this.sendConversationQueue(ws, {
-                            type: "conversation_queue",
-                            sessionId: msg.sessionId,
-                            limit: 1,
-                            items: item
-                                ? [
-                                    {
-                                        itemId: item.itemId,
-                                        text: item.text,
-                                        createdAt: item.createdAt,
-                                        ...(item.updatedAt ? { updatedAt: item.updatedAt } : {}),
-                                        ...(item.imageCount
-                                            ? { imageCount: item.imageCount }
-                                            : {}),
-                                        ...(item.skills?.length ? { skills: item.skills } : {}),
-                                        ...(item.mentions?.length
-                                            ? { mentions: item.mentions }
-                                            : {}),
-                                    },
-                                ]
-                                : [],
-                        });
-                    }
                 }
                 else {
                     this.send(ws, {
@@ -4461,21 +4812,37 @@ export class BridgeWebSocketServer {
             (await this.createStandaloneCodexProcess(msg.projectPath));
         const isStandalone = process !== this.getActiveCodexProcess();
         try {
-            const result = await process.listThreads({
-                limit: limit + offset,
-                cwd: msg.projectPath,
-                searchTerm: msg.searchQuery,
-            });
             const archivedIds = this.archiveStore.archivedIds();
-            const visibleThreads = result.data
-                .filter((thread) => !archivedIds.has(thread.id))
-                .filter((thread) => !msg.namedOnly || !!thread.name)
-                .slice(offset, offset + limit);
-            const indexedById = await getCodexSessionIndexMetadata(visibleThreads.map((thread) => thread.id));
-            const sessions = visibleThreads.map((thread) => codexThreadToRecentSession(thread, indexedById.get(thread.id)));
+            const visibleThreads = [];
+            let cursor;
+            let hasServerMore = false;
+            const targetCount = offset + limit;
+            do {
+                const request = {
+                    limit: Math.max(limit, 1),
+                    cwd: msg.projectPath,
+                    searchTerm: msg.searchQuery,
+                    sourceKinds: CODEX_RECENT_THREAD_SOURCE_KINDS,
+                };
+                if (cursor != null)
+                    request.cursor = cursor;
+                const result = await process.listThreads(request);
+                for (const thread of result.data) {
+                    if (archivedIds.has(thread.id))
+                        continue;
+                    if (msg.namedOnly && !thread.name)
+                        continue;
+                    visibleThreads.push(thread);
+                }
+                cursor = result.nextCursor;
+                hasServerMore = cursor != null;
+            } while (visibleThreads.length < targetCount && cursor != null);
+            const pageThreads = visibleThreads.slice(offset, offset + limit);
+            const indexedById = await getCodexSessionIndexMetadata(pageThreads.map((thread) => thread.id));
+            const sessions = pageThreads.map((thread) => codexThreadToRecentSession(thread, indexedById.get(thread.id)));
             return {
                 sessions,
-                hasMore: result.nextCursor != null,
+                hasMore: hasServerMore || visibleThreads.length > offset + limit,
             };
         }
         finally {
@@ -4683,8 +5050,13 @@ export class BridgeWebSocketServer {
             return true;
         return (this.clientSupportedServerMessages.get(ws)?.has(type) ?? false);
     }
-    hasInputConflictSince(sessionId, baseSeq) {
-        const delta = this.sessionManager.getHistorySince(sessionId, baseSeq);
+    hasInputConflictSince(session, baseSeq) {
+        if (session.provider === "codex" &&
+            typeof session.codexCanonicalHistoryRevision === "number" &&
+            baseSeq < session.codexCanonicalHistoryRevision) {
+            return true;
+        }
+        const delta = this.sessionManager.getHistorySince(session.id, baseSeq);
         if (!delta)
             return true;
         if (delta.kind === "snapshot")
@@ -4703,6 +5075,51 @@ export class BridgeWebSocketServer {
             return false;
         });
     }
+    sendCodexQueueState(ws, sessionId, session) {
+        const item = session.codexQueuedInput;
+        this.sendConversationQueue(ws, {
+            type: "conversation_queue",
+            sessionId,
+            limit: 1,
+            items: item
+                ? [
+                    {
+                        itemId: item.itemId,
+                        text: item.text,
+                        createdAt: item.createdAt,
+                        ...(item.updatedAt ? { updatedAt: item.updatedAt } : {}),
+                        ...(item.imageCount ? { imageCount: item.imageCount } : {}),
+                        ...(item.skills?.length ? { skills: item.skills } : {}),
+                        ...(item.mentions?.length ? { mentions: item.mentions } : {}),
+                    },
+                ]
+                : [],
+        });
+    }
+    sendCachedCommands(ws, sessionId, session) {
+        // Restore command metadata when the original init/supported_commands event
+        // has fallen out of the bounded in-memory history.
+        const cached = this.sessionManager.getCachedCommands(session.projectPath);
+        if (!cached ||
+            (cached.slashCommands.length === 0 &&
+                cached.skills.length === 0 &&
+                cached.apps.length === 0 &&
+                cached.plugins.length === 0)) {
+            return;
+        }
+        this.send(ws, {
+            type: "system",
+            subtype: "supported_commands",
+            sessionId,
+            slashCommands: cached.slashCommands,
+            skills: cached.skills,
+            ...(cached.skillMetadata ? { skillMetadata: cached.skillMetadata } : {}),
+            apps: cached.apps,
+            ...(cached.appMetadata ? { appMetadata: cached.appMetadata } : {}),
+            plugins: cached.plugins,
+            ...(cached.pluginMetadata ? { pluginMetadata: cached.pluginMetadata } : {}),
+        });
+    }
     sendConversationQueue(ws, msg) {
         if (!this.shouldSendToClient(ws, msg))
             return;