@unlinearity/cli-wechat-bridge 1.0.0

package/src/bridge/bridge-adapters.codex.ts

@@ -0,0 +1,2733 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { spawn as spawnChild } from "node:child_process";
+import type { ChildProcess, ChildProcessWithoutNullStreams } from "node:child_process";
+import type {
+  BridgeResumeSessionCandidate,
+  BridgeThreadSwitchReason,
+  BridgeThreadSwitchSource,
+  BridgeTurnOrigin,
+} from "./bridge-types.ts";
+import {
+  detectCliApproval,
+  normalizeOutput,
+  nowIso,
+  truncatePreview,
+} from "./bridge-utils.ts";
+import { AbstractPtyAdapter } from "./bridge-adapters.core.ts";
+import * as shared from "./bridge-adapters.shared.ts";
+import { ensureWorkspaceChannelDir } from "../wechat/channel-config.ts";
+import {
+  CODEX_REMOTE_AUTH_TOKEN_ENV,
+  LOCAL_CLIENT_PROTOCOL_VERSION,
+  type LocalClientEndpoint,
+} from "../runtime/runtime-types.ts";
+
+type AdapterOptions = shared.AdapterOptions;
+type CodexActiveTurn = shared.CodexActiveTurn;
+type CodexPendingApprovalRequest = shared.CodexPendingApprovalRequest;
+type CodexPendingUserInputRequest = shared.CodexPendingUserInputRequest;
+type CodexQueuedNotification = shared.CodexQueuedNotification;
+type CodexRpcPendingRequest = shared.CodexRpcPendingRequest;
+type CodexRpcRequestId = shared.CodexRpcRequestId;
+type CodexThreadAnnouncementSignal =
+  | "status_changed"
+  | "thread_started"
+  | "session_fallback"
+  | "turn_started"
+  | "user_message";
+type CodexPendingThreadAnnouncement = {
+  threadId: string;
+  source: BridgeThreadSwitchSource;
+  reason: BridgeThreadSwitchReason;
+  signals: Set<CodexThreadAnnouncementSignal>;
+  timer: ReturnType<typeof setTimeout> | null;
+};
+
+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 {
+  readonly runtimeKind = "codex_runtime_host" as const;
+
+  private appServer: ChildProcessWithoutNullStreams | null = null;
+  private nativeProcess: ChildProcess | null = null;
+  private appServerPort: number | null = null;
+  private appServerShuttingDown = false;
+  private appServerLog = "";
+  private appServerAuthToken: string | null = null;
+  private appServerAuthTokenFilePath: string | null = null;
+  private rpcSocket: WebSocket | null = null;
+  private rpcShuttingDown = false;
+  private rpcReconnectPromise: Promise<boolean> | null = null;
+  private cleanPanelExitInProgress = false;
+  private rpcRequestCounter = 0;
+  private pendingRpcRequests = new Map<string, CodexRpcPendingRequest>();
+  private sharedThreadId: string | null = null;
+  private announcedThreadId: string | null = null;
+  private pendingThreadAnnouncement: CodexPendingThreadAnnouncement | null = null;
+  private activeTurn: CodexActiveTurn | null = null;
+  private bridgeOwnedTurnIds = new Set<string>();
+  private recentBridgeThreadSignalAtById = new Map<string, number>();
+  private pendingTurnStart = false;
+  private pendingTurnThreadId: string | null = null;
+  private interruptPendingTurnStart = false;
+  private pendingThreadFollowId: string | null = null;
+  private pendingApprovalRequest: CodexPendingApprovalRequest | null = null;
+  private pendingUserInputRequest: CodexPendingUserInputRequest | null = null;
+  private queuedTurnNotifications: CodexQueuedNotification[] = [];
+  private queuedTurnServerRequests: Array<{
+    requestId: CodexRpcRequestId;
+    method: CodexPendingApprovalRequest["method"] | CodexPendingUserInputRequest["method"];
+    params: Record<string, unknown>;
+  }> = [];
+  private mirroredUserInputTurnIds = new Set<string>();
+  private turnFinalMessages = new Map<string, Map<string, string>>();
+  private turnDeltaByItem = new Map<string, Map<string, string>>();
+  private turnErrorById = new Map<string, string>();
+  private turnLastActivityAtMs = new Map<string, number>();
+  private startupBlocker: string | null = null;
+  private warmupUntilMs = 0;
+  private sessionFilePath: string | null = null;
+  private sessionPollTimer: ReturnType<typeof setInterval> | null = null;
+  private sessionReadOffset = 0;
+  private sessionPartialLine = "";
+  private sessionFinalText: string | null = null;
+  private sessionIgnoreBeforeMs: number | null = null;
+  private nextSessionFallbackScanAtMs = 0;
+  private completedTurnIds = new Set<string>();
+  private completedTurnOrder: string[] = [];
+  private pendingInjectedInputs: Array<{
+    text: string;
+    normalizedText: string;
+    createdAtMs: number;
+  }> = [];
+  private localInputListener: ((chunk: string | Buffer) => void) | null = null;
+  private interruptTimer: ReturnType<typeof setTimeout> | null = null;
+  private finalReplyCompletionTimer: ReturnType<typeof setTimeout> | null = null;
+  private finalReplyCompletionTurnId: string | null = null;
+  private resumeThreadId: string | null;
+  private readonly localClientInstanceId = `${process.pid}-${Date.now().toString(36)}`;
+
+  constructor(options: AdapterOptions) {
+    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;
+    }
+  }
+
+  override async start(): Promise<void> {
+    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;
+    }
+  }
+
+  protected buildSpawnArgs(): string[] {
+    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,
+    });
+  }
+
+  protected override afterStart(): void {
+    this.warmupUntilMs = this.usesRpcTurnTransport()
+      ? 0
+      : Date.now() + CODEX_STARTUP_WARMUP_MS;
+    if (this.isEmbeddedCliMode()) {
+      this.attachLocalInputForwarding();
+    }
+    this.startSessionPolling();
+  }
+
+  override async sendInput(text: string): Promise<void> {
+    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");
+  }
+
+  override async listResumeSessions(limit = 10): Promise<BridgeResumeSessionCandidate[]> {
+    return listCodexResumeSessions(this.options.cwd, limit);
+  }
+
+  override async resumeSession(threadId: string): Promise<void> {
+    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);
+  }
+
+  override async interrupt(): Promise<boolean> {
+    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;
+  }
+
+  override async resolveApproval(action: "confirm" | "deny"): Promise<boolean> {
+    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);
+  }
+
+  override async dispose(): Promise<void> {
+    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(): LocalClientEndpoint | null {
+    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(),
+    };
+  }
+
+  protected override handleData(rawText: string): void {
+    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.");
+      }
+    }
+  }
+
+  protected override handleExit(exitCode: number | undefined): void {
+    this.resetTurnTracking({ preserveThread: false });
+    this.detachLocalInputForwarding();
+    this.stopSessionPolling();
+    void this.disconnectRpcClient();
+    void this.stopAppServer();
+    super.handleExit(exitCode);
+  }
+
+  private isNativePanelMode(): boolean {
+    return this.options.renderMode === "panel";
+  }
+
+  private isHeadlessRuntimeMode(): boolean {
+    return this.options.renderMode === "headless";
+  }
+
+  private isEmbeddedCliMode(): boolean {
+    return !this.isNativePanelMode() && !this.isHeadlessRuntimeMode();
+  }
+
+  private usesRpcTurnTransport(): boolean {
+    return this.isNativePanelMode() || this.isHeadlessRuntimeMode();
+  }
+
+  private isCodexClientRunning(): boolean {
+    if (this.isHeadlessRuntimeMode()) {
+      return Boolean(this.appServer);
+    }
+    return this.isNativePanelMode() ? Boolean(this.nativeProcess) : Boolean(this.pty);
+  }
+
+  private async startNativeClient(): Promise<void> {
+    this.setStatus("starting", `Starting ${this.options.kind} adapter...`);
+
+    let spawnTarget: SpawnTarget | null = 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;
+    }
+  }
+
+  private handleNativeExit(
+    exitCode: number | undefined,
+    signal?: NodeJS.Signals,
+    startupError?: Error,
+  ): void {
+    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(),
+    });
+  }
+
+  private async stopNativeClient(): Promise<void> {
+    if (!this.nativeProcess) {
+      this.state.pid = undefined;
+      return;
+    }
+
+    const child = this.nativeProcess;
+    this.shuttingDown = true;
+    this.nativeProcess = null;
+
+    await new Promise<void>((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?.();
+    });
+  }
+
+  private startSessionPolling(): void {
+    this.stopSessionPolling();
+    const poll = () => {
+      void this.pollSessionLog();
+    };
+    this.sessionPollTimer = setInterval(poll, CODEX_SESSION_POLL_INTERVAL_MS);
+    this.sessionPollTimer.unref?.();
+    poll();
+  }
+
+  private stopSessionPolling(): void {
+    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;
+  }
+
+  private async pollSessionLog(): Promise<void> {
+    if (!this.isCodexClientRunning()) {
+      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 = "";
+    }
+
+    let content: string;
+    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);
+    }
+  }
+
+  private maybeApplyRecentSessionFallback(): void {
+    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;
+    }
+  }
+
+  private handleSessionLogLine(line: string): void {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      return;
+    }
+
+    let parsed: unknown;
+    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;
+      }
+    }
+  }
+
+  private rememberInjectedInput(text: string): void {
+    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);
+    }
+  }
+
+  private consumeInjectedInput(message: string): boolean {
+    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;
+  }
+
+  private async typeIntoPty(text: string): Promise<void> {
+    for (const character of text) {
+      this.writeToPty(character);
+      await delay(4);
+    }
+  }
+
+  private async sendPanelTurn(text: string): Promise<void> {
+    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.state.status === "busy") {
+        this.setStatus("idle");
+      }
+      throw error;
+    }
+  }
+
+  private async interruptPanelTurn(): Promise<boolean> {
+    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;
+  }
+
+  private async startAppServer(): Promise<void> {
+    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: string) => {
+      this.appServerLog = appendBoundedLog(this.appServerLog, chunk);
+    });
+    child.stderr.on("data", (chunk: string) => {
+      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}`);
+    }
+  }
+
+  private async connectRpcClient(): Promise<void> {
+    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}`);
+  }
+
+  private async openRpcSocket(
+    url: string,
+    authToken: string | null,
+    timeoutMs: number,
+  ): Promise<WebSocket> {
+    if (!authToken) {
+      throw new Error("Codex app-server websocket auth token is unavailable.");
+    }
+
+    return await new Promise<WebSocket>((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 },
+      );
+    });
+  }
+
+  private attachRpcSocket(socket: WebSocket): void {
+    this.rpcSocket = socket;
+    this.rpcShuttingDown = false;
+
+    socket.addEventListener("message", (event) => {
+      this.handleRpcMessageData(event.data);
+    });
+    socket.addEventListener("close", () => {
+      this.handleRpcSocketClosed();
+    });
+  }
+
+  private async disconnectRpcClient(): Promise<void> {
+    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<void>((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;
+  }
+
+  private handleRpcSocketClosed(): void {
+    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();
+  }
+
+  private async reconnectRpcClientAfterUnexpectedClose(): Promise<boolean> {
+    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;
+    }
+  }
+
+  private rejectPendingRpcRequests(message: string): void {
+    for (const pending of this.pendingRpcRequests.values()) {
+      pending.reject(new Error(message));
+    }
+    this.pendingRpcRequests.clear();
+  }
+
+  private async initializeRpcClient(): Promise<void> {
+    await this.sendRpcRequest("initialize", {
+      clientInfo: {
+        name: "wechat-bridge",
+        title: "WeChat Bridge",
+        version: "0.1.0",
+      },
+      capabilities: {
+        experimentalApi: true,
+      },
+    });
+  }
+
+  private async restoreInitialSharedThreadIfNeeded(): Promise<void> {
+    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(),
+      });
+    }
+  }
+
+  private async ensureThreadStarted(): Promise<string> {
+    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;
+  }
+
+  private async resumeSharedThread(
+    threadId: string,
+    options: { startup?: boolean } = {},
+  ): Promise<void> {
+    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,
+    });
+  }
+
+  private extractThreadIdFromResponse(response: unknown): string | null {
+    if (!isRecord(response) || !isRecord(response.thread)) {
+      return null;
+    }
+    return typeof response.thread.id === "string" ? response.thread.id : null;
+  }
+
+  private extractTurnIdFromResponse(response: unknown): string | null {
+    if (!isRecord(response) || !isRecord(response.turn)) {
+      return null;
+    }
+    return typeof response.turn.id === "string" ? response.turn.id : null;
+  }
+
+  private bindActiveTurn(activeTurn: CodexActiveTurn): void {
+    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);
+    }
+  }
+
+  private async requestActiveTurnInterrupt(): Promise<void> {
+    if (!this.activeTurn) {
+      return;
+    }
+
+    await this.sendRpcRequest("turn/interrupt", {
+      threadId: this.activeTurn.threadId,
+      turnId: this.activeTurn.turnId,
+    });
+  }
+
+  private armInterruptFallback(): void {
+    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);
+  }
+
+  private clearInterruptTimer(): void {
+    if (!this.interruptTimer) {
+      return;
+    }
+    clearTimeout(this.interruptTimer);
+    this.interruptTimer = null;
+  }
+
+  private recoverStaleBusyStateIfNeeded(): void {
+    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.");
+  }
+
+  private recoverStaleActiveTurnStateIfNeeded(): void {
+    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();
+  }
+
+  private resetTurnTracking(options: { preserveThread: boolean }): void {
+    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);
+    }
+  }
+
+  private updateSharedThread(
+    threadId: string | null,
+    options: {
+      source?: BridgeThreadSwitchSource;
+      reason?: BridgeThreadSwitchReason;
+      notify?: boolean;
+    } = {},
+  ): void {
+    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(),
+      });
+    }
+  }
+
+  private setActiveTurn(activeTurn: CodexActiveTurn | null): void {
+    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",
+      });
+    }
+  }
+
+  private clearPendingThreadAnnouncement(): void {
+    if (!this.pendingThreadAnnouncement) {
+      return;
+    }
+    if (this.pendingThreadAnnouncement.timer) {
+      clearTimeout(this.pendingThreadAnnouncement.timer);
+    }
+    this.pendingThreadAnnouncement = null;
+  }
+
+  private emitThreadSwitched(
+    threadId: string,
+    source: BridgeThreadSwitchSource,
+    reason: BridgeThreadSwitchReason,
+  ): void {
+    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,
+    });
+  }
+
+  private isPendingThreadAnnouncementStable(
+    pending: CodexPendingThreadAnnouncement,
+  ): boolean {
+    return pending.signals.has("user_message") || pending.signals.size >= 2;
+  }
+
+  private schedulePendingThreadAnnouncement(): void {
+    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?.();
+  }
+
+  private trackLocalSharedThread(
+    threadId: string,
+    options: {
+      reason: BridgeThreadSwitchReason;
+      signal: CodexThreadAnnouncementSignal;
+    },
+  ): void {
+    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<CodexThreadAnnouncementSignal>(),
+        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();
+  }
+
+  private rememberBridgeOwnedThreadSignal(threadId: string): void {
+    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());
+  }
+
+  private isRecentlyBridgeOwnedThread(threadId: string): boolean {
+    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;
+  }
+
+  private clearPendingApprovalState(): void {
+    this.pendingApprovalRequest = null;
+    this.pendingApproval = null;
+    this.state.pendingApproval = null;
+    this.state.pendingApprovalOrigin = undefined;
+  }
+
+  private cleanupTurnArtifacts(turnId: string): void {
+    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);
+  }
+
+  private rpcRequestKey(requestId: CodexRpcRequestId): string {
+    return `${typeof requestId}:${String(requestId)}`;
+  }
+
+  private isRpcSocketOpen(): boolean {
+    return Boolean(this.rpcSocket && this.rpcSocket.readyState === WebSocket.OPEN);
+  }
+
+  private async ensureRpcClientConnected(): Promise<void> {
+    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.");
+    }
+  }
+
+  private async sendRpcRequest(method: string, params: unknown): Promise<unknown> {
+    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<unknown>((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;
+  }
+
+  private sendRpcMessage(payload: Record<string, unknown>): void {
+    const socket = this.rpcSocket;
+    if (!socket || socket.readyState !== WebSocket.OPEN) {
+      throw new Error("Codex websocket is not connected.");
+    }
+
+    socket.send(JSON.stringify(payload));
+  }
+
+  private async respondToApprovalRequest(
+    request: CodexPendingApprovalRequest,
+    action: "confirm" | "deny",
+  ): Promise<void> {
+    const decision = action === "confirm" ? "accept" : "decline";
+    this.sendRpcMessage({
+      id: request.requestId,
+      result: { decision },
+    });
+  }
+
+  private handleRpcMessageData(data: unknown): void {
+    const text = coerceWebSocketMessageData(data);
+    if (!text) {
+      return;
+    }
+
+    let payload: unknown;
+    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);
+    }
+  }
+
+  private handleRpcResponse(requestId: CodexRpcRequestId, payload: Record<string, unknown>): void {
+    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);
+  }
+
+  private handleRpcNotification(method: string, params: unknown): void {
+    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();
+    }
+  }
+
+  private shouldQueuePendingTurnEvent(params: Record<string, unknown>): boolean {
+    if (!this.pendingTurnStart || this.activeTurn || !this.pendingTurnThreadId) {
+      return false;
+    }
+
+    return getNotificationThreadId(params) === this.pendingTurnThreadId;
+  }
+
+  private identifyTrackedTurn(
+    method: string,
+    params: Record<string, unknown>,
+  ): CodexActiveTurn | null {
+    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;
+  }
+
+  private handleTrackedTurnNotification(
+    method: string,
+    params: Record<string, unknown>,
+    trackedTurn: CodexActiveTurn,
+  ): void {
+    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;
+      }
+    }
+  }
+
+  private handleRpcServerRequest(
+    requestId: CodexRpcRequestId,
+    method: string,
+    params: unknown,
+  ): void {
+    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);
+  }
+
+  private handleTrackedTurnServerRequest(
+    requestId: CodexRpcRequestId,
+    method: CodexPendingApprovalRequest["method"],
+    params: Record<string, unknown>,
+    trackedTurn: CodexActiveTurn,
+  ): void {
+    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(),
+    });
+  }
+
+  private handleThreadStatusChanged(params: Record<string, unknown>): void {
+    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;
+  }
+
+  private handleThreadStarted(params: Record<string, unknown>): void {
+    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;
+  }
+
+  private handleTrackedTurnStarted(trackedTurn: CodexActiveTurn): void {
+    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;
+    }
+  }
+
+  private maybeMirrorLocalUserInput(
+    trackedTurn: CodexActiveTurn,
+    item: unknown,
+  ): void {
+    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",
+    });
+  }
+
+  private handleTurnCompleted(
+    trackedTurn: CodexActiveTurn,
+    params: Record<string, unknown>,
+  ): void {
+    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);
+  }
+
+  private getTurnFinalMessageMap(turnId: string): Map<string, string> {
+    let finalMessages = this.turnFinalMessages.get(turnId);
+    if (!finalMessages) {
+      finalMessages = new Map<string, string>();
+      this.turnFinalMessages.set(turnId, finalMessages);
+    }
+    return finalMessages;
+  }
+
+  private getTurnDeltaMap(turnId: string): Map<string, string> {
+    let deltaByItem = this.turnDeltaByItem.get(turnId);
+    if (!deltaByItem) {
+      deltaByItem = new Map<string, string>();
+      this.turnDeltaByItem.set(turnId, deltaByItem);
+    }
+    return deltaByItem;
+  }
+
+  private collectTurnOutput(turnId: string): string | null {
+    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];
+  }
+
+  private recordTurnActivity(turnId: string, timestamp: string | number = Date.now()): void {
+    const timestampMs =
+      typeof timestamp === "number" ? timestamp : Date.parse(timestamp);
+    this.turnLastActivityAtMs.set(
+      turnId,
+      Number.isFinite(timestampMs) ? timestampMs : Date.now(),
+    );
+  }
+
+  private clearFinalReplyCompletionTimer(): void {
+    if (this.finalReplyCompletionTimer) {
+      clearTimeout(this.finalReplyCompletionTimer);
+      this.finalReplyCompletionTimer = null;
+    }
+    this.finalReplyCompletionTurnId = null;
+  }
+
+  private clearFinalReplyCompletionTimerForTurn(turnId: string): void {
+    if (this.finalReplyCompletionTurnId !== turnId) {
+      return;
+    }
+    this.clearFinalReplyCompletionTimer();
+  }
+
+  private scheduleFinalReplyCompletionIfEligible(turnId: string): void {
+    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?.();
+  }
+
+  private autoCompleteWechatTurnAfterFinalReply(turnId: string): void {
+    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);
+  }
+
+  private async stopAppServer(): Promise<void> {
+    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<void>((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;
+  }
+
+  private describeAppServerLog(): string {
+    const summary = normalizeOutput(this.appServerLog).trim();
+    if (!summary) {
+      return "";
+    }
+    return ` Recent app-server log: ${truncatePreview(summary, 220)}`;
+  }
+
+  private terminateCodexClient(): void {
+    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.
+      }
+    }
+  }
+
+  private deleteAppServerAuthTokenFile(): void {
+    if (!this.appServerAuthTokenFilePath) {
+      return;
+    }
+
+    try {
+      fs.unlinkSync(this.appServerAuthTokenFilePath);
+    } catch {
+      // Best effort cleanup after app-server shutdown.
+    }
+
+    this.appServerAuthTokenFilePath = null;
+  }
+
+  private attachLocalInputForwarding(): void {
+    if (this.localInputListener || !process.stdin.readable) {
+      return;
+    }
+
+    process.stdin.setEncoding("utf8");
+    process.stdin.resume();
+    this.localInputListener = (chunk: string | Buffer) => {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      if (!text) {
+        return;
+      }
+      this.writeToPty(text);
+    };
+    process.stdin.on("data", this.localInputListener);
+  }
+
+  private detachLocalInputForwarding(): void {
+    if (!this.localInputListener) {
+      return;
+    }
+
+    process.stdin.off("data", this.localInputListener);
+    this.localInputListener = null;
+    if (process.stdin.isTTY) {
+      process.stdin.pause();
+    }
+  }
+
+  private renderLocalOutput(rawText: string): void {
+    try {
+      process.stdout.write(rawText);
+    } catch {
+      // Best effort local mirroring for the visible Codex panel.
+    }
+  }
+
+  private hasCompletedTurn(turnId: string): boolean {
+    return this.completedTurnIds.has(turnId);
+  }
+
+  private rememberCompletedTurn(turnId: string): void {
+    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: {
+  renderMode?: AdapterOptions["renderMode"];
+  shuttingDown: boolean;
+  exitCode: number | undefined;
+  signal?: NodeJS.Signals;
+  startupError?: Error;
+}): boolean {
+  return (
+    params.shuttingDown ||
+    (params.renderMode === "panel" &&
+      !params.startupError &&
+      !params.signal &&
+      params.exitCode === 0)
+  );
+}
+
+export function shouldSuppressCodexTransportFatalError(params: {
+  transportShuttingDown: boolean;
+  shuttingDown: boolean;
+  cleanPanelExitInProgress: boolean;
+}): boolean {
+  return (
+    params.transportShuttingDown ||
+    params.shuttingDown ||
+    params.cleanPanelExitInProgress
+  );
+}
+