@unlinearity/cli-wechat-bridge 1.1.5 → 1.2.0

package/dist/bridge/bridge-adapters.codex.js

@@ -1,17 +1,39 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
 import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
-import { spawn as spawnChild } from "node:child_process";
-import { detectCliApproval, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
+import { spawn as spawnChild, spawnSync } from "node:child_process";
+import { detectCliApproval, } from "./bridge-utils.js";
+import { normalizeOutput, nowIso, summarizeOutput, truncatePreview, } from "../core/text-utils.js";
 import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
 import { killProcessTreeSync } from "./bridge-process-reaper.js";
 import * as shared from "./bridge-adapters.shared.js";
-import { requestCodexVisibleThreadSwitch } from "../companion/codex-visible-client-link.js";
+import { requestCodexVisibleClientShutdown, requestCodexVisibleThreadSwitch, } from "../companion/codex-visible-client-link.js";
+import { readLocalCompanionEndpoint } from "../companion/local-companion-link.js";
 import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { CODEX_REMOTE_AUTH_TOKEN_ENV, LOCAL_CLIENT_PROTOCOL_VERSION, } from "../runtime/runtime-types.js";
+export function parseCodexCliVersion(output) {
+    const match = output.match(/\b(\d+\.\d+\.\d+)\b/);
+    return match?.[1] ?? null;
+}
+export function isCodexVersionInCompatibilityRange(version) {
+    const parts = version.split(".").map((part) => Number(part));
+    if (parts.length !== 3 || parts.some((part) => !Number.isInteger(part))) {
+        return false;
+    }
+    const major = parts[0] ?? -1;
+    const minor = parts[1] ?? -1;
+    return major === 0 && minor >= 149 && minor <= 155;
+}
 const { CODEX_APP_SERVER_HOST, CODEX_APP_SERVER_READY_TIMEOUT_MS, CODEX_FINAL_REPLY_SETTLE_DELAY_MS, CODEX_RECENT_SESSION_KEY_LIMIT, CODEX_RPC_CONNECT_RETRY_MS, CODEX_RPC_RECONNECT_TIMEOUT_MS, CODEX_SESSION_FALLBACK_SCAN_INTERVAL_MS, CODEX_SESSION_LOCAL_MIRROR_FALLBACK_WINDOW_MS, CODEX_SESSION_POLL_INTERVAL_MS, CODEX_STARTUP_WARMUP_MS, CODEX_THREAD_SIGNAL_TTL_MS, INTERRUPT_SETTLE_DELAY_MS, appendBoundedLog, buildCodexApprovalRequest, buildCodexCliArgs, buildCodexDynamicToolCallFailureResponse, buildCodexMcpServerElicitationDeclineResponse, buildCodexPermissionsRequestApprovalResponse, buildCodexUserInputRequest, coerceWebSocketMessageData, delay, describeUnknownError, extractCodexFinalTextFromItem, extractCodexThreadFollowIdFromStatusChanged, extractCodexThreadStartedThreadId, extractCodexUserMessageText, findCodexSessionFile, findRecentCodexSessionFileForCwd, getCodexRpcRequestId, getCodexApprovalAutoResponse, getCodexWechatOutboundAttachmentDenyMessage, getNotificationThreadId, getNotificationTurnId, isRecord, isRecentIsoTimestamp, listCodexResumeSessions, normalizeComparablePath, normalizeCodexRpcError, reserveLocalPort, resolveSpawnTarget, shouldAutoCompleteCodexWechatTurnAfterFinalReply, shouldIgnoreCodexSessionReplayEntry, shouldRecoverCodexStaleBusyState, waitForTcpPort, } = shared;
 const CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS = 150;
 const CODEX_NON_BLOCKING_USER_INPUT_TIMEOUT_MS = 120_000;
+const CODEX_RESUME_REPLAY_SETTLE_MS = 5_000;
 function getCodexThreadStatusType(value) {
     if (typeof value === "string") {
         return value;
@@ -63,14 +85,20 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     appServerAuthToken = null;
     appServerAuthTokenFilePath = null;
     rpcSocket = null;
+    lastRpcCloseDetail = "";
     rpcShuttingDown = false;
     rpcReconnectPromise = null;
     cleanPanelExitInProgress = false;
     rpcRequestCounter = 0;
     pendingRpcRequests = new Map();
     subscribedThreadIds = new Set();
+    pendingThreadSubscriptions = new Map();
     sharedThreadId = null;
+    previousCollaborationMode = null;
     announcedThreadId = null;
+    localThreadFollowBlockedUntilMs = 0;
+    pendingThreadStatusChecks = new Map();
+    threadStatusCheckEpoch = 0;
     pendingThreadAnnouncement = null;
     activeTurn = null;
     bridgeOwnedTurnIds = new Set();
@@ -80,6 +108,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     interruptPendingTurnStart = false;
     pendingThreadFollowId = null;
     pendingVisibleResume = null;
+    bridgeResumeReplayThreadId = null;
+    bridgeResumeReplayUntilMs = 0;
     pendingApprovalRequests = [];
     pendingUserInputRequest = null;
     pendingUserInputTimer = null;
@@ -108,6 +138,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     finalReplyCompletionTimer = null;
     finalReplyCompletionTurnId = null;
     resumeThreadId;
+    codexCliVersion = null;
     localClientInstanceId = `${process.pid}-${Date.now().toString(36)}`;
     constructor(options) {
         super(options);
@@ -126,6 +157,13 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.isHeadlessRuntimeMode()) {
             this.setStatus("starting", `Starting ${this.options.kind} runtime host...`);
         }
+        this.codexCliVersion = this.detectCodexCliVersion();
+        const compatibility = this.codexCliVersion
+            ? isCodexVersionInCompatibilityRange(this.codexCliVersion)
+                ? `compatible=${this.codexCliVersion}`
+                : `outside-supported-range=${this.codexCliVersion}`
+            : "unknown-version";
+        this.setStatus("starting", `Codex protocol compatibility: ${compatibility}.`);
         await this.startAppServer();
         await this.connectRpcClient();
         await this.restoreInitialSharedThreadIfNeeded();
@@ -153,6 +191,13 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             throw err;
         }
     }
+    async prepareVisibleClientSession() {
+        if (this.isNativePanelMode() || this.sharedThreadId) {
+            return Boolean(this.sharedThreadId);
+        }
+        const threadId = await this.ensureThreadStarted();
+        return Boolean(threadId);
+    }
     buildSpawnArgs() {
         if (!this.appServerPort) {
             throw new Error("Codex app-server is not ready.");
@@ -219,6 +264,74 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         await this.resumeVisibleSharedThread(threadId);
     }
+    async listModels() {
+        if (!this.usesRpcTurnTransport() || !this.sharedThreadId) {
+            throw new Error("Codex model selection requires an active app-server thread.");
+        }
+        const response = await this.sendRpcRequest("model/list", { includeHidden: false });
+        const data = isRecord(response) && Array.isArray(response.data) ? response.data : [];
+        const current = await this.readCodexThreadSettings();
+        const models = data.flatMap((item) => {
+            if (!isRecord(item))
+                return [];
+            const id = typeof item.id === "string" ? item.id : typeof item.model === "string" ? item.model : "";
+            if (!id)
+                return [];
+            const displayName = typeof item.displayName === "string" ? item.displayName : id;
+            const efforts = Array.isArray(item.supportedReasoningEfforts)
+                ? item.supportedReasoningEfforts.filter((value) => typeof value === "string")
+                : undefined;
+            return [{ id, displayName, isCurrent: id === current.model, supportedReasoningEfforts: efforts }];
+        });
+        return models;
+    }
+    async selectModel(modelId) {
+        const models = await this.listModels();
+        const selected = models.find((model) => model.id === modelId);
+        if (!selected)
+            throw new Error(`Codex model ${modelId} is not available.`);
+        await this.sendRpcRequest("thread/settings/update", { threadId: this.sharedThreadId, model: selected.id });
+        return selected;
+    }
+    async setPlanMode(enabled) {
+        if (!this.usesRpcTurnTransport() || !this.sharedThreadId) {
+            throw new Error("Codex plan mode requires an active app-server thread.");
+        }
+        const settings = await this.readCodexThreadSettings();
+        if (enabled) {
+            const response = await this.sendRpcRequest("collaborationMode/list", {});
+            const modes = isRecord(response) && Array.isArray(response.data) ? response.data : [];
+            const plan = modes.find((item) => isRecord(item) && (item.mode === "plan" || item.name?.toString().toLowerCase() === "plan"));
+            if (!isRecord(plan))
+                throw new Error("Codex plan mode is not available in this app-server.");
+            this.previousCollaborationMode = isRecord(settings.collaborationMode) ? settings.collaborationMode : null;
+            const mode = typeof plan.mode === "string" ? plan.mode : "plan";
+            const model = typeof plan.model === "string" ? plan.model : settings.model;
+            const effort = plan.reasoning_effort ?? plan.reasoningEffort ?? null;
+            await this.sendRpcRequest("thread/settings/update", {
+                threadId: this.sharedThreadId,
+                collaborationMode: { mode, settings: { model, reasoning_effort: effort, developer_instructions: null } },
+            });
+            return true;
+        }
+        const previous = this.previousCollaborationMode ?? {
+            mode: "default",
+            settings: { model: settings.model, reasoning_effort: settings.effort ?? null, developer_instructions: null },
+        };
+        await this.sendRpcRequest("thread/settings/update", {
+            threadId: this.sharedThreadId,
+            collaborationMode: previous,
+        });
+        this.previousCollaborationMode = null;
+        return false;
+    }
+    async readCodexThreadSettings() {
+        const response = await this.sendRpcRequest("thread/read", { threadId: this.sharedThreadId, includeTurns: false });
+        const thread = isRecord(response) && isRecord(response.thread) ? response.thread : null;
+        if (!thread || typeof thread.model !== "string")
+            throw new Error("Codex did not return the current thread model.");
+        return { model: thread.model, effort: thread.reasoningEffort, collaborationMode: thread.collaborationMode };
+    }
     async interrupt() {
         if (this.usesRpcTurnTransport()) {
             return await this.interruptPanelTurn();
@@ -286,6 +399,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         return true;
     }
     async dispose() {
+        await this.shutdownVisibleClient();
         this.resetTurnTracking({ preserveThread: false });
         if (this.isEmbeddedCliMode()) {
             this.detachLocalInputForwarding();
@@ -317,6 +431,25 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         await this.stopAppServer();
     }
+    async shutdownVisibleClient() {
+        const endpoint = readLocalCompanionEndpoint(this.options.cwd, { adapter: "codex" });
+        if (!endpoint?.companionPid ||
+            endpoint.instanceId !== this.localClientInstanceId ||
+            !endpoint.codexControlPort ||
+            !endpoint.codexControlToken) {
+            return;
+        }
+        try {
+            await requestCodexVisibleClientShutdown({
+                cwd: this.options.cwd,
+                instanceId: endpoint.instanceId,
+            });
+        }
+        catch {
+            // The visible client may already be exiting. Its endpoint is cleared
+            // by the supervisor when the child process finishes.
+        }
+    }
     getLocalClientEndpoint() {
         if (!this.isHeadlessRuntimeMode() || !this.appServerPort || !this.appServerAuthToken) {
             return null;
@@ -406,6 +539,24 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         return this.isNativePanelMode() ? Boolean(this.nativeProcess) : Boolean(this.pty);
     }
+    detectCodexCliVersion() {
+        try {
+            const target = resolveSpawnTarget(this.options.command, "codex", {
+                forwardArgs: ["--version"],
+            });
+            const result = spawnSync(target.file, target.args, {
+                cwd: this.options.cwd,
+                env: this.buildEnv(),
+                encoding: "utf8",
+                timeout: 5_000,
+                windowsHide: true,
+            });
+            return parseCodexCliVersion(`${result.stdout ?? ""}\n${result.stderr ?? ""}`);
+        }
+        catch {
+            return null;
+        }
+    }
     shouldPollSessionLog() {
         return (this.isCodexClientRunning() ||
             this.pendingTurnStart ||
@@ -1145,8 +1296,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         socket.addEventListener("message", (event) => {
             this.handleRpcMessageData(event.data);
         });
-        socket.addEventListener("close", () => {
-            this.handleRpcSocketClosed();
+        socket.addEventListener("close", (event) => {
+            this.handleRpcSocketClosed(event.code, event.reason);
         });
     }
     async disconnectRpcClient() {
@@ -1184,13 +1335,14 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         });
         this.rpcShuttingDown = false;
     }
-    handleRpcSocketClosed() {
+    handleRpcSocketClosed(code, reason) {
         const expectedShutdown = shouldSuppressCodexTransportFatalError({
             transportShuttingDown: this.rpcShuttingDown,
             shuttingDown: this.shuttingDown,
             cleanPanelExitInProgress: this.cleanPanelExitInProgress,
         });
         this.rpcSocket = null;
+        this.lastRpcCloseDetail = `close_code=${code ?? "unknown"}${reason ? ` reason=${truncatePreview(reason, 240)}` : ""}`;
         this.subscribedThreadIds.clear();
         this.rejectPendingRpcRequests("Codex websocket connection closed.");
         this.rpcShuttingDown = false;
@@ -1222,7 +1374,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 const details = this.describeAppServerLog();
                 this.emit({
                     type: "fatal_error",
-                    message: `codex app-server websocket closed unexpectedly.${details}`,
+                    message: `codex app-server websocket closed unexpectedly (${this.lastRpcCloseDetail || "no close details"}).${details}`,
                     timestamp: nowIso(),
                 });
                 this.terminateCodexClient();
@@ -1260,7 +1412,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             }
             this.emit({
                 type: "fatal_error",
-                message: `codex app-server websocket closed unexpectedly and could not reconnect: ${lastError}.${details}`,
+                message: `codex app-server websocket closed unexpectedly and could not reconnect (${this.lastRpcCloseDetail || "no close details"}): ${lastError}.${details}`,
                 timestamp: nowIso(),
             });
             this.terminateCodexClient();
@@ -1335,13 +1487,18 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.subscribedThreadIds.has(threadId)) {
             return true;
         }
-        try {
-            await this.ensureSharedThreadSubscribed(threadId);
-            return true;
-        }
-        catch {
-            return false;
+        const pending = this.pendingThreadSubscriptions.get(threadId);
+        if (pending) {
+            return await pending;
         }
+        const attempt = this.ensureSharedThreadSubscribed(threadId)
+            .then(() => true)
+            .catch(() => false)
+            .finally(() => {
+            this.pendingThreadSubscriptions.delete(threadId);
+        });
+        this.pendingThreadSubscriptions.set(threadId, attempt);
+        return await attempt;
     }
     async ensureSharedThreadSubscribed(threadId) {
         if (this.subscribedThreadIds.has(threadId)) {
@@ -1359,11 +1516,12 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!resumedThreadId) {
             throw new Error("Codex did not return a thread id while subscribing the bridge client.");
         }
+        if (resumedThreadId !== threadId) {
+            throw new Error(`Codex opened ${resumedThreadId}, expected ${threadId}.`);
+        }
+        this.validateCodexThreadWorkspaceIfPresent(response, threadId);
         this.rememberBridgeOwnedThreadSignal(resumedThreadId);
         this.subscribedThreadIds.add(resumedThreadId);
-        if (resumedThreadId !== this.sharedThreadId) {
-            this.updateSharedThread(resumedThreadId);
-        }
     }
     async listAppServerResumeSessions(limit) {
         const boundedLimit = Math.max(1, Math.min(100, limit));
@@ -1407,6 +1565,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (typeof thread.parentThreadId === "string") {
             throw new Error(`Codex thread ${targetThreadId} is a subagent thread and cannot be resumed.`);
         }
+        if (thread.canAcceptDirectInput === false) {
+            throw new Error(`Codex thread ${targetThreadId} is owned by a parent agent and cannot accept direct input.`);
+        }
         if (thread.ephemeral === true) {
             throw new Error(`Codex thread ${targetThreadId} is ephemeral and cannot be resumed.`);
         }
@@ -1415,6 +1576,28 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         return thread;
     }
+    validateCodexThreadWorkspaceIfPresent(response, targetThreadId) {
+        if (!isRecord(response) || !isRecord(response.thread)) {
+            return;
+        }
+        const thread = response.thread;
+        if (typeof thread.id === "string" && thread.id !== targetThreadId) {
+            throw new Error(`Codex opened ${thread.id}, expected ${targetThreadId}.`);
+        }
+        if (typeof thread.cwd === "string" &&
+            normalizeComparablePath(thread.cwd) !== normalizeComparablePath(this.options.cwd)) {
+            throw new Error(`Codex thread ${targetThreadId} does not belong to ${this.options.cwd}.`);
+        }
+        if (typeof thread.parentThreadId === "string") {
+            throw new Error(`Codex thread ${targetThreadId} is a subagent thread.`);
+        }
+        if (thread.canAcceptDirectInput === false) {
+            throw new Error(`Codex thread ${targetThreadId} is owned by a parent agent.`);
+        }
+        if (thread.ephemeral === true) {
+            throw new Error(`Codex thread ${targetThreadId} is ephemeral.`);
+        }
+    }
     async resumeVisibleSharedThread(threadId) {
         const targetThreadId = threadId.trim();
         if (!targetThreadId) {
@@ -1439,17 +1622,19 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.state.status !== "idle") {
             throw new Error(`Codex cannot switch threads while its status is ${this.state.status}.`);
         }
-        const readResponse = await this.sendRpcRequest("thread/read", {
-            threadId: targetThreadId,
-            includeTurns: false,
-        });
-        this.validateCodexResumeThread(readResponse, targetThreadId);
         const previousThreadId = this.sharedThreadId;
         let targetSubscribed = false;
         this.pendingVisibleResume = { targetThreadId };
-        this.setStatus("starting", `Switching Codex to thread ${targetThreadId.slice(0, 12)}...`);
+        this.setStatus("starting", `Codex resume validating thread ${targetThreadId.slice(0, 12)}...`);
         try {
+            const readResponse = await this.sendRpcRequest("thread/read", {
+                threadId: targetThreadId,
+                includeTurns: false,
+            });
+            this.validateCodexResumeThread(readResponse, targetThreadId);
+            this.setStatus("starting", `Codex resume validated thread ${targetThreadId.slice(0, 12)}.`);
             this.rememberBridgeOwnedThreadSignal(targetThreadId);
+            this.setStatus("starting", `Codex resume requesting thread ${targetThreadId.slice(0, 12)}.`);
             const resumeResponse = await this.sendRpcRequest("thread/resume", {
                 threadId: targetThreadId,
                 approvalPolicy: "on-request",
@@ -1460,6 +1645,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             targetSubscribed = true;
             this.validateCodexResumeThread(resumeResponse, targetThreadId);
             this.subscribedThreadIds.add(targetThreadId);
+            this.setStatus("starting", `Codex resume switching visible thread ${targetThreadId.slice(0, 12)}.`);
             const visibleThreadId = await this.switchVisibleCodexThread(targetThreadId);
             if (visibleThreadId !== targetThreadId) {
                 throw new Error(`The visible Codex client opened ${visibleThreadId}, expected ${targetThreadId}.`);
@@ -1474,6 +1660,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 reason: "wechat_resume",
                 notify: true,
             });
+            this.bridgeResumeReplayThreadId = targetThreadId;
+            this.bridgeResumeReplayUntilMs = Date.now() + CODEX_RESUME_REPLAY_SETTLE_MS;
+            this.setStatus("starting", `Codex resume committed thread ${targetThreadId.slice(0, 12)}.`);
             this.setStatus("idle");
             if (previousThreadId && previousThreadId !== targetThreadId) {
                 await this.unsubscribeCodexThreadBestEffort(previousThreadId);
@@ -1483,7 +1672,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             if (targetSubscribed && targetThreadId !== previousThreadId) {
                 await this.unsubscribeCodexThreadBestEffort(targetThreadId);
             }
-            this.setStatus("idle");
+            this.setStatus("idle", `Codex resume failed for ${targetThreadId.slice(0, 12)}: ${describeUnknownError(error)}`);
             throw error;
         }
         finally {
@@ -1533,6 +1722,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!resumedThreadId) {
             throw new Error("Codex did not return a thread id while resuming the saved thread.");
         }
+        this.validateCodexThreadWorkspaceIfPresent(response, resumedThreadId);
         this.rememberBridgeOwnedThreadSignal(resumedThreadId);
         this.subscribedThreadIds.add(resumedThreadId);
         this.sessionFilePath = null;
@@ -1680,6 +1870,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             this.completedTurnOrder = [];
         }
         this.pendingInjectedInputs = [];
+        this.threadStatusCheckEpoch += 1;
+        this.pendingThreadStatusChecks.clear();
+        this.clearBridgeResumeReplay();
         this.recentBridgeThreadSignalAtById.clear();
         this.sessionFinalText = null;
         this.nextSessionFallbackScanAtMs = 0;
@@ -1746,6 +1939,10 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             });
         }
     }
+    blockLateLocalThreadFollow() {
+        this.localThreadFollowBlockedUntilMs =
+            Date.now() + CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS;
+    }
     clearPendingThreadAnnouncement() {
         if (!this.pendingThreadAnnouncement) {
             return;
@@ -1804,16 +2001,29 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         pending.timer.unref?.();
     }
     trackLocalSharedThread(threadId, options) {
+        const weakSignal = options.signal === "status_changed" ||
+            options.signal === "thread_started" ||
+            options.signal === "session_fallback";
+        if (weakSignal && Date.now() < this.localThreadFollowBlockedUntilMs) {
+            return;
+        }
+        if (options.signal === "user_message" || options.signal === "turn_started") {
+            this.localThreadFollowBlockedUntilMs = 0;
+        }
         if (this.pendingVisibleResume) {
             return;
         }
         this.interruptWechatTurnForLocalThreadSwitch(threadId);
         if (!this.isNativePanelMode()) {
+            const threadChanged = this.sharedThreadId !== threadId;
             this.updateSharedThread(threadId, {
                 source: "local",
                 reason: options.reason,
                 notify: true,
             });
+            if (threadChanged) {
+                void this.tryEnsureSharedThreadSubscribed(threadId);
+            }
             return;
         }
         this.updateSharedThread(threadId, {
@@ -1897,6 +2107,20 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         return true;
     }
+    isBridgeResumeReplay(threadId) {
+        if (this.bridgeResumeReplayThreadId !== threadId) {
+            return false;
+        }
+        if (Date.now() >= this.bridgeResumeReplayUntilMs) {
+            this.clearBridgeResumeReplay();
+            return false;
+        }
+        return true;
+    }
+    clearBridgeResumeReplay() {
+        this.bridgeResumeReplayThreadId = null;
+        this.bridgeResumeReplayUntilMs = 0;
+    }
     clearPendingApprovalState() {
         this.pendingApprovalRequests = [];
         this.pendingApproval = null;
@@ -2393,6 +2617,68 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!threadId) {
             return;
         }
+        if (this.pendingVisibleResume) {
+            return;
+        }
+        if (this.isBridgeResumeReplay(threadId)) {
+            return;
+        }
+        const notificationCwd = typeof params.cwd === "string"
+            ? params.cwd
+            : isRecord(params.thread) && typeof params.thread.cwd === "string"
+                ? params.thread.cwd
+                : null;
+        if (notificationCwd &&
+            normalizeComparablePath(notificationCwd) !== normalizeComparablePath(this.options.cwd)) {
+            return;
+        }
+        if (!this.isTrustedThreadStatus(threadId, Boolean(notificationCwd))) {
+            this.queueThreadStatusCwdCheck(threadId);
+            return;
+        }
+        this.applyThreadStatusChanged(threadId);
+    }
+    isTrustedThreadStatus(threadId, hasCwd) {
+        if (hasCwd || this.isNativePanelMode()) {
+            return true;
+        }
+        return (this.subscribedThreadIds.has(threadId) ||
+            this.activeTurn?.threadId === threadId ||
+            this.pendingTurnThreadId === threadId ||
+            this.pendingVisibleResume?.targetThreadId === threadId);
+    }
+    queueThreadStatusCwdCheck(threadId) {
+        if (this.pendingThreadStatusChecks.has(threadId)) {
+            return;
+        }
+        const epoch = this.threadStatusCheckEpoch;
+        const check = this.sendRpcRequest("thread/read", {
+            threadId,
+            includeTurns: false,
+        })
+            .then((response) => {
+            if (epoch !== this.threadStatusCheckEpoch) {
+                return;
+            }
+            if (!isRecord(response) || !isRecord(response.thread)) {
+                return;
+            }
+            const thread = response.thread;
+            if (thread.id === threadId &&
+                typeof thread.cwd === "string" &&
+                normalizeComparablePath(thread.cwd) === normalizeComparablePath(this.options.cwd) &&
+                typeof thread.parentThreadId !== "string" &&
+                thread.ephemeral !== true) {
+                this.applyThreadStatusChanged(threadId);
+            }
+        })
+            .catch(() => undefined)
+            .finally(() => {
+            this.pendingThreadStatusChecks.delete(threadId);
+        });
+        this.pendingThreadStatusChecks.set(threadId, check);
+    }
+    applyThreadStatusChanged(threadId) {
         if (!this.activeTurn ||
             this.activeTurn.threadId === threadId ||
             this.activeTurn.origin === "wechat") {
@@ -2410,12 +2696,18 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!threadId) {
             return;
         }
+        if (this.isBridgeResumeReplay(threadId)) {
+            return;
+        }
         if (this.isRecentlyBridgeOwnedThread(threadId)) {
             return;
         }
         const thread = isRecord(params.thread) ? params.thread : null;
-        if (thread && typeof thread.cwd === "string") {
-            if (normalizeComparablePath(thread.cwd) !== normalizeComparablePath(this.options.cwd)) {
+        if (thread) {
+            if ((typeof thread.cwd === "string" &&
+                normalizeComparablePath(thread.cwd) !== normalizeComparablePath(this.options.cwd)) ||
+                typeof thread.parentThreadId === "string" ||
+                thread.ephemeral === true) {
                 return;
             }
         }
@@ -2435,6 +2727,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.activeTurn?.turnId === trackedTurn.turnId) {
             return;
         }
+        if (trackedTurn.origin === "local") {
+            this.clearBridgeResumeReplay();
+        }
         if (trackedTurn.origin === "local" &&
             trackedTurn.threadId !== this.sharedThreadId) {
             if (!this.activeTurn ||
@@ -2513,6 +2808,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.activeTurn?.turnId === trackedTurn.turnId) {
             this.setActiveTurn(null);
         }
+        if (completedTrackedTurn.origin === "wechat") {
+            this.blockLateLocalThreadFollow();
+        }
         this.cleanupTurnArtifacts(trackedTurn.turnId);
         if (this.state.status !== "stopped" &&
             (!this.activeTurn || this.activeTurn.turnId === trackedTurn.turnId)) {
@@ -2652,6 +2950,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!activeTurn || !finalText) {
             return;
         }
+        if (activeTurn.origin === "wechat") {
+            this.blockLateLocalThreadFollow();
+        }
         this.clearPendingApprovalState();
         this.clearPendingUserInputState();
         this.setActiveTurn(null);
@@ -2712,11 +3013,12 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.appServerAuthToken = null;
     }
     describeAppServerLog() {
-        const summary = normalizeOutput(this.appServerLog).trim();
-        if (!summary) {
+        const normalized = normalizeOutput(this.appServerLog).trim();
+        if (!normalized) {
             return "";
         }
-        return ` Recent app-server log: ${truncatePreview(summary, 220)}`;
+        const summary = summarizeOutput(normalized, 500);
+        return ` Recent app-server log: ${summary}`;
     }
     terminateCodexClient() {
         this.shuttingDown = true;