cli-wechat-bridge 1.0.5

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

@@ -0,0 +1,2228 @@
+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 { AbstractPtyAdapter } from "./bridge-adapters.core.js";
+import * as shared from "./bridge-adapters.shared.js";
+import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
+import { CODEX_REMOTE_AUTH_TOKEN_ENV, LOCAL_CLIENT_PROTOCOL_VERSION, } from "../runtime/runtime-types.js";
+const { CODEX_APP_SERVER_HOST, CODEX_APP_SERVER_LOG_LIMIT, 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, buildCliEnvironment, buildCodexApprovalRequest, buildCodexCliArgs, buildCodexUserInputRequest, coerceWebSocketMessageData, delay, describeUnknownError, extractCodexFinalTextFromItem, extractCodexThreadFollowIdFromStatusChanged, extractCodexThreadStartedThreadId, extractCodexUserMessageText, findCodexSessionFile, findRecentCodexSessionFileForCwd, getCodexRpcRequestId, getNotificationThreadId, getNotificationTurnId, isRecord, isRecentIsoTimestamp, listCodexResumeSessions, normalizeComparablePath, normalizeCodexRpcError, reserveLocalPort, resolveSpawnTarget, shouldAutoCompleteCodexWechatTurnAfterFinalReply, shouldIgnoreCodexSessionReplayEntry, shouldRecoverCodexStaleBusyState, waitForTcpPort, } = shared;
+const CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS = 150;
+export class CodexPtyAdapter extends AbstractPtyAdapter {
+    runtimeKind = "codex_runtime_host";
+    appServer = null;
+    nativeProcess = null;
+    appServerPort = null;
+    appServerShuttingDown = false;
+    appServerLog = "";
+    appServerAuthToken = null;
+    appServerAuthTokenFilePath = null;
+    rpcSocket = null;
+    rpcShuttingDown = false;
+    rpcReconnectPromise = null;
+    cleanPanelExitInProgress = false;
+    rpcRequestCounter = 0;
+    pendingRpcRequests = new Map();
+    sharedThreadId = null;
+    announcedThreadId = null;
+    pendingThreadAnnouncement = null;
+    activeTurn = null;
+    bridgeOwnedTurnIds = new Set();
+    recentBridgeThreadSignalAtById = new Map();
+    pendingTurnStart = false;
+    pendingTurnThreadId = null;
+    interruptPendingTurnStart = false;
+    pendingThreadFollowId = null;
+    pendingApprovalRequest = null;
+    pendingUserInputRequest = null;
+    queuedTurnNotifications = [];
+    queuedTurnServerRequests = [];
+    mirroredUserInputTurnIds = new Set();
+    turnFinalMessages = new Map();
+    turnDeltaByItem = new Map();
+    turnErrorById = new Map();
+    turnLastActivityAtMs = new Map();
+    startupBlocker = null;
+    warmupUntilMs = 0;
+    sessionFilePath = null;
+    sessionPollTimer = null;
+    sessionReadOffset = 0;
+    sessionPartialLine = "";
+    sessionFinalText = null;
+    sessionIgnoreBeforeMs = null;
+    nextSessionFallbackScanAtMs = 0;
+    completedTurnIds = new Set();
+    completedTurnOrder = [];
+    pendingInjectedInputs = [];
+    localInputListener = null;
+    interruptTimer = null;
+    finalReplyCompletionTimer = null;
+    finalReplyCompletionTurnId = null;
+    resumeThreadId;
+    localClientInstanceId = `${process.pid}-${Date.now().toString(36)}`;
+    constructor(options) {
+        super(options);
+        this.resumeThreadId = options.initialSharedSessionId ?? options.initialSharedThreadId ?? null;
+        if (this.resumeThreadId && options.renderMode !== "panel") {
+            this.state.sharedSessionId = this.resumeThreadId;
+            this.state.sharedThreadId = this.resumeThreadId;
+        }
+    }
+    async start() {
+        if (this.isCodexClientRunning()) {
+            return;
+        }
+        if (this.isHeadlessRuntimeMode()) {
+            this.setStatus("starting", `Starting ${this.options.kind} runtime host...`);
+        }
+        await this.startAppServer();
+        await this.connectRpcClient();
+        await this.restoreInitialSharedThreadIfNeeded();
+        try {
+            if (this.isNativePanelMode()) {
+                await this.startNativeClient();
+            }
+            else if (this.isHeadlessRuntimeMode()) {
+                this.shuttingDown = false;
+                this.cleanPanelExitInProgress = false;
+                this.hasAcceptedInput = true;
+                this.state.pid = this.appServer?.pid ?? undefined;
+                this.state.startedAt = nowIso();
+                this.state.pendingApproval = null;
+                this.afterStart();
+                this.setStatus("idle", `${this.options.kind} adapter is ready.`);
+            }
+            else {
+                await super.start();
+            }
+        }
+        catch (err) {
+            await this.disconnectRpcClient();
+            await this.stopAppServer();
+            throw err;
+        }
+    }
+    buildSpawnArgs() {
+        if (!this.appServerPort) {
+            throw new Error("Codex app-server is not ready.");
+        }
+        return buildCodexCliArgs(`ws://${CODEX_APP_SERVER_HOST}:${this.appServerPort}`, {
+            inlineMode: this.options.renderMode !== "panel",
+            profile: this.options.profile,
+            extraCliArgs: this.options.extraCliArgs,
+        });
+    }
+    afterStart() {
+        this.warmupUntilMs = this.usesRpcTurnTransport()
+            ? 0
+            : Date.now() + CODEX_STARTUP_WARMUP_MS;
+        if (this.isEmbeddedCliMode()) {
+            this.attachLocalInputForwarding();
+        }
+        this.startSessionPolling();
+    }
+    async sendInput(text) {
+        if (this.usesRpcTurnTransport()) {
+            await this.sendPanelTurn(text);
+            return;
+        }
+        if (!this.pty) {
+            throw new Error("codex adapter is not running.");
+        }
+        if (this.state.status === "busy") {
+            throw new Error("codex is still working. Wait for the current reply or use /stop.");
+        }
+        if (this.pendingApproval) {
+            throw new Error("A Codex approval request is pending. Reply with /confirm <code> or /deny.");
+        }
+        if (this.startupBlocker) {
+            throw new Error("Codex is waiting for local terminal input before the session can continue.");
+        }
+        await delay(this.warmupUntilMs - Date.now());
+        if (!this.pty) {
+            throw new Error("codex adapter is not running.");
+        }
+        if (this.startupBlocker) {
+            throw new Error("Codex is waiting for local terminal input before the session can continue.");
+        }
+        this.clearInterruptTimer();
+        this.hasAcceptedInput = true;
+        this.currentPreview = truncatePreview(text);
+        this.state.lastInputAt = nowIso();
+        this.rememberInjectedInput(text);
+        this.setStatus("busy");
+        this.state.activeTurnOrigin = "wechat";
+        await this.typeIntoPty(text.replace(/\r?\n/g, "\r"));
+        await delay(40);
+        this.writeToPty("\r");
+    }
+    async listResumeSessions(limit = 10) {
+        return listCodexResumeSessions(this.options.cwd, limit);
+    }
+    async resumeSession(threadId) {
+        if (this.isNativePanelMode()) {
+            throw new Error('WeChat /resume is disabled in codex mode. Use /resume directly inside "wechat-codex"; WeChat will follow the active local thread.');
+        }
+        await this.resumeSharedThread(threadId);
+    }
+    async interrupt() {
+        if (this.usesRpcTurnTransport()) {
+            return await this.interruptPanelTurn();
+        }
+        if (!this.pty) {
+            return false;
+        }
+        if (this.state.status !== "busy" && this.state.status !== "awaiting_approval") {
+            return false;
+        }
+        this.clearPendingApprovalState();
+        this.writeToPty("\u0003");
+        this.armInterruptFallback();
+        return true;
+    }
+    async resolveApproval(action) {
+        if (!this.pendingApproval) {
+            return false;
+        }
+        if (this.pendingApprovalRequest && this.rpcSocket) {
+            const request = this.pendingApprovalRequest;
+            await this.respondToApprovalRequest(request, action);
+            this.clearPendingApprovalState();
+            this.setStatus("busy");
+            return true;
+        }
+        return await super.resolveApproval(action);
+    }
+    async dispose() {
+        this.resetTurnTracking({ preserveThread: false });
+        if (this.isEmbeddedCliMode()) {
+            this.detachLocalInputForwarding();
+        }
+        this.stopSessionPolling();
+        if (this.isNativePanelMode()) {
+            this.cleanPanelExitInProgress = true;
+        }
+        await this.disconnectRpcClient();
+        if (this.isNativePanelMode()) {
+            await this.stopNativeClient();
+            this.clearCompletionTimer();
+            this.pendingApproval = null;
+            this.state.pendingApproval = null;
+            this.state.status = "stopped";
+            this.state.pid = undefined;
+            this.state.startedAt = undefined;
+        }
+        else if (this.isHeadlessRuntimeMode()) {
+            this.clearCompletionTimer();
+            this.clearInterruptTimer();
+            this.clearPendingApprovalState();
+            this.state.status = "stopped";
+            this.state.pid = undefined;
+            this.state.startedAt = undefined;
+        }
+        else {
+            await super.dispose();
+        }
+        await this.stopAppServer();
+    }
+    getLocalClientEndpoint() {
+        if (!this.isHeadlessRuntimeMode() || !this.appServerPort || !this.appServerAuthToken) {
+            return null;
+        }
+        return {
+            protocolVersion: LOCAL_CLIENT_PROTOCOL_VERSION,
+            runtimeKind: this.runtimeKind,
+            instanceId: this.localClientInstanceId,
+            kind: this.options.kind,
+            port: this.appServerPort,
+            token: this.appServerAuthToken,
+            renderMode: "headless",
+            bridgeOwnerPid: process.pid,
+            serverPort: this.appServerPort,
+            serverUrl: `ws://${CODEX_APP_SERVER_HOST}:${this.appServerPort}`,
+            remoteAuthTokenEnv: CODEX_REMOTE_AUTH_TOKEN_ENV,
+            cwd: this.options.cwd,
+            command: this.options.command,
+            profile: this.options.profile,
+            sharedSessionId: this.state.sharedSessionId,
+            sharedThreadId: this.state.sharedThreadId,
+            resumeConversationId: this.state.resumeConversationId,
+            transcriptPath: this.state.transcriptPath,
+            startedAt: this.state.startedAt ?? nowIso(),
+        };
+    }
+    handleData(rawText) {
+        this.renderLocalOutput(rawText);
+        const text = normalizeOutput(rawText);
+        if (!text) {
+            return;
+        }
+        this.state.lastOutputAt = nowIso();
+        const approval = detectCliApproval(text);
+        if (this.hasAcceptedInput) {
+            if (approval && !this.pendingApproval) {
+                this.pendingApproval = approval;
+                this.state.pendingApproval = approval;
+                this.state.pendingApprovalOrigin = this.state.activeTurnOrigin;
+                this.setStatus("awaiting_approval", "Codex approval is required.");
+                this.emit({
+                    type: "approval_required",
+                    request: approval,
+                    timestamp: nowIso(),
+                });
+            }
+            return;
+        }
+        if (approval) {
+            this.startupBlocker = approval.commandPreview;
+            if (this.state.status !== "awaiting_approval") {
+                this.setStatus("awaiting_approval", "Codex is waiting for local terminal input.");
+            }
+            return;
+        }
+        if (this.startupBlocker) {
+            this.startupBlocker = null;
+            if (this.state.status === "awaiting_approval") {
+                this.setStatus("idle", "codex adapter is ready.");
+            }
+        }
+    }
+    handleExit(exitCode) {
+        this.resetTurnTracking({ preserveThread: false });
+        this.detachLocalInputForwarding();
+        this.stopSessionPolling();
+        void this.disconnectRpcClient();
+        void this.stopAppServer();
+        super.handleExit(exitCode);
+    }
+    isNativePanelMode() {
+        return this.options.renderMode === "panel";
+    }
+    isHeadlessRuntimeMode() {
+        return this.options.renderMode === "headless";
+    }
+    isEmbeddedCliMode() {
+        return !this.isNativePanelMode() && !this.isHeadlessRuntimeMode();
+    }
+    usesRpcTurnTransport() {
+        return this.isNativePanelMode() || this.isHeadlessRuntimeMode();
+    }
+    isCodexClientRunning() {
+        if (this.isHeadlessRuntimeMode()) {
+            return Boolean(this.appServer);
+        }
+        return this.isNativePanelMode() ? Boolean(this.nativeProcess) : Boolean(this.pty);
+    }
+    shouldPollSessionLog() {
+        return (this.isCodexClientRunning() ||
+            this.pendingTurnStart ||
+            Boolean(this.activeTurn) ||
+            Boolean(this.state.activeTurnId) ||
+            Boolean(this.sessionFilePath));
+    }
+    async startNativeClient() {
+        this.setStatus("starting", `Starting ${this.options.kind} adapter...`);
+        let spawnTarget = null;
+        try {
+            spawnTarget = resolveSpawnTarget(this.options.command, this.options.kind);
+            const child = spawnChild(spawnTarget.file, [...spawnTarget.args, ...this.buildSpawnArgs()], {
+                cwd: this.options.cwd,
+                env: this.buildEnv(),
+                stdio: "inherit",
+                windowsHide: false,
+            });
+            this.nativeProcess = child;
+            this.shuttingDown = false;
+            this.cleanPanelExitInProgress = false;
+            this.hasAcceptedInput = false;
+            this.state.pid = child.pid ?? undefined;
+            this.state.startedAt = nowIso();
+            this.state.status = "idle";
+            this.state.pendingApproval = null;
+            child.once("error", (error) => {
+                if (this.nativeProcess === child) {
+                    this.handleNativeExit(undefined, undefined, error);
+                }
+            });
+            child.once("exit", (exitCode, signal) => {
+                if (this.nativeProcess === child) {
+                    this.handleNativeExit(exitCode ?? undefined, signal ?? undefined);
+                }
+            });
+            this.afterStart();
+            this.setStatus("idle", `${this.options.kind} adapter is ready.`);
+        }
+        catch (err) {
+            this.state.status = "error";
+            this.emit({
+                type: "fatal_error",
+                message: `Failed to start ${this.options.kind}${spawnTarget ? ` (${spawnTarget.file})` : ""}: ${String(err)}`,
+                timestamp: nowIso(),
+            });
+            throw err;
+        }
+    }
+    handleNativeExit(exitCode, signal, startupError) {
+        const expectedShutdown = shouldTreatCodexNativeExitAsExpected({
+            renderMode: this.options.renderMode,
+            shuttingDown: this.shuttingDown,
+            exitCode,
+            signal,
+            startupError,
+        });
+        if (expectedShutdown && this.isNativePanelMode()) {
+            this.cleanPanelExitInProgress = true;
+        }
+        this.clearCompletionTimer();
+        this.resetTurnTracking({ preserveThread: false });
+        this.stopSessionPolling();
+        void this.disconnectRpcClient();
+        void this.stopAppServer();
+        this.shuttingDown = false;
+        this.nativeProcess = null;
+        this.state.status = "stopped";
+        this.state.pid = undefined;
+        this.pendingApproval = null;
+        this.state.pendingApproval = null;
+        if (expectedShutdown) {
+            this.emit({
+                type: "status",
+                status: "stopped",
+                message: `${this.options.kind} worker stopped.`,
+                timestamp: nowIso(),
+            });
+            return;
+        }
+        const exitLabel = startupError
+            ? startupError.message
+            : signal
+                ? `signal ${signal}`
+                : typeof exitCode === "number"
+                    ? `code ${exitCode}`
+                    : "an unknown code";
+        this.emit({
+            type: "fatal_error",
+            message: `${this.options.kind} worker exited unexpectedly with ${exitLabel}.`,
+            timestamp: nowIso(),
+        });
+    }
+    async stopNativeClient() {
+        if (!this.nativeProcess) {
+            this.state.pid = undefined;
+            return;
+        }
+        const child = this.nativeProcess;
+        this.shuttingDown = true;
+        this.nativeProcess = null;
+        await new Promise((resolve) => {
+            let settled = false;
+            const finish = () => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                resolve();
+            };
+            child.once("exit", () => finish());
+            try {
+                child.kill();
+            }
+            catch {
+                finish();
+            }
+            const timer = setTimeout(() => finish(), 1_500);
+            timer.unref?.();
+        });
+    }
+    startSessionPolling() {
+        this.stopSessionPolling();
+        const poll = () => {
+            void this.pollSessionLog();
+        };
+        this.sessionPollTimer = setInterval(poll, CODEX_SESSION_POLL_INTERVAL_MS);
+        this.sessionPollTimer.unref?.();
+        poll();
+    }
+    stopSessionPolling() {
+        if (this.sessionPollTimer) {
+            clearInterval(this.sessionPollTimer);
+            this.sessionPollTimer = null;
+        }
+        this.sessionFilePath = null;
+        this.sessionReadOffset = 0;
+        this.sessionPartialLine = "";
+        this.sessionFinalText = null;
+        this.sessionIgnoreBeforeMs = null;
+        this.nextSessionFallbackScanAtMs = 0;
+    }
+    async pollSessionLog() {
+        if (!this.shouldPollSessionLog()) {
+            return;
+        }
+        this.maybeApplyRecentSessionFallback();
+        if (!this.sessionFilePath) {
+            const startedAtMs = this.state.startedAt ? Date.parse(this.state.startedAt) : Date.now();
+            this.sessionFilePath = findCodexSessionFile(this.options.cwd, startedAtMs, { threadId: this.sharedThreadId ?? undefined });
+            if (!this.sessionFilePath) {
+                return;
+            }
+            this.sessionReadOffset = 0;
+            this.sessionPartialLine = "";
+            this.seedSessionReplayCutoff(startedAtMs);
+        }
+        let content;
+        try {
+            content = fs.readFileSync(this.sessionFilePath, "utf8");
+        }
+        catch {
+            this.sessionFilePath = null;
+            this.sessionReadOffset = 0;
+            this.sessionPartialLine = "";
+            return;
+        }
+        if (content.length < this.sessionReadOffset) {
+            this.sessionReadOffset = 0;
+            this.sessionPartialLine = "";
+        }
+        if (content.length === this.sessionReadOffset) {
+            return;
+        }
+        const chunk = content.slice(this.sessionReadOffset);
+        this.sessionReadOffset = content.length;
+        const lines = `${this.sessionPartialLine}${chunk}`.split(/\r?\n/);
+        this.sessionPartialLine = lines.pop() ?? "";
+        for (const line of lines) {
+            this.handleSessionLogLine(line);
+        }
+    }
+    seedSessionReplayCutoff(startedAtMs) {
+        if (this.sessionIgnoreBeforeMs !== null ||
+            this.pendingTurnStart ||
+            this.activeTurn ||
+            this.state.activeTurnId) {
+            return;
+        }
+        if (Number.isFinite(startedAtMs)) {
+            this.sessionIgnoreBeforeMs = startedAtMs;
+        }
+    }
+    maybeApplyRecentSessionFallback() {
+        if (!this.isNativePanelMode()) {
+            return;
+        }
+        const now = Date.now();
+        if (now < this.nextSessionFallbackScanAtMs) {
+            return;
+        }
+        this.nextSessionFallbackScanAtMs = now + CODEX_SESSION_FALLBACK_SCAN_INTERVAL_MS;
+        const startedAtMs = this.state.startedAt ? Date.parse(this.state.startedAt) : now;
+        const candidate = findRecentCodexSessionFileForCwd(this.options.cwd, startedAtMs);
+        if (!candidate) {
+            return;
+        }
+        let currentSessionModifiedAtMs = Number.NEGATIVE_INFINITY;
+        if (this.sessionFilePath) {
+            try {
+                currentSessionModifiedAtMs = fs.statSync(this.sessionFilePath).mtimeMs;
+            }
+            catch {
+                currentSessionModifiedAtMs = Number.NEGATIVE_INFINITY;
+            }
+        }
+        if (candidate.threadId !== this.sharedThreadId) {
+            if (this.sessionFilePath && candidate.modifiedAtMs <= currentSessionModifiedAtMs) {
+                return;
+            }
+            if (!this.activeTurn || this.activeTurn.threadId === candidate.threadId) {
+                this.trackLocalSharedThread(candidate.threadId, {
+                    reason: "local_session_fallback",
+                    signal: "session_fallback",
+                });
+                this.pendingThreadFollowId = null;
+            }
+            else {
+                this.pendingThreadFollowId = candidate.threadId;
+            }
+        }
+        if (this.sessionFilePath !== candidate.filePath) {
+            this.sessionFilePath = candidate.filePath;
+            this.sessionReadOffset = 0;
+            this.sessionPartialLine = "";
+            this.sessionFinalText = null;
+            this.seedSessionReplayCutoff(startedAtMs);
+        }
+    }
+    handleSessionLogLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            return;
+        }
+        if (!isRecord(parsed) || !isRecord(parsed.payload) || typeof parsed.payload.type !== "string") {
+            return;
+        }
+        if (shouldIgnoreCodexSessionReplayEntry(parsed.timestamp, this.sessionIgnoreBeforeMs)) {
+            return;
+        }
+        const payload = parsed.payload;
+        const timestamp = typeof parsed.timestamp === "string" ? parsed.timestamp : nowIso();
+        if (this.sessionIgnoreBeforeMs !== null) {
+            this.sessionIgnoreBeforeMs = null;
+        }
+        switch (payload.type) {
+            case "task_started": {
+                if (typeof payload.turn_id === "string") {
+                    this.recordTurnActivity(payload.turn_id, timestamp);
+                    this.hasAcceptedInput = true;
+                    this.state.activeTurnId = payload.turn_id;
+                    const hasTrackedTurnContext = this.pendingTurnStart ||
+                        Boolean(this.activeTurn) ||
+                        this.state.activeTurnOrigin === "local" ||
+                        this.state.activeTurnOrigin === "wechat";
+                    if (hasTrackedTurnContext &&
+                        this.state.status !== "busy" &&
+                        this.state.status !== "awaiting_approval") {
+                        const message = this.state.activeTurnOrigin === "local"
+                            ? "Codex is busy with a local terminal turn."
+                            : undefined;
+                        this.setStatus("busy", message);
+                    }
+                }
+                return;
+            }
+            case "user_message": {
+                if (typeof payload.message !== "string") {
+                    return;
+                }
+                const message = normalizeOutput(payload.message).trim();
+                if (!message) {
+                    return;
+                }
+                this.hasAcceptedInput = true;
+                this.state.lastInputAt = timestamp;
+                const origin = this.consumeInjectedInput(message) ? "wechat" : "local";
+                this.state.activeTurnOrigin = origin;
+                if (origin === "local") {
+                    const turnId = this.activeTurn?.turnId ?? this.state.activeTurnId ?? null;
+                    if (turnId && !this.mirroredUserInputTurnIds.has(turnId)) {
+                        this.mirroredUserInputTurnIds.add(turnId);
+                        this.emit({
+                            type: "mirrored_user_input",
+                            text: message,
+                            timestamp,
+                            origin: "local",
+                        });
+                    }
+                    if (this.state.status !== "busy" && this.state.status !== "awaiting_approval") {
+                        this.setStatus("busy", "Codex is busy with a local terminal turn.");
+                    }
+                    if (!turnId &&
+                        !this.isRpcSocketOpen() &&
+                        isRecentIsoTimestamp(timestamp, CODEX_SESSION_LOCAL_MIRROR_FALLBACK_WINDOW_MS)) {
+                        this.emit({
+                            type: "mirrored_user_input",
+                            text: message,
+                            timestamp,
+                            origin: "local",
+                        });
+                    }
+                }
+                return;
+            }
+            case "agent_message": {
+                if (payload.phase !== "final_answer" || typeof payload.message !== "string") {
+                    return;
+                }
+                const message = normalizeOutput(payload.message).trim();
+                if (message) {
+                    this.sessionFinalText = message;
+                    this.state.lastOutputAt = timestamp;
+                    const activeTurnId = this.activeTurn?.turnId ?? this.state.activeTurnId ?? null;
+                    if (activeTurnId) {
+                        this.recordTurnActivity(activeTurnId, timestamp);
+                        this.scheduleFinalReplyCompletionIfEligible(activeTurnId);
+                    }
+                }
+                return;
+            }
+            case "task_complete": {
+                if (typeof payload.turn_id !== "string") {
+                    return;
+                }
+                this.clearFinalReplyCompletionTimerForTurn(payload.turn_id);
+                if (this.hasCompletedTurn(payload.turn_id)) {
+                    this.sessionFinalText = null;
+                    if (this.activeTurn?.turnId === payload.turn_id) {
+                        this.setActiveTurn(null);
+                    }
+                    this.cleanupTurnArtifacts(payload.turn_id);
+                    if (this.state.status !== "stopped") {
+                        this.setStatus("idle");
+                    }
+                    return;
+                }
+                const finalText = this.sessionFinalText ||
+                    (typeof payload.last_agent_message === "string"
+                        ? normalizeOutput(payload.last_agent_message).trim()
+                        : "");
+                const completionOrigin = this.activeTurn?.turnId === payload.turn_id
+                    ? this.activeTurn.origin
+                    : this.state.activeTurnOrigin;
+                this.sessionFinalText = null;
+                if (this.activeTurn?.turnId === payload.turn_id) {
+                    this.setActiveTurn(null);
+                }
+                else if (this.state.activeTurnId === payload.turn_id) {
+                    this.state.activeTurnId = undefined;
+                    this.state.activeTurnOrigin = undefined;
+                }
+                this.clearPendingApprovalState();
+                this.cleanupTurnArtifacts(payload.turn_id);
+                if (this.state.status !== "stopped") {
+                    this.setStatus("idle");
+                }
+                if (finalText) {
+                    this.emit({
+                        type: "final_reply",
+                        text: finalText,
+                        timestamp,
+                    });
+                }
+                this.emit({
+                    type: "task_complete",
+                    summary: completionOrigin === "local"
+                        ? "Local terminal turn completed."
+                        : this.currentPreview,
+                    timestamp,
+                });
+                this.rememberCompletedTurn(payload.turn_id);
+                return;
+            }
+        }
+    }
+    rememberInjectedInput(text) {
+        const normalizedText = normalizeOutput(text).trim();
+        if (!normalizedText) {
+            return;
+        }
+        const cutoff = Date.now() - 60_000;
+        this.pendingInjectedInputs = this.pendingInjectedInputs.filter((entry) => entry.createdAtMs >= cutoff);
+        this.pendingInjectedInputs.push({
+            text,
+            normalizedText,
+            createdAtMs: Date.now(),
+        });
+        if (this.pendingInjectedInputs.length > 8) {
+            this.pendingInjectedInputs.splice(0, this.pendingInjectedInputs.length - 8);
+        }
+    }
+    consumeInjectedInput(message) {
+        const normalizedMessage = normalizeOutput(message).trim();
+        if (!normalizedMessage) {
+            return false;
+        }
+        const cutoff = Date.now() - 60_000;
+        this.pendingInjectedInputs = this.pendingInjectedInputs.filter((entry) => entry.createdAtMs >= cutoff);
+        const index = this.pendingInjectedInputs.findIndex((entry) => entry.normalizedText === normalizedMessage);
+        if (index < 0) {
+            return false;
+        }
+        this.pendingInjectedInputs.splice(index, 1);
+        return true;
+    }
+    async typeIntoPty(text) {
+        for (const character of text) {
+            this.writeToPty(character);
+            await delay(4);
+        }
+    }
+    async sendPanelTurn(text) {
+        if (this.isNativePanelMode() && !this.nativeProcess) {
+            throw new Error("codex panel is not running.");
+        }
+        this.recoverStaleBusyStateIfNeeded();
+        this.recoverStaleActiveTurnStateIfNeeded();
+        if (this.pendingApproval) {
+            throw new Error("A Codex approval request is pending. Reply with /confirm <code> or /deny.");
+        }
+        if (this.pendingTurnStart || this.activeTurn || this.state.status === "busy") {
+            const origin = this.state.activeTurnOrigin;
+            if (origin === "local") {
+                throw new Error("The local Codex panel is still working. Wait for the current reply or use /stop.");
+            }
+            throw new Error("codex is still working. Wait for the current reply or use /stop.");
+        }
+        this.clearInterruptTimer();
+        this.hasAcceptedInput = true;
+        this.currentPreview = truncatePreview(text);
+        this.state.lastInputAt = nowIso();
+        this.rememberInjectedInput(text);
+        this.clearPendingApprovalState();
+        const threadId = await this.ensureThreadStarted();
+        this.pendingTurnStart = true;
+        this.pendingTurnThreadId = threadId;
+        this.interruptPendingTurnStart = false;
+        this.state.activeTurnOrigin = "wechat";
+        this.setStatus("busy");
+        try {
+            const response = await this.sendRpcRequest("turn/start", {
+                threadId,
+                cwd: this.options.cwd,
+                approvalPolicy: "on-request",
+                approvalsReviewer: "user",
+                input: [
+                    {
+                        type: "text",
+                        text,
+                    },
+                ],
+            });
+            const turnId = this.extractTurnIdFromResponse(response);
+            if (!turnId) {
+                throw new Error("Codex did not return a turn id for the requested turn.");
+            }
+            this.bindActiveTurn({
+                threadId,
+                turnId,
+                origin: "wechat",
+            });
+            if (this.interruptPendingTurnStart) {
+                await this.requestActiveTurnInterrupt();
+                this.armInterruptFallback();
+            }
+        }
+        catch (error) {
+            this.pendingTurnStart = false;
+            this.pendingTurnThreadId = null;
+            this.interruptPendingTurnStart = false;
+            this.state.activeTurnOrigin = undefined;
+            if (!this.activeTurn && this.getState().status === "busy") {
+                this.setStatus("idle");
+            }
+            throw error;
+        }
+    }
+    async interruptPanelTurn() {
+        if (this.isNativePanelMode() && !this.nativeProcess) {
+            return false;
+        }
+        const turnPending = this.pendingTurnStart || this.state.status === "busy" || this.state.status === "awaiting_approval";
+        if (!turnPending) {
+            return false;
+        }
+        this.clearPendingApprovalState();
+        if (this.pendingTurnStart && !this.activeTurn) {
+            this.interruptPendingTurnStart = true;
+            this.armInterruptFallback();
+            return true;
+        }
+        if (!this.activeTurn) {
+            return false;
+        }
+        await this.requestActiveTurnInterrupt();
+        this.armInterruptFallback();
+        return true;
+    }
+    async startAppServer() {
+        if (this.appServer) {
+            return;
+        }
+        const port = await reserveLocalPort();
+        const env = this.buildEnv();
+        const workspacePaths = ensureWorkspaceChannelDir(this.options.cwd);
+        const token = crypto.randomBytes(24).toString("hex");
+        const tokenFilePath = path.join(workspacePaths.workspaceDir, `codex-app-server-token-${this.localClientInstanceId}.txt`);
+        fs.writeFileSync(tokenFilePath, `${token}\n`, "utf8");
+        const spawnTarget = resolveSpawnTarget(this.options.command, "codex");
+        const child = spawnChild(spawnTarget.file, [
+            ...spawnTarget.args,
+            "app-server",
+            "--listen",
+            `ws://${CODEX_APP_SERVER_HOST}:${port}`,
+            "--ws-auth",
+            "capability-token",
+            "--ws-token-file",
+            tokenFilePath,
+        ], {
+            cwd: this.options.cwd,
+            env,
+            stdio: "pipe",
+            windowsHide: true,
+        });
+        this.appServer = child;
+        this.appServerPort = port;
+        this.appServerShuttingDown = false;
+        this.appServerLog = "";
+        this.appServerAuthToken = token;
+        this.appServerAuthTokenFilePath = tokenFilePath;
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            this.appServerLog = appendBoundedLog(this.appServerLog, chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            this.appServerLog = appendBoundedLog(this.appServerLog, chunk);
+        });
+        child.on("exit", (code, signal) => {
+            const expectedShutdown = shouldSuppressCodexTransportFatalError({
+                transportShuttingDown: this.appServerShuttingDown,
+                shuttingDown: this.shuttingDown,
+                cleanPanelExitInProgress: this.cleanPanelExitInProgress,
+            });
+            this.appServer = null;
+            this.appServerPort = null;
+            this.appServerShuttingDown = false;
+            this.deleteAppServerAuthTokenFile();
+            this.appServerAuthToken = null;
+            if (expectedShutdown) {
+                return;
+            }
+            const exitLabel = signal ? `signal ${signal}` : `code ${typeof code === "number" ? code : "unknown"}`;
+            const details = this.describeAppServerLog();
+            this.emit({
+                type: "fatal_error",
+                message: `codex app-server exited unexpectedly with ${exitLabel}.${details}`,
+                timestamp: nowIso(),
+            });
+            this.terminateCodexClient();
+        });
+        try {
+            await waitForTcpPort(CODEX_APP_SERVER_HOST, port, CODEX_APP_SERVER_READY_TIMEOUT_MS);
+        }
+        catch (err) {
+            await this.stopAppServer();
+            const details = this.describeAppServerLog();
+            throw new Error(`Failed to start Codex app-server: ${String(err)}${details}`, {
+                cause: err,
+            });
+        }
+    }
+    async connectRpcClient() {
+        if (this.rpcSocket) {
+            return;
+        }
+        if (!this.appServerPort) {
+            throw new Error("Codex app-server is not ready.");
+        }
+        if (typeof WebSocket !== "function") {
+            throw new Error("Global WebSocket is unavailable in this runtime.");
+        }
+        const url = `ws://${CODEX_APP_SERVER_HOST}:${this.appServerPort}`;
+        const deadline = Date.now() + CODEX_APP_SERVER_READY_TIMEOUT_MS;
+        let lastError = "Timed out before the websocket became ready.";
+        while (Date.now() < deadline) {
+            try {
+                const socket = await this.openRpcSocket(url, this.appServerAuthToken, deadline - Date.now());
+                this.attachRpcSocket(socket);
+                await this.initializeRpcClient();
+                return;
+            }
+            catch (err) {
+                lastError = describeUnknownError(err);
+                await this.disconnectRpcClient();
+                await delay(CODEX_RPC_CONNECT_RETRY_MS);
+            }
+        }
+        throw new Error(`Failed to connect to Codex app-server websocket: ${lastError}`);
+    }
+    async openRpcSocket(url, authToken, timeoutMs) {
+        if (!authToken) {
+            throw new Error("Codex app-server websocket auth token is unavailable.");
+        }
+        return await new Promise((resolve, reject) => {
+            const socket = new WebSocket(url, {
+                headers: {
+                    Authorization: `Bearer ${authToken}`,
+                },
+            });
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                try {
+                    socket.close();
+                }
+                catch {
+                    // Best effort cleanup after timeout.
+                }
+                reject(new Error(`Timed out opening Codex websocket ${url}.`));
+            }, Math.max(500, timeoutMs));
+            const cleanup = () => {
+                clearTimeout(timer);
+            };
+            socket.addEventListener("open", () => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                resolve(socket);
+            }, { once: true });
+            socket.addEventListener("error", () => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                reject(new Error(`Failed to open Codex websocket ${url}.`));
+            }, { once: true });
+        });
+    }
+    attachRpcSocket(socket) {
+        this.rpcSocket = socket;
+        this.rpcShuttingDown = false;
+        socket.addEventListener("message", (event) => {
+            this.handleRpcMessageData(event.data);
+        });
+        socket.addEventListener("close", () => {
+            this.handleRpcSocketClosed();
+        });
+    }
+    async disconnectRpcClient() {
+        const socket = this.rpcSocket;
+        this.rpcSocket = null;
+        this.rpcShuttingDown = true;
+        this.rejectPendingRpcRequests("Codex websocket connection closed.");
+        if (!socket) {
+            this.rpcShuttingDown = false;
+            return;
+        }
+        await new Promise((resolve) => {
+            if (socket.readyState === WebSocket.CLOSED) {
+                resolve();
+                return;
+            }
+            let settled = false;
+            const finish = () => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                resolve();
+            };
+            socket.addEventListener("close", () => finish(), { once: true });
+            const timer = setTimeout(() => finish(), 1_000);
+            timer.unref?.();
+            try {
+                socket.close();
+            }
+            catch {
+                finish();
+            }
+        });
+        this.rpcShuttingDown = false;
+    }
+    handleRpcSocketClosed() {
+        const expectedShutdown = shouldSuppressCodexTransportFatalError({
+            transportShuttingDown: this.rpcShuttingDown,
+            shuttingDown: this.shuttingDown,
+            cleanPanelExitInProgress: this.cleanPanelExitInProgress,
+        });
+        this.rpcSocket = null;
+        this.rejectPendingRpcRequests("Codex websocket connection closed.");
+        this.rpcShuttingDown = false;
+        if (expectedShutdown) {
+            return;
+        }
+        void this.reconnectRpcClientAfterUnexpectedClose();
+    }
+    async reconnectRpcClientAfterUnexpectedClose() {
+        if (this.rpcReconnectPromise) {
+            return await this.rpcReconnectPromise;
+        }
+        this.rpcReconnectPromise = (async () => {
+            if (shouldSuppressCodexTransportFatalError({
+                transportShuttingDown: this.rpcShuttingDown,
+                shuttingDown: this.shuttingDown,
+                cleanPanelExitInProgress: this.cleanPanelExitInProgress,
+            })) {
+                return false;
+            }
+            if (!this.appServer || !this.appServerPort) {
+                if (shouldSuppressCodexTransportFatalError({
+                    transportShuttingDown: this.appServerShuttingDown,
+                    shuttingDown: this.shuttingDown,
+                    cleanPanelExitInProgress: this.cleanPanelExitInProgress,
+                })) {
+                    return false;
+                }
+                const details = this.describeAppServerLog();
+                this.emit({
+                    type: "fatal_error",
+                    message: `codex app-server websocket closed unexpectedly.${details}`,
+                    timestamp: nowIso(),
+                });
+                this.terminateCodexClient();
+                return false;
+            }
+            const reconnectDeadline = Date.now() + CODEX_RPC_RECONNECT_TIMEOUT_MS;
+            let lastError = "Codex websocket connection closed.";
+            while (!this.shuttingDown &&
+                !this.cleanPanelExitInProgress &&
+                Date.now() < reconnectDeadline) {
+                try {
+                    await this.connectRpcClient();
+                    return true;
+                }
+                catch (error) {
+                    lastError = describeUnknownError(error);
+                    await delay(CODEX_RPC_CONNECT_RETRY_MS);
+                }
+            }
+            const details = this.describeAppServerLog();
+            if (shouldSuppressCodexTransportFatalError({
+                transportShuttingDown: this.appServerShuttingDown,
+                shuttingDown: this.shuttingDown,
+                cleanPanelExitInProgress: this.cleanPanelExitInProgress,
+            })) {
+                return false;
+            }
+            this.emit({
+                type: "fatal_error",
+                message: `codex app-server websocket closed unexpectedly and could not reconnect: ${lastError}.${details}`,
+                timestamp: nowIso(),
+            });
+            this.terminateCodexClient();
+            return false;
+        })();
+        try {
+            return await this.rpcReconnectPromise;
+        }
+        finally {
+            this.rpcReconnectPromise = null;
+        }
+    }
+    rejectPendingRpcRequests(message) {
+        for (const pending of this.pendingRpcRequests.values()) {
+            pending.reject(new Error(message));
+        }
+        this.pendingRpcRequests.clear();
+    }
+    async initializeRpcClient() {
+        await this.sendRpcRequest("initialize", {
+            clientInfo: {
+                name: "wechat-bridge",
+                title: "WeChat Bridge",
+                version: "0.1.0",
+            },
+            capabilities: {
+                experimentalApi: true,
+            },
+        });
+    }
+    async restoreInitialSharedThreadIfNeeded() {
+        if (!this.resumeThreadId || this.isNativePanelMode()) {
+            return;
+        }
+        const threadId = this.resumeThreadId;
+        this.resumeThreadId = null;
+        try {
+            await this.resumeSharedThread(threadId, { startup: true });
+        }
+        catch (error) {
+            this.updateSharedThread(null);
+            this.emit({
+                type: "status",
+                status: "starting",
+                message: `Failed to restore the previous Codex thread ${threadId.slice(0, 12)}. Starting without resume: ${describeUnknownError(error)}`,
+                timestamp: nowIso(),
+            });
+        }
+    }
+    async ensureThreadStarted() {
+        if (this.sharedThreadId) {
+            return this.sharedThreadId;
+        }
+        const response = await this.sendRpcRequest("thread/start", {
+            cwd: this.options.cwd,
+            approvalPolicy: "on-request",
+            approvalsReviewer: "user",
+            sandbox: "workspace-write",
+            serviceName: "wechat-bridge",
+            experimentalRawEvents: false,
+            persistExtendedHistory: true,
+        });
+        const threadId = this.extractThreadIdFromResponse(response);
+        if (!threadId) {
+            throw new Error("Codex did not return a thread id for the bridge session.");
+        }
+        this.rememberBridgeOwnedThreadSignal(threadId);
+        this.updateSharedThread(threadId);
+        return threadId;
+    }
+    async resumeSharedThread(threadId, options = {}) {
+        const trimmedThreadId = threadId.trim();
+        if (!trimmedThreadId) {
+            throw new Error("A thread id is required to resume a Codex thread.");
+        }
+        if (this.pendingApproval) {
+            throw new Error("A Codex approval request is pending. Reply with /confirm <code> or /deny.");
+        }
+        if (!options.startup &&
+            (this.pendingTurnStart ||
+                this.activeTurn ||
+                this.state.status === "busy" ||
+                this.state.status === "awaiting_approval")) {
+            throw new Error("codex is still working. Wait for the current reply or use /stop.");
+        }
+        const response = await this.sendRpcRequest("thread/resume", {
+            threadId: trimmedThreadId,
+            cwd: this.options.cwd,
+            approvalPolicy: "on-request",
+            approvalsReviewer: "user",
+            sandbox: "workspace-write",
+        });
+        const resumedThreadId = this.extractThreadIdFromResponse(response);
+        if (!resumedThreadId) {
+            throw new Error("Codex did not return a thread id while resuming the saved thread.");
+        }
+        this.rememberBridgeOwnedThreadSignal(resumedThreadId);
+        this.sessionFilePath = null;
+        this.sessionReadOffset = 0;
+        this.sessionPartialLine = "";
+        this.sessionFinalText = null;
+        this.pendingThreadFollowId = null;
+        this.updateSharedThread(resumedThreadId, {
+            source: options.startup ? "restore" : "wechat",
+            reason: options.startup ? "startup_restore" : "wechat_resume",
+            notify: true,
+        });
+    }
+    extractThreadIdFromResponse(response) {
+        if (!isRecord(response) || !isRecord(response.thread)) {
+            return null;
+        }
+        return typeof response.thread.id === "string" ? response.thread.id : null;
+    }
+    extractTurnIdFromResponse(response) {
+        if (!isRecord(response) || !isRecord(response.turn)) {
+            return null;
+        }
+        return typeof response.turn.id === "string" ? response.turn.id : null;
+    }
+    bindActiveTurn(activeTurn) {
+        this.pendingTurnStart = false;
+        this.pendingTurnThreadId = null;
+        this.bridgeOwnedTurnIds.add(activeTurn.turnId);
+        this.setActiveTurn(activeTurn);
+        const queuedNotifications = this.queuedTurnNotifications;
+        this.queuedTurnNotifications = [];
+        for (const notification of queuedNotifications) {
+            this.handleRpcNotification(notification.method, notification.params);
+        }
+        const queuedRequests = this.queuedTurnServerRequests;
+        this.queuedTurnServerRequests = [];
+        for (const request of queuedRequests) {
+            this.handleRpcServerRequest(request.requestId, request.method, request.params);
+        }
+    }
+    async requestActiveTurnInterrupt() {
+        if (!this.activeTurn) {
+            return;
+        }
+        await this.sendRpcRequest("turn/interrupt", {
+            threadId: this.activeTurn.threadId,
+            turnId: this.activeTurn.turnId,
+        });
+    }
+    armInterruptFallback() {
+        this.clearInterruptTimer();
+        this.interruptTimer = setTimeout(() => {
+            this.interruptTimer = null;
+            if (this.state.status !== "busy" && this.state.status !== "awaiting_approval") {
+                return;
+            }
+            this.resetTurnTracking({ preserveThread: true });
+            this.setStatus("idle", "Codex task interrupted.");
+            this.emit({
+                type: "task_complete",
+                summary: "Interrupted",
+                timestamp: nowIso(),
+            });
+        }, INTERRUPT_SETTLE_DELAY_MS);
+    }
+    clearInterruptTimer() {
+        if (!this.interruptTimer) {
+            return;
+        }
+        clearTimeout(this.interruptTimer);
+        this.interruptTimer = null;
+    }
+    recoverStaleBusyStateIfNeeded() {
+        if (!shouldRecoverCodexStaleBusyState({
+            status: this.state.status,
+            pendingTurnStart: this.pendingTurnStart,
+            hasActiveTurn: Boolean(this.activeTurn),
+            hasPendingApproval: Boolean(this.pendingApproval || this.pendingApprovalRequest),
+            activeTurnId: this.state.activeTurnId,
+        })) {
+            return;
+        }
+        this.pendingTurnStart = false;
+        this.pendingTurnThreadId = null;
+        this.interruptPendingTurnStart = false;
+        this.state.activeTurnId = undefined;
+        this.state.activeTurnOrigin = undefined;
+        this.clearInterruptTimer();
+        this.setStatus("idle", "Recovered stale busy state.");
+    }
+    recoverStaleActiveTurnStateIfNeeded() {
+        if (!this.activeTurn ||
+            this.pendingTurnStart ||
+            this.pendingApproval ||
+            this.pendingApprovalRequest ||
+            this.state.status === "busy" ||
+            this.state.status === "awaiting_approval" ||
+            this.state.activeTurnId) {
+            return;
+        }
+        this.cleanupTurnArtifacts(this.activeTurn.turnId);
+        this.setActiveTurn(null);
+        this.clearInterruptTimer();
+    }
+    resetTurnTracking(options) {
+        this.clearInterruptTimer();
+        this.clearFinalReplyCompletionTimer();
+        if (this.activeTurn) {
+            this.cleanupTurnArtifacts(this.activeTurn.turnId);
+        }
+        this.setActiveTurn(null);
+        this.pendingTurnStart = false;
+        this.pendingTurnThreadId = null;
+        this.interruptPendingTurnStart = false;
+        this.pendingThreadFollowId = null;
+        this.clearPendingApprovalState();
+        this.queuedTurnNotifications = [];
+        this.queuedTurnServerRequests = [];
+        this.turnFinalMessages.clear();
+        this.turnDeltaByItem.clear();
+        this.turnErrorById.clear();
+        this.turnLastActivityAtMs.clear();
+        this.mirroredUserInputTurnIds.clear();
+        this.bridgeOwnedTurnIds.clear();
+        this.completedTurnIds.clear();
+        this.completedTurnOrder = [];
+        this.pendingInjectedInputs = [];
+        this.recentBridgeThreadSignalAtById.clear();
+        this.sessionFinalText = null;
+        this.nextSessionFallbackScanAtMs = 0;
+        this.state.activeTurnId = undefined;
+        this.state.activeTurnOrigin = undefined;
+        if (!options.preserveThread) {
+            this.clearPendingThreadAnnouncement();
+            this.announcedThreadId = null;
+        }
+        if (!options.preserveThread) {
+            this.updateSharedThread(null);
+        }
+    }
+    updateSharedThread(threadId, options = {}) {
+        const previousThreadId = this.sharedThreadId;
+        this.sharedThreadId = threadId;
+        this.state.sharedSessionId = threadId ?? undefined;
+        this.state.sharedThreadId = threadId ?? undefined;
+        if (!threadId) {
+            this.clearPendingThreadAnnouncement();
+            this.announcedThreadId = null;
+        }
+        else if (previousThreadId !== threadId &&
+            this.pendingThreadAnnouncement &&
+            this.pendingThreadAnnouncement.threadId !== threadId) {
+            this.clearPendingThreadAnnouncement();
+        }
+        if (threadId && options.source && options.reason) {
+            const switchedAt = nowIso();
+            this.state.lastSessionSwitchAt = switchedAt;
+            this.state.lastSessionSwitchSource = options.source;
+            this.state.lastSessionSwitchReason = options.reason;
+            this.state.lastThreadSwitchAt = switchedAt;
+            this.state.lastThreadSwitchSource = options.source;
+            this.state.lastThreadSwitchReason = options.reason;
+            if (options.notify) {
+                this.emitThreadSwitched(threadId, options.source, options.reason);
+            }
+        }
+        if (previousThreadId !== threadId) {
+            this.sessionFilePath = null;
+            this.sessionReadOffset = 0;
+            this.sessionPartialLine = "";
+            this.sessionFinalText = null;
+            this.sessionIgnoreBeforeMs = threadId ? Date.now() : null;
+            this.nextSessionFallbackScanAtMs = 0;
+            this.emit({
+                type: "status",
+                status: this.state.status,
+                timestamp: nowIso(),
+            });
+        }
+    }
+    setActiveTurn(activeTurn) {
+        this.activeTurn = activeTurn;
+        this.state.activeTurnId = activeTurn?.turnId;
+        this.state.activeTurnOrigin = activeTurn?.origin;
+        if (!activeTurn && this.pendingThreadFollowId) {
+            const pendingThreadId = this.pendingThreadFollowId;
+            this.pendingThreadFollowId = null;
+            this.trackLocalSharedThread(pendingThreadId, {
+                reason: "local_follow",
+                signal: "status_changed",
+            });
+        }
+    }
+    clearPendingThreadAnnouncement() {
+        if (!this.pendingThreadAnnouncement) {
+            return;
+        }
+        if (this.pendingThreadAnnouncement.timer) {
+            clearTimeout(this.pendingThreadAnnouncement.timer);
+        }
+        this.pendingThreadAnnouncement = null;
+    }
+    emitThreadSwitched(threadId, source, reason) {
+        if (this.announcedThreadId === threadId) {
+            if (this.pendingThreadAnnouncement?.threadId === threadId) {
+                this.clearPendingThreadAnnouncement();
+            }
+            return;
+        }
+        if (this.pendingThreadAnnouncement?.threadId === threadId) {
+            this.clearPendingThreadAnnouncement();
+        }
+        const switchedAt = nowIso();
+        this.announcedThreadId = threadId;
+        this.state.lastSessionSwitchAt = switchedAt;
+        this.state.lastSessionSwitchSource = source;
+        this.state.lastSessionSwitchReason = reason;
+        this.state.lastThreadSwitchAt = switchedAt;
+        this.state.lastThreadSwitchSource = source;
+        this.state.lastThreadSwitchReason = reason;
+        this.emit({
+            type: "thread_switched",
+            threadId,
+            source,
+            reason,
+            timestamp: switchedAt,
+        });
+    }
+    isPendingThreadAnnouncementStable(pending) {
+        return pending.signals.has("user_message") || pending.signals.size >= 2;
+    }
+    schedulePendingThreadAnnouncement() {
+        const pending = this.pendingThreadAnnouncement;
+        if (!pending || pending.timer || !this.isNativePanelMode()) {
+            return;
+        }
+        pending.timer = setTimeout(() => {
+            const current = this.pendingThreadAnnouncement;
+            if (!current || current.threadId !== pending.threadId) {
+                return;
+            }
+            current.timer = null;
+            this.updateSharedThread(current.threadId, {
+                source: current.source,
+                reason: current.reason,
+                notify: true,
+            });
+        }, CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS);
+        pending.timer.unref?.();
+    }
+    trackLocalSharedThread(threadId, options) {
+        if (!this.isNativePanelMode()) {
+            this.updateSharedThread(threadId, {
+                source: "local",
+                reason: options.reason,
+                notify: true,
+            });
+            return;
+        }
+        this.updateSharedThread(threadId, {
+            source: "local",
+            reason: options.reason,
+        });
+        if (this.announcedThreadId === threadId) {
+            if (this.pendingThreadAnnouncement?.threadId === threadId) {
+                this.clearPendingThreadAnnouncement();
+            }
+            return;
+        }
+        if (!this.pendingThreadAnnouncement || this.pendingThreadAnnouncement.threadId !== threadId) {
+            this.clearPendingThreadAnnouncement();
+            this.pendingThreadAnnouncement = {
+                threadId,
+                source: "local",
+                reason: options.reason,
+                signals: new Set(),
+                timer: null,
+            };
+        }
+        this.pendingThreadAnnouncement.source = "local";
+        this.pendingThreadAnnouncement.reason = options.reason;
+        this.pendingThreadAnnouncement.signals.add(options.signal);
+        if (this.isPendingThreadAnnouncementStable(this.pendingThreadAnnouncement)) {
+            this.updateSharedThread(threadId, {
+                source: "local",
+                reason: options.reason,
+                notify: true,
+            });
+            return;
+        }
+        this.schedulePendingThreadAnnouncement();
+    }
+    rememberBridgeOwnedThreadSignal(threadId) {
+        const cutoff = Date.now() - CODEX_THREAD_SIGNAL_TTL_MS;
+        for (const [candidateThreadId, recordedAtMs] of this.recentBridgeThreadSignalAtById.entries()) {
+            if (recordedAtMs < cutoff) {
+                this.recentBridgeThreadSignalAtById.delete(candidateThreadId);
+            }
+        }
+        this.recentBridgeThreadSignalAtById.set(threadId, Date.now());
+    }
+    isRecentlyBridgeOwnedThread(threadId) {
+        const recordedAtMs = this.recentBridgeThreadSignalAtById.get(threadId);
+        if (!recordedAtMs) {
+            return false;
+        }
+        if (recordedAtMs < Date.now() - CODEX_THREAD_SIGNAL_TTL_MS) {
+            this.recentBridgeThreadSignalAtById.delete(threadId);
+            return false;
+        }
+        return true;
+    }
+    clearPendingApprovalState() {
+        this.pendingApprovalRequest = null;
+        this.pendingApproval = null;
+        this.state.pendingApproval = null;
+        this.state.pendingApprovalOrigin = undefined;
+    }
+    cleanupTurnArtifacts(turnId) {
+        this.clearFinalReplyCompletionTimerForTurn(turnId);
+        this.turnFinalMessages.delete(turnId);
+        this.turnDeltaByItem.delete(turnId);
+        this.turnErrorById.delete(turnId);
+        this.turnLastActivityAtMs.delete(turnId);
+        this.mirroredUserInputTurnIds.delete(turnId);
+        this.bridgeOwnedTurnIds.delete(turnId);
+    }
+    rpcRequestKey(requestId) {
+        return `${typeof requestId}:${String(requestId)}`;
+    }
+    isRpcSocketOpen() {
+        return Boolean(this.rpcSocket && this.rpcSocket.readyState === WebSocket.OPEN);
+    }
+    async ensureRpcClientConnected() {
+        if (this.isRpcSocketOpen()) {
+            return;
+        }
+        if (this.rpcReconnectPromise) {
+            const reconnected = await this.rpcReconnectPromise;
+            if (!reconnected || !this.isRpcSocketOpen()) {
+                throw new Error("Codex websocket is not connected.");
+            }
+            return;
+        }
+        await this.connectRpcClient();
+        if (!this.isRpcSocketOpen()) {
+            throw new Error("Codex websocket is not connected.");
+        }
+    }
+    async sendRpcRequest(method, params) {
+        await this.ensureRpcClientConnected();
+        const socket = this.rpcSocket;
+        if (!socket || socket.readyState !== WebSocket.OPEN) {
+            throw new Error("Codex websocket is not connected.");
+        }
+        const requestId = ++this.rpcRequestCounter;
+        const requestKey = this.rpcRequestKey(requestId);
+        const responsePromise = new Promise((resolve, reject) => {
+            this.pendingRpcRequests.set(requestKey, {
+                method,
+                resolve,
+                reject,
+            });
+        });
+        try {
+            this.sendRpcMessage({
+                id: requestId,
+                method,
+                params,
+            });
+        }
+        catch (err) {
+            this.pendingRpcRequests.delete(requestKey);
+            throw err;
+        }
+        return await responsePromise;
+    }
+    sendRpcMessage(payload) {
+        const socket = this.rpcSocket;
+        if (!socket || socket.readyState !== WebSocket.OPEN) {
+            throw new Error("Codex websocket is not connected.");
+        }
+        socket.send(JSON.stringify(payload));
+    }
+    async respondToApprovalRequest(request, action) {
+        const decision = action === "confirm" ? "accept" : "decline";
+        this.sendRpcMessage({
+            id: request.requestId,
+            result: { decision },
+        });
+    }
+    handleRpcMessageData(data) {
+        const text = coerceWebSocketMessageData(data);
+        if (!text) {
+            return;
+        }
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            return;
+        }
+        if (!isRecord(payload)) {
+            return;
+        }
+        const requestId = getCodexRpcRequestId(payload.id);
+        const method = typeof payload.method === "string" ? payload.method : null;
+        if (requestId !== null && method) {
+            this.handleRpcServerRequest(requestId, method, payload.params);
+            return;
+        }
+        if (requestId !== null) {
+            this.handleRpcResponse(requestId, payload);
+            return;
+        }
+        if (method) {
+            this.handleRpcNotification(method, payload.params);
+        }
+    }
+    handleRpcResponse(requestId, payload) {
+        const requestKey = this.rpcRequestKey(requestId);
+        const pending = this.pendingRpcRequests.get(requestKey);
+        if (!pending) {
+            return;
+        }
+        this.pendingRpcRequests.delete(requestKey);
+        if (payload.error !== undefined && payload.error !== null) {
+            pending.reject(new Error(normalizeCodexRpcError(payload.error)));
+            return;
+        }
+        pending.resolve(payload.result);
+    }
+    handleRpcNotification(method, params) {
+        if (!isRecord(params)) {
+            return;
+        }
+        if (method === "thread/started") {
+            this.handleThreadStarted(params);
+            return;
+        }
+        if (method === "thread/status/changed") {
+            this.handleThreadStatusChanged(params);
+            return;
+        }
+        if (method === "item/started" ||
+            method === "item/agentMessage/delta" ||
+            method === "item/completed" ||
+            method === "turn/completed" ||
+            method === "turn/started" ||
+            method === "error" ||
+            method === "serverRequest/resolved") {
+            if (this.shouldQueuePendingTurnEvent(params)) {
+                this.queuedTurnNotifications.push({ method, params });
+                return;
+            }
+            const trackedTurn = this.identifyTrackedTurn(method, params);
+            if (!trackedTurn) {
+                return;
+            }
+            this.handleTrackedTurnNotification(method, params, trackedTurn);
+            return;
+        }
+        if (this.activeTurn) {
+            this.state.lastOutputAt = nowIso();
+        }
+    }
+    shouldQueuePendingTurnEvent(params) {
+        if (!this.pendingTurnStart || this.activeTurn || !this.pendingTurnThreadId) {
+            return false;
+        }
+        return getNotificationThreadId(params) === this.pendingTurnThreadId;
+    }
+    identifyTrackedTurn(method, params) {
+        const threadId = getNotificationThreadId(params);
+        const turnId = getNotificationTurnId(params);
+        if (!threadId || !turnId) {
+            return null;
+        }
+        if (this.bridgeOwnedTurnIds.has(turnId)) {
+            return {
+                threadId,
+                turnId,
+                origin: "wechat",
+            };
+        }
+        if (this.activeTurn?.turnId === turnId) {
+            return {
+                threadId,
+                turnId,
+                origin: this.activeTurn.origin,
+            };
+        }
+        const localBootstrapUserMessage = this.isNativePanelMode() &&
+            !this.activeTurn &&
+            (method === "item/started" || method === "item/completed") &&
+            extractCodexUserMessageText(params.item);
+        if (localBootstrapUserMessage) {
+            return {
+                threadId,
+                turnId,
+                origin: "local",
+            };
+        }
+        if (this.sharedThreadId && threadId === this.sharedThreadId) {
+            return {
+                threadId,
+                turnId,
+                origin: "local",
+            };
+        }
+        if (method === "turn/started" && !this.activeTurn) {
+            return {
+                threadId,
+                turnId,
+                origin: "local",
+            };
+        }
+        return null;
+    }
+    handleTrackedTurnNotification(method, params, trackedTurn) {
+        this.state.lastOutputAt = nowIso();
+        this.recordTurnActivity(trackedTurn.turnId);
+        this.handleTrackedTurnStarted(trackedTurn);
+        switch (method) {
+            case "item/started": {
+                this.maybeMirrorLocalUserInput(trackedTurn, params.item);
+                return;
+            }
+            case "item/agentMessage/delta": {
+                const itemId = typeof params.itemId === "string" ? params.itemId : null;
+                const delta = typeof params.delta === "string" ? params.delta : "";
+                if (!itemId || !delta) {
+                    return;
+                }
+                const deltaByItem = this.getTurnDeltaMap(trackedTurn.turnId);
+                const previous = deltaByItem.get(itemId) ?? "";
+                deltaByItem.set(itemId, `${previous}${delta}`);
+                return;
+            }
+            case "item/completed": {
+                this.maybeMirrorLocalUserInput(trackedTurn, params.item);
+                const itemId = isRecord(params.item) && typeof params.item.id === "string"
+                    ? params.item.id
+                    : null;
+                const finalText = extractCodexFinalTextFromItem(params.item);
+                if (itemId && finalText) {
+                    this.getTurnFinalMessageMap(trackedTurn.turnId).set(itemId, finalText);
+                    this.scheduleFinalReplyCompletionIfEligible(trackedTurn.turnId);
+                }
+                return;
+            }
+            case "error": {
+                if (isRecord(params.error) && typeof params.error.message === "string") {
+                    this.turnErrorById.set(trackedTurn.turnId, params.error.message);
+                }
+                return;
+            }
+            case "serverRequest/resolved": {
+                const requestId = getCodexRpcRequestId(params.requestId);
+                if (requestId !== null &&
+                    this.pendingApprovalRequest &&
+                    requestId === this.pendingApprovalRequest.requestId &&
+                    trackedTurn.turnId === this.pendingApprovalRequest.turnId) {
+                    this.clearPendingApprovalState();
+                    if (this.state.status === "awaiting_approval") {
+                        this.setStatus("busy", "Codex approval resolved.");
+                    }
+                }
+                return;
+            }
+            case "turn/completed": {
+                this.clearFinalReplyCompletionTimerForTurn(trackedTurn.turnId);
+                this.handleTurnCompleted(trackedTurn, params);
+                return;
+            }
+        }
+    }
+    handleRpcServerRequest(requestId, method, params) {
+        if (method !== "item/commandExecution/requestApproval" &&
+            method !== "item/fileChange/requestApproval") {
+            this.sendRpcMessage({
+                id: requestId,
+                error: {
+                    code: -32601,
+                    message: `Unsupported server request: ${method}`,
+                },
+            });
+            return;
+        }
+        if (!isRecord(params)) {
+            this.sendRpcMessage({
+                id: requestId,
+                error: {
+                    code: -32602,
+                    message: "Invalid Codex approval request payload.",
+                },
+            });
+            return;
+        }
+        if (this.shouldQueuePendingTurnEvent(params)) {
+            this.queuedTurnServerRequests.push({
+                requestId,
+                method,
+                params,
+            });
+            return;
+        }
+        const trackedTurn = this.identifyTrackedTurn("server/request", params);
+        if (!trackedTurn) {
+            return;
+        }
+        this.handleTrackedTurnStarted(trackedTurn);
+        this.handleTrackedTurnServerRequest(requestId, method, params, trackedTurn);
+    }
+    handleTrackedTurnServerRequest(requestId, method, params, trackedTurn) {
+        const request = buildCodexApprovalRequest(method, params);
+        if (!request) {
+            return;
+        }
+        this.pendingApprovalRequest = {
+            requestId,
+            method,
+            threadId: trackedTurn.threadId,
+            turnId: trackedTurn.turnId,
+            origin: trackedTurn.origin,
+        };
+        this.pendingApproval = request;
+        this.state.pendingApproval = request;
+        this.state.pendingApprovalOrigin = trackedTurn.origin;
+        this.state.lastOutputAt = nowIso();
+        this.setStatus("awaiting_approval", "Codex approval is required.");
+        this.emit({
+            type: "approval_required",
+            request,
+            timestamp: nowIso(),
+        });
+    }
+    handleThreadStatusChanged(params) {
+        const threadId = extractCodexThreadFollowIdFromStatusChanged(params);
+        if (!threadId) {
+            return;
+        }
+        if (!this.activeTurn || this.activeTurn.threadId === threadId) {
+            this.trackLocalSharedThread(threadId, {
+                reason: "local_follow",
+                signal: "status_changed",
+            });
+            this.pendingThreadFollowId = null;
+            return;
+        }
+        this.pendingThreadFollowId = threadId;
+    }
+    handleThreadStarted(params) {
+        const threadId = extractCodexThreadStartedThreadId(params);
+        if (!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)) {
+                return;
+            }
+        }
+        if (!this.activeTurn || this.activeTurn.threadId === threadId) {
+            this.trackLocalSharedThread(threadId, {
+                reason: "local_follow",
+                signal: "thread_started",
+            });
+            this.pendingThreadFollowId = null;
+            return;
+        }
+        this.pendingThreadFollowId = threadId;
+    }
+    handleTrackedTurnStarted(trackedTurn) {
+        if (this.activeTurn?.turnId === trackedTurn.turnId) {
+            return;
+        }
+        if (trackedTurn.origin === "local" &&
+            trackedTurn.threadId !== this.sharedThreadId) {
+            if (!this.activeTurn || this.activeTurn.threadId === trackedTurn.threadId) {
+                this.trackLocalSharedThread(trackedTurn.threadId, {
+                    reason: "local_turn",
+                    signal: "turn_started",
+                });
+                this.pendingThreadFollowId = null;
+            }
+            else {
+                this.pendingThreadFollowId = trackedTurn.threadId;
+            }
+        }
+        if (!this.activeTurn) {
+            this.setActiveTurn(trackedTurn);
+            if (trackedTurn.origin === "local" && this.state.status !== "awaiting_approval") {
+                this.setStatus("busy", "Codex is busy with a local terminal turn.");
+            }
+            return;
+        }
+        if (this.activeTurn.threadId !== trackedTurn.threadId) {
+            this.pendingThreadFollowId = trackedTurn.threadId;
+        }
+    }
+    maybeMirrorLocalUserInput(trackedTurn, item) {
+        if (trackedTurn.origin !== "local" || this.mirroredUserInputTurnIds.has(trackedTurn.turnId)) {
+            return;
+        }
+        const text = extractCodexUserMessageText(item);
+        if (!text) {
+            return;
+        }
+        this.trackLocalSharedThread(trackedTurn.threadId, {
+            reason: "local_turn",
+            signal: "user_message",
+        });
+        this.mirroredUserInputTurnIds.add(trackedTurn.turnId);
+        this.emit({
+            type: "mirrored_user_input",
+            text,
+            timestamp: nowIso(),
+            origin: "local",
+        });
+    }
+    handleTurnCompleted(trackedTurn, params) {
+        this.clearFinalReplyCompletionTimerForTurn(trackedTurn.turnId);
+        if (this.hasCompletedTurn(trackedTurn.turnId)) {
+            if (this.activeTurn?.turnId === trackedTurn.turnId) {
+                this.setActiveTurn(null);
+            }
+            this.cleanupTurnArtifacts(trackedTurn.turnId);
+            return;
+        }
+        const turn = isRecord(params.turn) ? params.turn : null;
+        const status = turn && typeof turn.status === "string" ? turn.status : "completed";
+        const completedError = turn && isRecord(turn.error) && typeof turn.error.message === "string"
+            ? turn.error.message
+            : this.turnErrorById.get(trackedTurn.turnId) ?? null;
+        const finalText = this.collectTurnOutput(trackedTurn.turnId);
+        const completedTrackedTurn = this.activeTurn?.turnId === trackedTurn.turnId ? this.activeTurn : trackedTurn;
+        const summary = status === "interrupted"
+            ? "Interrupted"
+            : completedTrackedTurn.origin === "local"
+                ? "Local terminal turn completed."
+                : this.currentPreview;
+        if (this.pendingApprovalRequest &&
+            this.pendingApprovalRequest.turnId === trackedTurn.turnId) {
+            this.clearPendingApprovalState();
+        }
+        if (this.activeTurn?.turnId === trackedTurn.turnId) {
+            this.setActiveTurn(null);
+        }
+        this.cleanupTurnArtifacts(trackedTurn.turnId);
+        if (this.state.status !== "stopped" &&
+            (!this.activeTurn || this.activeTurn.turnId === trackedTurn.turnId)) {
+            const statusMessage = status === "interrupted" ? "Codex task interrupted." : undefined;
+            this.setStatus("idle", statusMessage);
+        }
+        if (finalText) {
+            this.emit({
+                type: "final_reply",
+                text: finalText,
+                timestamp: nowIso(),
+            });
+        }
+        else if (status === "failed") {
+            const failureText = completedError
+                ? `Codex could not complete the request: ${completedError}`
+                : "Codex could not complete the request.";
+            this.emit({
+                type: "stdout",
+                text: failureText,
+                timestamp: nowIso(),
+            });
+        }
+        this.emit({
+            type: "task_complete",
+            summary,
+            timestamp: nowIso(),
+        });
+        this.rememberCompletedTurn(trackedTurn.turnId);
+    }
+    getTurnFinalMessageMap(turnId) {
+        let finalMessages = this.turnFinalMessages.get(turnId);
+        if (!finalMessages) {
+            finalMessages = new Map();
+            this.turnFinalMessages.set(turnId, finalMessages);
+        }
+        return finalMessages;
+    }
+    getTurnDeltaMap(turnId) {
+        let deltaByItem = this.turnDeltaByItem.get(turnId);
+        if (!deltaByItem) {
+            deltaByItem = new Map();
+            this.turnDeltaByItem.set(turnId, deltaByItem);
+        }
+        return deltaByItem;
+    }
+    collectTurnOutput(turnId) {
+        const finalMessages = Array.from(this.getTurnFinalMessageMap(turnId).values())
+            .map((text) => normalizeOutput(text).trim())
+            .filter(Boolean);
+        if (finalMessages.length > 0) {
+            return finalMessages.join("\n\n");
+        }
+        const deltaFallback = Array.from(this.getTurnDeltaMap(turnId).values())
+            .map((text) => normalizeOutput(text).trim())
+            .filter(Boolean);
+        if (deltaFallback.length === 0) {
+            return null;
+        }
+        return deltaFallback[deltaFallback.length - 1] ?? null;
+    }
+    recordTurnActivity(turnId, timestamp = Date.now()) {
+        const timestampMs = typeof timestamp === "number" ? timestamp : Date.parse(timestamp);
+        this.turnLastActivityAtMs.set(turnId, Number.isFinite(timestampMs) ? timestampMs : Date.now());
+    }
+    clearFinalReplyCompletionTimer() {
+        if (this.finalReplyCompletionTimer) {
+            clearTimeout(this.finalReplyCompletionTimer);
+            this.finalReplyCompletionTimer = null;
+        }
+        this.finalReplyCompletionTurnId = null;
+    }
+    clearFinalReplyCompletionTimerForTurn(turnId) {
+        if (this.finalReplyCompletionTurnId !== turnId) {
+            return;
+        }
+        this.clearFinalReplyCompletionTimer();
+    }
+    scheduleFinalReplyCompletionIfEligible(turnId) {
+        if (!this.activeTurn ||
+            this.activeTurn.turnId !== turnId ||
+            this.activeTurn.origin !== "wechat" ||
+            this.pendingTurnStart ||
+            this.pendingApproval ||
+            this.pendingApprovalRequest ||
+            !this.collectTurnOutput(turnId)) {
+            return;
+        }
+        this.clearFinalReplyCompletionTimer();
+        this.finalReplyCompletionTurnId = turnId;
+        this.finalReplyCompletionTimer = setTimeout(() => {
+            this.autoCompleteWechatTurnAfterFinalReply(turnId);
+        }, CODEX_FINAL_REPLY_SETTLE_DELAY_MS);
+        this.finalReplyCompletionTimer.unref?.();
+    }
+    autoCompleteWechatTurnAfterFinalReply(turnId) {
+        this.clearFinalReplyCompletionTimerForTurn(turnId);
+        const activeTurn = this.activeTurn;
+        const finalText = this.collectTurnOutput(turnId);
+        const lastActivityAtMs = this.turnLastActivityAtMs.get(turnId) ?? null;
+        const pendingApproval = Boolean(this.pendingApproval || this.pendingApprovalRequest);
+        const nowMs = Date.now();
+        if (!shouldAutoCompleteCodexWechatTurnAfterFinalReply({
+            candidateTurnId: turnId,
+            activeTurnId: activeTurn?.turnId,
+            activeTurnOrigin: activeTurn?.origin,
+            pendingTurnStart: this.pendingTurnStart,
+            hasPendingApproval: pendingApproval,
+            hasFinalOutput: Boolean(finalText),
+            hasCompletedTurn: this.hasCompletedTurn(turnId),
+            lastActivityAtMs,
+            nowMs,
+            settleDelayMs: CODEX_FINAL_REPLY_SETTLE_DELAY_MS,
+        })) {
+            if (activeTurn?.turnId === turnId &&
+                activeTurn.origin === "wechat" &&
+                !this.pendingTurnStart &&
+                !pendingApproval &&
+                finalText &&
+                typeof lastActivityAtMs === "number") {
+                const remainingMs = CODEX_FINAL_REPLY_SETTLE_DELAY_MS - (nowMs - lastActivityAtMs);
+                if (remainingMs > 0) {
+                    this.finalReplyCompletionTurnId = turnId;
+                    this.finalReplyCompletionTimer = setTimeout(() => {
+                        this.autoCompleteWechatTurnAfterFinalReply(turnId);
+                    }, remainingMs);
+                    this.finalReplyCompletionTimer.unref?.();
+                }
+            }
+            return;
+        }
+        if (!activeTurn || !finalText) {
+            return;
+        }
+        this.clearPendingApprovalState();
+        this.setActiveTurn(null);
+        this.cleanupTurnArtifacts(turnId);
+        this.state.lastOutputAt = nowIso();
+        if (this.state.status !== "stopped") {
+            this.setStatus("idle", "Recovered delayed Codex completion after final reply.");
+        }
+        this.emit({
+            type: "final_reply",
+            text: finalText,
+            timestamp: nowIso(),
+        });
+        this.emit({
+            type: "task_complete",
+            summary: this.currentPreview,
+            timestamp: nowIso(),
+        });
+        this.rememberCompletedTurn(turnId);
+    }
+    async stopAppServer() {
+        if (!this.appServer) {
+            this.appServerPort = null;
+            this.appServerShuttingDown = false;
+            this.deleteAppServerAuthTokenFile();
+            this.appServerAuthToken = null;
+            return;
+        }
+        const child = this.appServer;
+        this.appServerShuttingDown = true;
+        this.appServer = null;
+        this.appServerPort = null;
+        await new Promise((resolve) => {
+            let settled = false;
+            const finish = () => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                resolve();
+            };
+            child.once("exit", () => finish());
+            try {
+                child.kill();
+            }
+            catch {
+                finish();
+            }
+            const timer = setTimeout(() => finish(), 1_000);
+            timer.unref?.();
+        });
+        this.deleteAppServerAuthTokenFile();
+        this.appServerAuthToken = null;
+    }
+    describeAppServerLog() {
+        const summary = normalizeOutput(this.appServerLog).trim();
+        if (!summary) {
+            return "";
+        }
+        return ` Recent app-server log: ${truncatePreview(summary, 220)}`;
+    }
+    terminateCodexClient() {
+        this.shuttingDown = true;
+        if (this.pty) {
+            try {
+                this.pty.kill();
+            }
+            catch {
+                // Best effort cleanup after embedded client failure.
+            }
+            return;
+        }
+        if (this.nativeProcess) {
+            try {
+                this.nativeProcess.kill();
+            }
+            catch {
+                // Best effort cleanup after panel client failure.
+            }
+        }
+    }
+    deleteAppServerAuthTokenFile() {
+        if (!this.appServerAuthTokenFilePath) {
+            return;
+        }
+        try {
+            fs.unlinkSync(this.appServerAuthTokenFilePath);
+        }
+        catch {
+            // Best effort cleanup after app-server shutdown.
+        }
+        this.appServerAuthTokenFilePath = null;
+    }
+    attachLocalInputForwarding() {
+        if (this.localInputListener || !process.stdin.readable) {
+            return;
+        }
+        process.stdin.setEncoding("utf8");
+        process.stdin.resume();
+        this.localInputListener = (chunk) => {
+            const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+            if (!text) {
+                return;
+            }
+            this.writeToPty(text);
+        };
+        process.stdin.on("data", this.localInputListener);
+    }
+    detachLocalInputForwarding() {
+        if (!this.localInputListener) {
+            return;
+        }
+        process.stdin.off("data", this.localInputListener);
+        this.localInputListener = null;
+        if (process.stdin.isTTY) {
+            process.stdin.pause();
+        }
+    }
+    renderLocalOutput(rawText) {
+        try {
+            process.stdout.write(rawText);
+        }
+        catch {
+            // Best effort local mirroring for the visible Codex panel.
+        }
+    }
+    hasCompletedTurn(turnId) {
+        return this.completedTurnIds.has(turnId);
+    }
+    rememberCompletedTurn(turnId) {
+        if (this.completedTurnIds.has(turnId)) {
+            return;
+        }
+        this.completedTurnIds.add(turnId);
+        this.completedTurnOrder.push(turnId);
+        while (this.completedTurnOrder.length > CODEX_RECENT_SESSION_KEY_LIMIT) {
+            const staleTurnId = this.completedTurnOrder.shift();
+            if (staleTurnId) {
+                this.completedTurnIds.delete(staleTurnId);
+            }
+        }
+    }
+}
+export function shouldTreatCodexNativeExitAsExpected(params) {
+    return (params.shuttingDown ||
+        (params.renderMode === "panel" &&
+            !params.startupError &&
+            !params.signal &&
+            params.exitCode === 0));
+}
+export function shouldSuppressCodexTransportFatalError(params) {
+    return (params.transportShuttingDown ||
+        params.shuttingDown ||
+        params.cleanPanelExitInProgress);
+}