happy-imou-cloud 2.0.0 → 2.0.2

package/dist/{runCodex-B-05E-YZ.mjs → runCodex-C--ZwAhl.mjs}

@@ -1,27 +1,24 @@
 import { randomUUID } from 'node:crypto';
-import { l as logger, b as connectionState, A as ApiClient } from './api-BGXYX0yH.mjs';
-import { readSettings } from './persistence-BA_unuca.mjs';
-import { d as resolveCodexExecutable, e as shouldUseShellForCodex, b as stopCaffeinate, i as initialMachineMetadata, n as notifyDaemonSessionStarted } from './index-C7Y0R-MI.mjs';
-import { I as INTERACTION_SUPERSEDED_ERROR, B as BasePermissionHandler, a as BaseReasoningProcessor, c as createSessionMetadata, s as setupOfflineReconnection } from './BaseReasoningProcessor-BKLRCKTU.mjs';
-import { a as MessageBuffer, r as registerKillSessionHandler, M as MessageQueue2, h as hashObject } from './registerKillSessionHandler-C2-yHm1V.mjs';
+import { l as logger, b as connectionState, A as ApiClient, i as isAuthenticationRequiredError } from './api-MYhAGPLn.mjs';
+import { readSettings } from './persistence-Dkm7rm8k.mjs';
+import { f as formatDisplayMessage, v as validateCodexAcpSpawn, d as createCodexBackend, t as truncateDisplayMessage, b as stopCaffeinate, i as initialMachineMetadata, n as notifyDaemonSessionStarted } from './index-B97L7qLD.mjs';
+import { B as BasePermissionHandler, g as getPendingInteractionTimeoutMs, I as INTERACTION_SUPERSEDED_ERROR, b as INTERACTION_TIMED_OUT_ERROR, a as BaseReasoningProcessor, c as createSessionMetadata, s as setupOfflineReconnection } from './BaseReasoningProcessor-D8VhEbs2.mjs';
+import { a as MessageBuffer, r as registerKillSessionHandler, M as MessageQueue2, h as hashObject } from './registerKillSessionHandler-5GbrO0FM.mjs';
 import { F as Future } from './future-xRdLl3vf.mjs';
 import { spawn, execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
-import { join } from 'node:path';
+import path, { join } from 'node:path';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { useStdout, useInput, Box, Text, render } from 'ink';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { z } from 'zod';
-import { ElicitRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { execSync } from 'child_process';
 import 'axios';
 import 'chalk';
 import 'fs';
 import 'node:events';
 import 'socket.io-client';
+import 'zod';
 import 'tweetnacl';
+import 'child_process';
 import 'util';
 import 'fs/promises';
 import 'crypto';
@@ -131,6 +128,7 @@ class CodexSession {
   sessionId;
   mode;
   thinking = false;
+  localModePinned = false;
   keepAliveInterval;
   onModeChangeCallback;
   clientSwapCallbacks = [];
@@ -185,11 +183,23 @@ class CodexSession {
     this.thinking = thinking;
     this.client.keepAlive(thinking, this.mode);
   };
-  onModeChange = (mode) => {
+  onModeChange = async (mode) => {
     this.mode = mode;
     this.client.keepAlive(this.thinking, mode);
-    this.onModeChangeCallback(mode);
+    await this.onModeChangeCallback(mode);
   };
+  pinLocalMode = () => {
+    this.localModePinned = true;
+    logger.debug("[CodexSession] Local mode pinned");
+  };
+  clearLocalModePin = () => {
+    if (!this.localModePinned) {
+      return;
+    }
+    this.localModePinned = false;
+    logger.debug("[CodexSession] Local mode pin cleared");
+  };
+  isLocalModePinned = () => this.localModePinned;
   onSessionFound = (sessionId) => {
     if (this.sessionId === sessionId) {
       return;
@@ -232,21 +242,6 @@ function extractCodexSessionIdFromPath(filePath) {
   const match = filePath.match(/-([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\.jsonl$/);
   return match?.[1] ?? null;
 }
-function findCodexResumeFile(sessionId) {
-  if (!sessionId) return null;
-  try {
-    const candidates = collectFilesRecursive(getCodexSessionsRoot()).filter((full) => full.endsWith(`-${sessionId}.jsonl`)).filter((full) => {
-      try {
-        return fs.statSync(full).isFile();
-      } catch {
-        return false;
-      }
-    }).sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
-    return candidates[0] || null;
-  } catch {
-    return null;
-  }
-}
 function findLatestCodexSessionIdSince(startTimeMs) {
   try {
     const candidates = collectFilesRecursive(getCodexSessionsRoot()).filter((full) => full.endsWith(".jsonl")).filter((full) => {
@@ -268,6 +263,36 @@ function findLatestCodexSessionIdSince(startTimeMs) {
   return null;
 }
 
+function firstExistingPath(candidates) {
+  for (const candidate of candidates) {
+    try {
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveCodexExecutable() {
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+    const npmGlobalBin = path.join(appData, "npm");
+    const resolved = firstExistingPath([
+      path.join(npmGlobalBin, "codex.cmd"),
+      path.join(npmGlobalBin, "codex.ps1"),
+      path.join(npmGlobalBin, "codex")
+    ]);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return "codex";
+}
+function shouldUseShellForCodex(executable) {
+  return process.platform === "win32" && /\.(cmd|bat|ps1)$/i.test(executable);
+}
+
 class CodexExitCodeError extends Error {
   exitCode;
   constructor(exitCode) {
@@ -385,10 +410,18 @@ async function codexLocalLauncher(session) {
     session.client.rpcHandlerManager.registerHandler("abort", doAbort);
     session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
     session.queue.setOnMessage(() => {
+      if (session.isLocalModePinned()) {
+        logger.debug("[codex-local]: message arrived while local mode is pinned; staying local");
+        return;
+      }
       void doSwitch();
     });
     if (session.queue.size() > 0) {
-      return { type: "switch" };
+      if (session.isLocalModePinned()) {
+        logger.debug("[codex-local]: pending queued messages detected, but local mode is pinned; staying local");
+      } else {
+        return { type: "switch" };
+      }
     }
     while (true) {
       if (exitReason) {
@@ -522,7 +555,7 @@ const CodexDisplay = ({ messageBuffer, logPath, onExit, onSwitchToLocal, title }
     }
   };
   const formatMessage = (msg) => {
-    const lines = msg.content.split("\n");
+    const lines = formatDisplayMessage(msg.content).split("\n");
     const maxLineLength = terminalWidth - 10;
     return lines.map((line) => {
       if (line.length <= maxLineLength) return line;
@@ -564,462 +597,6 @@ const CodexDisplay = ({ messageBuffer, logPath, onExit, onSwitchToLocal, title }
   ));
 };
 
-const DEFAULT_TIMEOUT = 14 * 24 * 60 * 60 * 1e3;
-function getCodexMcpCommand() {
-  const codexExecutable = resolveCodexExecutable();
-  try {
-    const version = execSync(`"${codexExecutable}" --version`, { encoding: "utf8" }).trim();
-    const match = version.match(/codex-cli\s+(\d+\.\d+\.\d+(?:-alpha\.\d+)?)/);
-    if (!match) {
-      logger.debug("[CodexMCP] Could not parse codex version:", version);
-      return null;
-    }
-    const versionStr = match[1];
-    const [major, minor, patch] = versionStr.split(/[-.]/).map(Number);
-    if (major > 0 || minor > 43) return "mcp-server";
-    if (minor === 43 && patch === 0) {
-      if (versionStr.includes("-alpha.")) {
-        const alphaNum = parseInt(versionStr.split("-alpha.")[1]);
-        return alphaNum >= 5 ? "mcp-server" : "mcp";
-      }
-      return "mcp-server";
-    }
-    return "mcp";
-  } catch (error) {
-    logger.debug("[CodexMCP] Codex CLI not found or not executable:", error);
-    return null;
-  }
-}
-function resolveCodexMcpTransport(executable, mcpCommand) {
-  return {
-    // Preserve the resolved executable path so daemon/service environments do not
-    // depend on APPDATA npm shims being present on PATH.
-    command: executable,
-    args: [mcpCommand]
-  };
-}
-function extractCodexIdentifiers(response) {
-  const meta = response?.meta || {};
-  const structured = response?.structuredContent || response?.structured_content || response?.structured_output || {};
-  const sessionId = meta.sessionId || meta.session_id || response?.sessionId || response?.session_id || meta.threadId || meta.thread_id || response?.threadId || response?.thread_id || structured.threadId || structured.thread_id || null;
-  const conversationId = meta.conversationId || meta.conversation_id || response?.conversationId || response?.conversation_id || meta.threadId || meta.thread_id || response?.threadId || response?.thread_id || structured.threadId || structured.thread_id || structured.conversationId || structured.conversation_id || null;
-  return { sessionId, conversationId };
-}
-function normalizeCodexPermissionRequest(params) {
-  return {
-    requestId: params.codex_call_id || params.call_id || params.codex_mcp_tool_call_id || params.codex_event_id || `codex-permission-${Date.now()}`,
-    toolName: "CodexBash",
-    input: {
-      command: params.codex_command || params.command,
-      cwd: params.codex_cwd || params.cwd,
-      proposed_execpolicy_amendment: params.proposed_execpolicy_amendment,
-      parsed_cmd: params.parsed_cmd
-    }
-  };
-}
-function resolveCodexPermissionRequest(params, fallback) {
-  const normalized = normalizeCodexPermissionRequest(params);
-  const hasInlinePayload = Boolean(
-    normalized.input.command || normalized.input.cwd || normalized.input.proposed_execpolicy_amendment || normalized.input.parsed_cmd
-  );
-  const hasInlineId = Boolean(
-    params.codex_call_id || params.call_id || params.codex_mcp_tool_call_id || params.codex_event_id
-  );
-  if (!fallback || hasInlinePayload && hasInlineId) {
-    return normalized;
-  }
-  return {
-    requestId: hasInlineId ? normalized.requestId : fallback.call_id || normalized.requestId,
-    toolName: normalized.toolName,
-    input: {
-      command: normalized.input.command || fallback.command,
-      cwd: normalized.input.cwd || fallback.cwd,
-      proposed_execpolicy_amendment: normalized.input.proposed_execpolicy_amendment || fallback.proposed_execpolicy_amendment,
-      parsed_cmd: normalized.input.parsed_cmd || fallback.parsed_cmd
-    }
-  };
-}
-class CodexMcpClient {
-  client;
-  transport = null;
-  connected = false;
-  sessionId = null;
-  conversationId = null;
-  handler = null;
-  permissionHandler = null;
-  selectionHandler = null;
-  pendingExecApprovalContexts = [];
-  constructor() {
-    this.client = this.createClient();
-  }
-  createClient() {
-    const client = new Client(
-      { name: "happy-codex-client", version: "1.0.0" },
-      { capabilities: { elicitation: {} } }
-    );
-    client.setNotificationHandler(z.object({
-      method: z.literal("codex/event"),
-      params: z.object({
-        msg: z.any()
-      })
-    }).passthrough(), (data) => {
-      const msg = data.params.msg;
-      if (msg?.type === "exec_approval_request") {
-        this.pendingExecApprovalContexts.push({
-          call_id: msg.call_id,
-          command: msg.command,
-          cwd: msg.cwd,
-          proposed_execpolicy_amendment: msg.proposed_execpolicy_amendment,
-          parsed_cmd: msg.parsed_cmd
-        });
-      }
-      this.updateIdentifiersFromEvent(msg);
-      this.handler?.(msg);
-    });
-    return client;
-  }
-  setHandler(handler) {
-    this.handler = handler;
-  }
-  /**
-   * Set the permission handler for tool approval
-   */
-  setPermissionHandler(handler) {
-    this.permissionHandler = handler;
-  }
-  setSelectionHandler(handler) {
-    this.selectionHandler = handler;
-  }
-  async connect() {
-    if (this.connected) return;
-    const mcpCommand = getCodexMcpCommand();
-    if (mcpCommand === null) {
-      throw new Error(
-        "Codex CLI not found or not executable.\n\nTo install codex:\n  npm install -g @openai/codex\n\nAlternatively, use Claude:\n  happy claude"
-      );
-    }
-    logger.debug(`[CodexMCP] Connecting to Codex MCP server using command: codex ${mcpCommand}`);
-    const codexExecutable = resolveCodexExecutable();
-    const transport = resolveCodexMcpTransport(codexExecutable, mcpCommand);
-    this.transport = new StdioClientTransport({
-      command: transport.command,
-      args: transport.args,
-      env: Object.keys(process.env).reduce((acc, key) => {
-        const value = process.env[key];
-        if (typeof value === "string") acc[key] = value;
-        return acc;
-      }, {})
-    });
-    this.registerPermissionHandlers();
-    await this.client.connect(this.transport);
-    this.connected = true;
-    logger.debug("[CodexMCP] Connected to Codex");
-  }
-  isClosedTransportError(error) {
-    const record = error;
-    const code = typeof record?.code === "number" ? record.code : null;
-    if (code === -32e3) {
-      return true;
-    }
-    const message = typeof record?.message === "string" ? record.message.toLowerCase() : "";
-    if (code === -32001 && message.includes("aborterror")) {
-      return true;
-    }
-    return message.includes("connection closed") || message.includes("not connected");
-  }
-  async callToolWithReconnectRetry(call) {
-    try {
-      return await call();
-    } catch (error) {
-      if (!this.isClosedTransportError(error)) {
-        throw error;
-      }
-      logger.debug("[CodexMCP] Transport closed during tool call; reconnecting and retrying once");
-      try {
-        await this.disconnect();
-      } catch {
-      }
-      await this.connect();
-      return await call();
-    }
-  }
-  registerPermissionHandlers() {
-    this.client.setRequestHandler(
-      ElicitRequestSchema,
-      async (request) => {
-        const params = request.params;
-        logger.debug("[CodexMCP] Received elicitation request:", params);
-        try {
-          if (this.isSelectionRequest(params)) {
-            return await this.handleSelectionRequest(params);
-          }
-          if (!this.permissionHandler) {
-            logger.debug("[CodexMCP] No permission handler set, denying by default");
-            return {
-              action: "decline",
-              decision: "denied",
-              content: {
-                decision: "denied"
-              }
-            };
-          }
-          const normalized = resolveCodexPermissionRequest(
-            params,
-            this.takeExecApprovalContextForPermission(params)
-          );
-          const result = await this.permissionHandler.handleToolCall(
-            normalized.requestId,
-            normalized.toolName,
-            normalized.input
-          );
-          logger.debug("[CodexMCP] Permission result:", result);
-          return {
-            action: result.decision === "abort" ? "cancel" : result.decision === "denied" ? "decline" : "accept",
-            decision: result.decision,
-            content: {
-              decision: result.decision
-            }
-          };
-        } catch (error) {
-          if (error instanceof Error && error.message === "Session reset") {
-            logger.debug("[CodexMCP] Permission request cancelled during session reset");
-            return {
-              action: "cancel"
-            };
-          }
-          if (error instanceof Error && error.message === INTERACTION_SUPERSEDED_ERROR) {
-            logger.debug("[CodexMCP] Selection request cancelled because a new user message arrived");
-            return {
-              action: "cancel"
-            };
-          }
-          logger.debug("[CodexMCP] Error handling permission request:", error);
-          return {
-            action: "decline",
-            decision: "denied",
-            reason: error instanceof Error ? error.message : "Permission request failed"
-          };
-        }
-      }
-    );
-    logger.debug("[CodexMCP] Permission handlers registered");
-  }
-  isSelectionRequest(params) {
-    if (Array.isArray(params.codex_command) && params.codex_command.length > 0) {
-      return false;
-    }
-    if (Array.isArray(params.options) && params.options.length > 0) {
-      return true;
-    }
-    return Boolean(params.requestedSchema?.properties?.optionId);
-  }
-  async handleSelectionRequest(params) {
-    const optionMap = (params.options || []).filter((option) => Boolean(option.optionId));
-    const options = optionMap.map((option) => ({
-      optionId: option.optionId,
-      label: option.label || option.name || option.optionId,
-      description: option.description || option.name || option.optionId
-    }));
-    const defaultOptionId = params.requestedSchema?.properties?.optionId?.default;
-    if (options.length === 0) {
-      logger.debug("[CodexMCP] Selection request has no options, cancelling");
-      return {
-        action: "cancel"
-      };
-    }
-    if (!this.selectionHandler) {
-      logger.debug("[CodexMCP] No selection handler set, cancelling selection request");
-      return {
-        action: "cancel"
-      };
-    }
-    const requestId = params.codex_event_id || params.codex_elicitation || `selection-${Date.now()}`;
-    const response = await this.selectionHandler.requestSelection({
-      id: requestId,
-      message: params.message,
-      options,
-      defaultOptionId
-    });
-    return {
-      action: "accept",
-      optionId: response.optionId,
-      content: {
-        optionId: response.optionId
-      }
-    };
-  }
-  takeExecApprovalContextForPermission(params) {
-    const hasInlinePayload = Boolean(
-      params.codex_command || params.command || params.codex_cwd || params.cwd || params.proposed_execpolicy_amendment || params.parsed_cmd
-    );
-    const explicitId = params.codex_call_id || params.call_id || params.codex_mcp_tool_call_id || params.codex_event_id;
-    if (hasInlinePayload && explicitId) {
-      return null;
-    }
-    if (!this.pendingExecApprovalContexts.length) {
-      return null;
-    }
-    if (explicitId) {
-      const index = this.pendingExecApprovalContexts.findIndex((context) => context.call_id === explicitId);
-      if (index >= 0) {
-        return this.pendingExecApprovalContexts.splice(index, 1)[0] || null;
-      }
-    }
-    return this.pendingExecApprovalContexts.shift() || null;
-  }
-  async startSession(config, options) {
-    if (!this.connected) await this.connect();
-    logger.debug("[CodexMCP] Starting Codex session:", config);
-    const response = await this.callToolWithReconnectRetry(
-      () => this.client.callTool({
-        name: "codex",
-        arguments: config
-      }, void 0, {
-        signal: options?.signal,
-        timeout: DEFAULT_TIMEOUT
-      })
-    );
-    logger.debug("[CodexMCP] startSession response:", response);
-    this.extractIdentifiers(response);
-    return response;
-  }
-  async continueSession(prompt, options) {
-    if (!this.connected) await this.connect();
-    if (!this.sessionId) {
-      throw new Error("No active session. Call startSession first.");
-    }
-    if (!this.conversationId) {
-      this.conversationId = this.sessionId;
-      logger.debug("[CodexMCP] conversationId missing, defaulting to sessionId:", this.conversationId);
-    }
-    const args = { sessionId: this.sessionId, conversationId: this.conversationId, prompt };
-    logger.debug("[CodexMCP] Continuing Codex session:", args);
-    const response = await this.callToolWithReconnectRetry(
-      () => this.client.callTool({
-        name: "codex-reply",
-        arguments: args
-      }, void 0, {
-        signal: options?.signal,
-        timeout: DEFAULT_TIMEOUT
-      })
-    );
-    logger.debug("[CodexMCP] continueSession response:", response);
-    this.extractIdentifiers(response);
-    return response;
-  }
-  updateIdentifiersFromEvent(event) {
-    if (!event || typeof event !== "object") {
-      return;
-    }
-    const candidates = [event];
-    if (event.data && typeof event.data === "object") {
-      candidates.push(event.data);
-    }
-    for (const candidate of candidates) {
-      const sessionId = candidate.session_id ?? candidate.sessionId ?? candidate.thread_id ?? candidate.threadId;
-      if (sessionId) {
-        this.sessionId = sessionId;
-        logger.debug("[CodexMCP] Session ID extracted from event:", this.sessionId);
-      }
-      const conversationId = candidate.conversation_id ?? candidate.conversationId;
-      if (conversationId) {
-        this.conversationId = conversationId;
-        logger.debug("[CodexMCP] Conversation ID extracted from event:", this.conversationId);
-      }
-    }
-  }
-  extractIdentifiers(response) {
-    const identifiers = extractCodexIdentifiers(response);
-    if (identifiers.sessionId) {
-      this.sessionId = identifiers.sessionId;
-      logger.debug("[CodexMCP] Session ID extracted:", this.sessionId);
-    }
-    if (identifiers.conversationId) {
-      this.conversationId = identifiers.conversationId;
-      logger.debug("[CodexMCP] Conversation ID extracted:", this.conversationId);
-    }
-    const content = response?.content;
-    if (Array.isArray(content)) {
-      for (const item of content) {
-        if (!this.sessionId && item?.sessionId) {
-          this.sessionId = item.sessionId;
-          logger.debug("[CodexMCP] Session ID extracted from content:", this.sessionId);
-        }
-        if (!this.conversationId && item && typeof item === "object" && "conversationId" in item && item.conversationId) {
-          this.conversationId = item.conversationId;
-          logger.debug("[CodexMCP] Conversation ID extracted from content:", this.conversationId);
-        }
-      }
-    }
-  }
-  getSessionId() {
-    return this.sessionId;
-  }
-  hasActiveSession() {
-    return this.sessionId !== null;
-  }
-  clearSession() {
-    const previousSessionId = this.sessionId;
-    this.sessionId = null;
-    this.conversationId = null;
-    logger.debug("[CodexMCP] Session cleared, previous sessionId:", previousSessionId);
-  }
-  /**
-   * Store the current session ID without clearing it, useful for abort handling
-   */
-  storeSessionForResume() {
-    logger.debug("[CodexMCP] Storing session for potential resume:", this.sessionId);
-    return this.sessionId;
-  }
-  /**
-   * Force close the Codex MCP transport and clear all session identifiers.
-   * Use this for permanent shutdown (e.g. kill/exit). Prefer `disconnect()` for
-   * transient connection resets where you may want to keep the session id.
-   */
-  async forceCloseSession() {
-    logger.debug("[CodexMCP] Force closing session");
-    try {
-      await this.disconnect();
-    } finally {
-      this.clearSession();
-    }
-    logger.debug("[CodexMCP] Session force-closed");
-  }
-  async disconnect() {
-    if (!this.connected) return;
-    const pid = this.transport?.pid ?? null;
-    logger.debug(`[CodexMCP] Disconnecting; child pid=${pid ?? "none"}`);
-    try {
-      logger.debug("[CodexMCP] client.close begin");
-      await this.client.close();
-      logger.debug("[CodexMCP] client.close done");
-    } catch (e) {
-      logger.debug("[CodexMCP] Error closing client, attempting transport close directly", e);
-      try {
-        logger.debug("[CodexMCP] transport.close begin");
-        await this.transport?.close?.();
-        logger.debug("[CodexMCP] transport.close done");
-      } catch {
-      }
-    }
-    if (pid) {
-      try {
-        process.kill(pid, 0);
-        logger.debug("[CodexMCP] Child still alive, sending SIGKILL");
-        try {
-          process.kill(pid, "SIGKILL");
-        } catch {
-        }
-      } catch {
-      }
-    }
-    this.transport = null;
-    this.connected = false;
-    this.client = this.createClient();
-    logger.debug(`[CodexMCP] Disconnected; session ${this.sessionId ?? "none"} preserved`);
-  }
-}
-
 class CodexPermissionHandler extends BasePermissionHandler {
   constructor(session) {
     super(session);
@@ -1035,16 +612,7 @@ class CodexPermissionHandler extends BasePermissionHandler {
    * @returns Promise resolving to permission result
    */
   async handleToolCall(toolCallId, toolName, input) {
-    return new Promise((resolve, reject) => {
-      this.pendingRequests.set(toolCallId, {
-        resolve,
-        reject,
-        toolName,
-        input
-      });
-      this.addPendingRequestToState(toolCallId, toolName, input);
-      logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId})`);
-    });
+    return this.registerPendingRequest(toolCallId, toolName, input);
   }
 }
 
@@ -1061,11 +629,15 @@ class CodexSelectionHandler {
   }
   async requestSelection(request) {
     return new Promise((resolve, reject) => {
-      this.pendingRequests.set(request.id, {
+      const pending = {
         resolve,
         reject,
         request
-      });
+      };
+      pending.timeoutHandle = setTimeout(() => {
+        this.handleSelectionTimeout(request.id, pending);
+      }, getPendingInteractionTimeoutMs());
+      this.pendingRequests.set(request.id, pending);
       this.session.updateAgentState((currentState) => ({
         ...currentState,
         requests: {
@@ -1108,6 +680,7 @@ class CodexSelectionHandler {
     this.pendingRequests.clear();
     const completedAt = Date.now();
     for (const [, pending] of pendingSnapshot) {
+      this.clearPendingRequestTimeout(pending);
       pending.reject(new Error(reason));
     }
     this.session.updateAgentState((currentState) => {
@@ -1139,6 +712,7 @@ class CodexSelectionHandler {
     const pendingSnapshot = Array.from(this.pendingRequests.entries());
     this.pendingRequests.clear();
     for (const [, pending] of pendingSnapshot) {
+      this.clearPendingRequestTimeout(pending);
       pending.reject(new Error(reason));
     }
     this.session.updateAgentState((currentState) => {
@@ -1172,6 +746,7 @@ class CodexSelectionHandler {
         return;
       }
       this.pendingRequests.delete(response.id);
+      this.clearPendingRequestTimeout(pending);
       pending.resolve(response);
       this.session.updateAgentState((currentState) => {
         const request = currentState.requests?.[response.id];
@@ -1196,6 +771,54 @@ class CodexSelectionHandler {
       });
     });
   }
+  clearPendingRequestTimeout(pending) {
+    if (pending?.timeoutHandle) {
+      clearTimeout(pending.timeoutHandle);
+      pending.timeoutHandle = void 0;
+    }
+  }
+  handleSelectionTimeout(requestId, pending) {
+    const active = this.pendingRequests.get(requestId);
+    if (!active || active !== pending) {
+      return;
+    }
+    this.pendingRequests.delete(requestId);
+    this.clearPendingRequestTimeout(active);
+    active.reject(new Error(INTERACTION_TIMED_OUT_ERROR));
+    this.session.updateAgentState((currentState) => {
+      const request = currentState.requests?.[requestId] || {
+        tool: "AskUserQuestion",
+        arguments: {
+          requestKind: "selection",
+          questions: []
+        },
+        createdAt: Date.now(),
+        requestKind: "selection",
+        options: active.request.options,
+        defaultOptionId: active.request.defaultOptionId
+      };
+      const { [requestId]: _, ...remainingRequests } = currentState.requests || {};
+      return {
+        ...currentState,
+        requests: remainingRequests,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [requestId]: {
+            ...request,
+            completedAt: Date.now(),
+            status: "canceled",
+            reason: INTERACTION_TIMED_OUT_ERROR,
+            requestKind: "selection"
+          }
+        }
+      };
+    });
+    this.session.sendSessionEvent({
+      type: "message",
+      message: "Pending interaction timed out waiting for a response. Send a new message to continue."
+    });
+    logger.debug(`[Codex] Selection request timed out (${requestId})`);
+  }
 }
 
 class ReasoningProcessor extends BaseReasoningProcessor {
@@ -1217,67 +840,62 @@ class ReasoningProcessor extends BaseReasoningProcessor {
   complete(fullText) {
     this.completeReasoning(fullText);
   }
+  completeCurrent() {
+    return this.completeReasoning();
+  }
 }
 
-class DiffProcessor {
-  previousDiff = null;
-  onMessage = null;
-  constructor(onMessage) {
-    this.onMessage = onMessage || null;
-  }
-  /**
-   * Process a turn_diff message and check if the unified_diff has changed
-   */
-  processDiff(unifiedDiff) {
-    if (this.previousDiff !== unifiedDiff) {
-      logger.debug("[DiffProcessor] Unified diff changed, sending CodexDiff tool call");
-      const callId = randomUUID();
-      const toolCall = {
-        type: "tool-call",
-        name: "CodexDiff",
-        callId,
-        input: {
-          unified_diff: unifiedDiff
-        },
-        id: randomUUID()
-      };
-      this.onMessage?.(toolCall);
-      const toolResult = {
-        type: "tool-call-result",
-        callId,
-        output: {
-          status: "completed"
-        },
-        id: randomUUID()
-      };
-      this.onMessage?.(toolResult);
-    }
-    this.previousDiff = unifiedDiff;
-    logger.debug("[DiffProcessor] Updated stored diff");
-  }
-  /**
-   * Reset the processor state (called on task_complete or turn_aborted)
-   */
-  reset() {
-    logger.debug("[DiffProcessor] Resetting diff state");
-    this.previousDiff = null;
-  }
-  /**
-   * Set the message callback for sending messages directly
-   */
-  setMessageCallback(callback) {
-    this.onMessage = callback;
+function createAbortError() {
+  const error = new Error("Operation aborted");
+  error.name = "AbortError";
+  return error;
+}
+async function waitForResponseCompleteWithAbort(backend, signal, timeoutMs = 12e4) {
+  if (!backend.waitForResponseComplete) {
+    return;
   }
-  /**
-   * Get the current diff value
-   */
-  getCurrentDiff() {
-    return this.previousDiff;
+  if (signal.aborted) {
+    throw createAbortError();
   }
+  await new Promise((resolve, reject) => {
+    const onAbort = () => reject(createAbortError());
+    signal.addEventListener("abort", onAbort, { once: true });
+    backend.waitForResponseComplete(timeoutMs).then(resolve).catch(reject).finally(() => {
+      signal.removeEventListener("abort", onAbort);
+    });
+  });
 }
-
-function shouldEmitCodexReadyOnTurnEnd(opts) {
-  return !opts.shouldExit && opts.exitReason !== "switch";
+function normalizeCodexBackendError(error) {
+  const record = typeof error === "object" && error !== null ? error : null;
+  const text = formatDisplayMessage(error).trim();
+  const stderrText = record ? formatDisplayMessage(record.stderr).trim() : "";
+  const detailText = record ? formatDisplayMessage(record.detail).trim() : "";
+  const searchableText = [text, stderrText, detailText].filter(Boolean).join("\n");
+  const prefix = typeof error === "object" && error !== null ? [
+    record?.code !== void 0 && record?.code !== null ? `[code=${String(record.code)}]` : "",
+    record?.status !== void 0 && record?.status !== null ? `[status=${String(record.status)}]` : ""
+  ].filter(Boolean).join(" ") : "";
+  if (searchableText.includes("Failed to locate @zed-industries/codex-acp-")) {
+    const hint = "Codex ACP could not start because the @zed-industries/codex-acp platform binary is missing. Reinstall codex-acp for this machine, or set HAPPY_CODEX_ACP_BIN to a working codex-acp executable.";
+    return prefix ? `${prefix} ${hint}` : hint;
+  }
+  if (searchableText.includes("method not found: initialize") || searchableText.includes("method not found: session/new")) {
+    const hint = "The configured Codex ACP command does not speak the ACP protocol. Make sure HAPPY_CODEX_ACP_BIN points to codex-acp, not the codex CLI.";
+    return prefix ? `${prefix} ${hint}` : hint;
+  }
+  if (error instanceof Error && text) {
+    return text;
+  }
+  if (typeof error === "object" && error !== null && !Array.isArray(error) && Object.keys(error).length === 0) {
+    return "Codex backend exited unexpectedly";
+  }
+  if (typeof error === "object" && error !== null) {
+    const message = text;
+    if (message) {
+      return prefix ? `${prefix} ${message}` : message;
+    }
+  }
+  return text || "Codex backend exited unexpectedly";
 }
 function shouldEmitCodexReadyAfterWait(opts) {
   if (opts.readyAlreadySent) {
@@ -1290,6 +908,68 @@ function registerCodexRemoteRpcHandlers(clientSession, handlers) {
   clientSession.rpcHandlerManager.registerHandler("switch", handlers.handleSwitchToLocal);
   registerKillSessionHandler(clientSession.rpcHandlerManager, handlers.handleKillSession);
 }
+function handleIncomingCodexMessageDuringRemoteTurn(opts) {
+  const reason = opts.reason ?? INTERACTION_SUPERSEDED_ERROR;
+  const supersededPermissions = opts.supersedePermissions(reason);
+  const supersededSelections = opts.supersedeSelections(reason);
+  const interruptedTurn = opts.turnInFlight;
+  const total = supersededPermissions + supersededSelections;
+  if (interruptedTurn) {
+    opts.abortActiveTurn();
+  }
+  if (total > 0 || interruptedTurn) {
+    const message = interruptedTurn ? "Current Codex task was canceled because a new user message arrived. Processing the latest message instead." : "Previous pending interaction was canceled because a new user message arrived. Processing the latest message instead.";
+    opts.onInterrupted(message);
+  }
+  return total > 0 || interruptedTurn;
+}
+function resolveCodexAcpExecutionMode(mode) {
+  const approvalPolicy = (() => {
+    switch (mode.permissionMode) {
+      case "default":
+        return "on-request";
+      case "read-only":
+        return "on-request";
+      case "safe-yolo":
+        return "on-request";
+      case "yolo":
+        return "never";
+      case "bypassPermissions":
+        return "never";
+      case "acceptEdits":
+        return "on-request";
+      case "plan":
+        return "on-request";
+      default:
+        return "on-request";
+    }
+  })();
+  const sandbox = (() => {
+    switch (mode.permissionMode) {
+      case "default":
+        return "workspace-write";
+      case "read-only":
+        return "read-only";
+      case "safe-yolo":
+        return "workspace-write";
+      case "yolo":
+        return "danger-full-access";
+      case "bypassPermissions":
+        return "danger-full-access";
+      case "acceptEdits":
+        return "workspace-write";
+      case "plan":
+        return "read-only";
+      default:
+        return "read-only";
+    }
+  })();
+  return {
+    approvalPolicy,
+    sandbox,
+    model: mode.model
+  };
+}
 async function codexRemoteLauncher(session) {
   const messageBuffer = new MessageBuffer();
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
@@ -1297,46 +977,26 @@ async function codexRemoteLauncher(session) {
   let exitReason = null;
   let shouldExit = false;
   let abortController = new AbortController();
-  let storedSessionIdForResume = null;
-  const client = new CodexMcpClient();
-  let pendingModeResumeFile = null;
+  let turnInFlight = false;
+  let backend = null;
+  let acpSessionId = null;
+  let wasSessionCreated = false;
+  let currentModeHash = null;
+  let pending = null;
+  let readyAlreadySent = false;
+  let accumulatedResponse = "";
+  let isResponseInProgress = false;
+  let taskStartedSent = false;
   const permissionHandler = new CodexPermissionHandler(session.client);
   const selectionHandler = new CodexSelectionHandler(session.client);
   const reasoningProcessor = new ReasoningProcessor((message) => {
     session.runtimeSession.sendCodexMessage(message);
   });
-  const diffProcessor = new DiffProcessor((message) => {
-    session.runtimeSession.sendCodexMessage(message);
-  });
-  const handleSwitchToLocal = async () => {
-    logger.debug("[Codex] Switching to local from RPC");
-    exitReason = "switch";
-    shouldExit = true;
-    await handleAbort();
-  };
-  client.setPermissionHandler(permissionHandler);
-  client.setSelectionHandler(selectionHandler);
-  session.setPendingInteractionSuperseder((reason = INTERACTION_SUPERSEDED_ERROR) => {
-    const supersededPermissions = permissionHandler.supersedePendingRequests(reason);
-    const supersededSelections = selectionHandler.supersedePendingRequests(reason);
-    const total = supersededPermissions + supersededSelections;
-    if (total > 0) {
-      const message = "Previous pending interaction was canceled because a new user message arrived. Processing the latest message instead.";
-      messageBuffer.addMessage(message, "status");
-      session.runtimeSession.sendSessionEvent({ type: "message", message });
-    }
-    return total > 0;
-  });
-  const handleClientSwap = (clientSession) => {
-    permissionHandler.updateSession(clientSession);
-    selectionHandler.updateSession(clientSession);
-    registerCodexRemoteRpcHandlers(clientSession, {
-      handleAbort,
-      handleSwitchToLocal,
-      handleKillSession
-    });
+  const rotateAbortController = () => {
+    const activeController = abortController;
+    abortController = new AbortController();
+    return activeController;
   };
-  session.addClientSwapCallback(handleClientSwap);
   const sendReady = () => {
     session.runtimeSession.sendSessionEvent({ type: "ready" });
     try {
@@ -1349,18 +1009,282 @@ async function codexRemoteLauncher(session) {
       logger.debug("[Codex] Failed to send ready push", pushError);
     }
   };
+  const resetTurnState = () => {
+    reasoningProcessor.abort();
+    accumulatedResponse = "";
+    isResponseInProgress = false;
+    taskStartedSent = false;
+    session.onThinkingChange(false);
+  };
+  const abortActiveTurn = () => {
+    const activeController = rotateAbortController();
+    activeController.abort();
+    reasoningProcessor.abort();
+    session.onThinkingChange(false);
+    if (backend && acpSessionId) {
+      void backend.cancel(acpSessionId).catch((error) => {
+        logger.debug("[Codex] Error cancelling ACP session:", error);
+      });
+    }
+  };
+  const disposeBackend = async () => {
+    if (!backend) {
+      return;
+    }
+    const currentBackend = backend;
+    backend = null;
+    acpSessionId = null;
+    wasSessionCreated = false;
+    try {
+      await currentBackend.dispose();
+    } catch (error) {
+      logger.debug("[Codex] Error disposing ACP backend:", error);
+    }
+  };
+  const emitFinalAssistantMessage = () => {
+    if (!accumulatedResponse.trim()) {
+      return;
+    }
+    session.runtimeSession.sendCodexMessage({
+      type: "message",
+      message: accumulatedResponse,
+      id: randomUUID()
+    });
+    accumulatedResponse = "";
+    isResponseInProgress = false;
+  };
+  const setupBackendMessageHandler = (currentBackend) => {
+    currentBackend.onMessage((msg) => {
+      switch (msg.type) {
+        case "model-output": {
+          const text = msg.textDelta ?? msg.fullText ?? "";
+          if (!text) {
+            return;
+          }
+          if (!isResponseInProgress) {
+            messageBuffer.removeLastMessage("system");
+            messageBuffer.addMessage(text, "assistant");
+            isResponseInProgress = true;
+          } else {
+            messageBuffer.updateLastMessage(text, "assistant");
+          }
+          accumulatedResponse += text;
+          return;
+        }
+        case "status": {
+          if (msg.status === "running") {
+            session.onThinkingChange(true);
+            if (!taskStartedSent) {
+              session.runtimeSession.sendCodexMessage({
+                type: "task_started",
+                id: randomUUID()
+              });
+              taskStartedSent = true;
+            }
+            if (!isResponseInProgress) {
+              messageBuffer.addMessage("Thinking...", "system");
+            }
+            return;
+          }
+          if (msg.status === "idle" || msg.status === "stopped") {
+            reasoningProcessor.completeCurrent();
+            return;
+          }
+          if (msg.status === "error") {
+            const errorMessage = normalizeCodexBackendError(msg.detail);
+            messageBuffer.addMessage(`Error: ${errorMessage}`, "status");
+            return;
+          }
+          return;
+        }
+        case "tool-call": {
+          const toolArgs = msg.args ? truncateDisplayMessage(msg.args, 100) : "";
+          messageBuffer.addMessage(
+            `Executing: ${msg.toolName}${toolArgs ? ` ${toolArgs}` : ""}`,
+            "tool"
+          );
+          session.runtimeSession.sendCodexMessage({
+            type: "tool-call",
+            name: msg.toolName,
+            callId: msg.callId,
+            input: msg.args,
+            id: randomUUID()
+          });
+          return;
+        }
+        case "tool-result": {
+          const isError = msg.result && typeof msg.result === "object" && "error" in msg.result;
+          const resultText = truncateDisplayMessage(msg.result, 200) || (isError ? "Unknown error" : "");
+          messageBuffer.addMessage(
+            `${isError ? "Error:" : "Result:"} ${resultText}`.trim(),
+            "result"
+          );
+          session.runtimeSession.sendCodexMessage({
+            type: "tool-call-result",
+            callId: msg.callId,
+            output: msg.result,
+            id: randomUUID()
+          });
+          return;
+        }
+        case "fs-edit": {
+          messageBuffer.addMessage(`File edit: ${msg.description}`, "tool");
+          session.runtimeSession.sendCodexMessage({
+            type: "file-edit",
+            description: msg.description,
+            filePath: msg.path || "unknown",
+            diff: msg.diff,
+            id: randomUUID()
+          });
+          return;
+        }
+        case "terminal-output": {
+          const terminalOutput = formatDisplayMessage(msg.data);
+          messageBuffer.addMessage(terminalOutput, "result");
+          session.runtimeSession.sendCodexMessage({
+            type: "terminal-output",
+            data: terminalOutput,
+            callId: randomUUID()
+          });
+          return;
+        }
+        case "permission-request": {
+          const payload = msg.payload || {};
+          session.runtimeSession.sendCodexMessage({
+            type: "permission-request",
+            permissionId: msg.id,
+            toolName: typeof payload.toolName === "string" ? payload.toolName : msg.reason,
+            description: msg.reason,
+            options: payload
+          });
+          return;
+        }
+        case "exec-approval-request": {
+          const { call_id, type, ...inputs } = msg;
+          messageBuffer.addMessage(`Exec approval requested: ${call_id}`, "tool");
+          session.runtimeSession.sendCodexMessage({
+            type: "tool-call",
+            name: "CodexBash",
+            callId: call_id,
+            input: inputs,
+            id: randomUUID()
+          });
+          return;
+        }
+        case "patch-apply-begin": {
+          const changeCount = Object.keys(msg.changes || {}).length;
+          const filesMsg = changeCount === 1 ? "1 file" : `${changeCount} files`;
+          messageBuffer.addMessage(`Modifying ${filesMsg}...`, "tool");
+          session.runtimeSession.sendCodexMessage({
+            type: "tool-call",
+            name: "CodexPatch",
+            callId: msg.call_id,
+            input: {
+              auto_approved: msg.auto_approved,
+              changes: msg.changes
+            },
+            id: randomUUID()
+          });
+          return;
+        }
+        case "patch-apply-end": {
+          if (msg.success) {
+            messageBuffer.addMessage(truncateDisplayMessage(msg.stdout || "Files modified successfully", 200), "result");
+          } else {
+            messageBuffer.addMessage(`Error: ${truncateDisplayMessage(msg.stderr || "Failed to modify files", 200)}`, "result");
+          }
+          session.runtimeSession.sendCodexMessage({
+            type: "tool-call-result",
+            callId: msg.call_id,
+            output: {
+              stdout: msg.stdout,
+              stderr: msg.stderr,
+              success: msg.success
+            },
+            id: randomUUID()
+          });
+          return;
+        }
+        case "token-count": {
+          session.runtimeSession.sendCodexMessage({
+            ...msg,
+            id: randomUUID()
+          });
+          return;
+        }
+        case "event": {
+          if (msg.name === "thinking") {
+            const thinkingPayload = msg.payload;
+            const thinkingText = typeof thinkingPayload?.text === "string" ? thinkingPayload.text : "";
+            if (thinkingText) {
+              reasoningProcessor.processDelta(thinkingText);
+              if (!thinkingText.startsWith("**")) {
+                messageBuffer.updateLastMessage(`[Thinking] ${thinkingText.substring(0, 100)}...`, "system");
+              }
+            }
+          }
+          return;
+        }
+        default:
+          return;
+      }
+    });
+  };
+  const createBackend = (mode) => {
+    const executionMode = resolveCodexAcpExecutionMode(mode);
+    const validation = validateCodexAcpSpawn({
+      command: process.env.HAPPY_CODEX_ACP_COMMAND,
+      model: executionMode.model,
+      sandbox: executionMode.sandbox,
+      approvalPolicy: executionMode.approvalPolicy,
+      baseArgs: session.codexArgs
+    });
+    if (!validation.ok) {
+      throw new Error(validation.errorMessage);
+    }
+    const result = createCodexBackend({
+      cwd: session.path,
+      baseArgs: session.codexArgs,
+      model: executionMode.model,
+      sandbox: executionMode.sandbox,
+      approvalPolicy: executionMode.approvalPolicy,
+      mcpServers: {},
+      permissionHandler,
+      selectionHandler: {
+        handleSelection: (request) => selectionHandler.requestSelection(request)
+      }
+    });
+    backend = result.backend;
+    setupBackendMessageHandler(result.backend);
+    return result.backend;
+  };
+  const handleSwitchToLocal = async () => {
+    logger.debug("[Codex] Switching to local from RPC");
+    session.pinLocalMode();
+    exitReason = "switch";
+    shouldExit = true;
+    await handleAbort();
+  };
+  session.setPendingInteractionSuperseder((reason = INTERACTION_SUPERSEDED_ERROR) => {
+    return handleIncomingCodexMessageDuringRemoteTurn({
+      reason,
+      supersedePermissions: (value) => permissionHandler.supersedePendingRequests(value),
+      supersedeSelections: (value) => selectionHandler.supersedePendingRequests(value),
+      turnInFlight,
+      abortActiveTurn,
+      onInterrupted: (message) => {
+        logger.debug("[Codex] Incoming user message interrupted ACP remote turn");
+        messageBuffer.addMessage(message, "status");
+        session.runtimeSession.sendSessionEvent({ type: "message", message });
+      }
+    });
+  });
   async function handleAbort() {
     logger.debug("[Codex] Abort requested - stopping current task");
     try {
-      if (client.hasActiveSession()) {
-        storedSessionIdForResume = client.storeSessionForResume();
-      }
-      abortController.abort();
-      reasoningProcessor.abort();
+      abortActiveTurn();
     } catch (error) {
       logger.debug("[Codex] Error during abort:", error);
-    } finally {
-      abortController = new AbortController();
     }
   }
   async function handleKillSession() {
@@ -1377,7 +1301,7 @@ async function codexRemoteLauncher(session) {
       session.runtimeSession.sendSessionDeath();
       await session.runtimeSession.flush();
       await session.runtimeSession.close();
-      await client.forceCloseSession();
+      await disposeBackend();
       stopCaffeinate();
       process.exit(0);
     } catch (error) {
@@ -1385,6 +1309,16 @@ async function codexRemoteLauncher(session) {
       process.exit(1);
     }
   }
+  const handleClientSwap = (clientSession) => {
+    permissionHandler.updateSession(clientSession);
+    selectionHandler.updateSession(clientSession);
+    registerCodexRemoteRpcHandlers(clientSession, {
+      handleAbort,
+      handleSwitchToLocal,
+      handleKillSession
+    });
+  };
+  session.addClientSwapCallback(handleClientSwap);
   if (hasTTY) {
     console.clear();
     inkInstance = render(React.createElement(CodexDisplay, {
@@ -1399,6 +1333,7 @@ async function codexRemoteLauncher(session) {
       },
       onSwitchToLocal: async () => {
         logger.debug("[Codex] Switching to local from local keyboard");
+        session.pinLocalMode();
         exitReason = "switch";
         shouldExit = true;
         await handleAbort();
@@ -1420,116 +1355,7 @@ async function codexRemoteLauncher(session) {
     handleSwitchToLocal,
     handleKillSession
   });
-  client.setHandler((msg) => {
-    logger.debug(`[Codex] Message: ${JSON.stringify(msg)}`);
-    if (msg.type === "agent_message") {
-      messageBuffer.addMessage(msg.message, "assistant");
-    } else if (msg.type === "agent_reasoning") {
-      messageBuffer.addMessage(`[Thinking] ${msg.text.substring(0, 100)}...`, "system");
-    } else if (msg.type === "exec_command_begin") {
-      messageBuffer.addMessage(`Executing: ${msg.command}`, "tool");
-    } else if (msg.type === "exec_command_end") {
-      const output = msg.output || msg.error || "Command completed";
-      const truncatedOutput = output.substring(0, 200);
-      messageBuffer.addMessage(`Result: ${truncatedOutput}${output.length > 200 ? "..." : ""}`, "result");
-    } else if (msg.type === "task_started") {
-      messageBuffer.addMessage("Starting task...", "status");
-      session.onThinkingChange(true);
-    } else if (msg.type === "task_complete") {
-      messageBuffer.addMessage("Task completed", "status");
-      session.onThinkingChange(false);
-      diffProcessor.reset();
-      if (shouldEmitCodexReadyOnTurnEnd({ shouldExit, exitReason })) {
-        sendReady();
-        readyAlreadySent = true;
-      }
-    } else if (msg.type === "turn_aborted") {
-      messageBuffer.addMessage("Turn aborted", "status");
-      session.onThinkingChange(false);
-      diffProcessor.reset();
-      if (shouldEmitCodexReadyOnTurnEnd({ shouldExit, exitReason })) {
-        sendReady();
-        readyAlreadySent = true;
-      }
-    }
-    if (msg.type === "agent_reasoning_section_break") {
-      reasoningProcessor.handleSectionBreak();
-    }
-    if (msg.type === "agent_reasoning_delta") {
-      reasoningProcessor.processDelta(msg.delta);
-    }
-    if (msg.type === "agent_reasoning") {
-      reasoningProcessor.complete(msg.text);
-    }
-    if (msg.type === "agent_message") {
-      session.runtimeSession.sendCodexMessage({
-        type: "message",
-        message: msg.message,
-        id: randomUUID()
-      });
-    }
-    if (msg.type === "exec_command_begin" || msg.type === "exec_approval_request") {
-      const { call_id, type, ...inputs } = msg;
-      session.runtimeSession.sendCodexMessage({
-        type: "tool-call",
-        name: "CodexBash",
-        callId: call_id,
-        input: inputs,
-        id: randomUUID()
-      });
-    }
-    if (msg.type === "exec_command_end") {
-      const { call_id, type, ...output } = msg;
-      session.runtimeSession.sendCodexMessage({
-        type: "tool-call-result",
-        callId: call_id,
-        output,
-        id: randomUUID()
-      });
-    }
-    if (msg.type === "token_count") {
-      session.runtimeSession.sendCodexMessage({
-        ...msg,
-        id: randomUUID()
-      });
-    }
-    if (msg.type === "patch_apply_begin") {
-      const { call_id, auto_approved, changes } = msg;
-      const changeCount = Object.keys(changes).length;
-      const filesMsg = changeCount === 1 ? "1 file" : `${changeCount} files`;
-      messageBuffer.addMessage(`Modifying ${filesMsg}...`, "tool");
-      session.runtimeSession.sendCodexMessage({
-        type: "tool-call",
-        name: "CodexPatch",
-        callId: call_id,
-        input: { auto_approved, changes },
-        id: randomUUID()
-      });
-    }
-    if (msg.type === "patch_apply_end") {
-      const { call_id, stdout, stderr, success } = msg;
-      if (success) {
-        messageBuffer.addMessage((stdout || "Files modified successfully").substring(0, 200), "result");
-      } else {
-        messageBuffer.addMessage(`Error: ${(stderr || "Failed to modify files").substring(0, 200)}`, "result");
-      }
-      session.runtimeSession.sendCodexMessage({
-        type: "tool-call-result",
-        callId: call_id,
-        output: { stdout, stderr, success },
-        id: randomUUID()
-      });
-    }
-    if (msg.type === "turn_diff" && msg.unified_diff) {
-      diffProcessor.processDiff(msg.unified_diff);
-    }
-  });
-  let readyAlreadySent = false;
   try {
-    await client.connect();
-    let wasCreated = false;
-    let currentModeHash = null;
-    let pending = null;
     while (!shouldExit) {
       let message = pending;
       pending = null;
@@ -1547,122 +1373,71 @@ async function codexRemoteLauncher(session) {
       if (!message) {
         break;
       }
-      if (wasCreated && currentModeHash && message.hash !== currentModeHash) {
+      if (wasSessionCreated && currentModeHash && message.hash !== currentModeHash) {
         messageBuffer.addMessage("\u2550".repeat(40), "status");
         messageBuffer.addMessage("Starting new Codex session (mode changed)...", "status");
-        const prevSessionId = client.getSessionId();
-        pendingModeResumeFile = findCodexResumeFile(prevSessionId);
-        client.clearSession();
+        await disposeBackend();
         session.clearSessionId();
-        wasCreated = false;
         currentModeHash = null;
         pending = message;
         permissionHandler.reset();
         selectionHandler.reset();
-        reasoningProcessor.abort();
-        diffProcessor.reset();
-        session.onThinkingChange(false);
+        resetTurnState();
         continue;
       }
       currentModeHash = message.hash;
       readyAlreadySent = false;
       messageBuffer.addMessage(message.message, "user");
+      const turnSignal = abortController.signal;
       try {
-        const approvalPolicy = (() => {
-          switch (message.mode.permissionMode) {
-            case "default":
-              return "untrusted";
-            case "read-only":
-              return "never";
-            case "safe-yolo":
-              return "on-failure";
-            case "yolo":
-              return "on-failure";
-            case "bypassPermissions":
-              return "on-failure";
-            case "acceptEdits":
-              return "on-request";
-            case "plan":
-              return "untrusted";
-            default:
-              return "untrusted";
-          }
-        })();
-        const sandbox = (() => {
-          switch (message.mode.permissionMode) {
-            case "default":
-              return "workspace-write";
-            case "read-only":
-              return "read-only";
-            case "safe-yolo":
-              return "workspace-write";
-            case "yolo":
-              return "danger-full-access";
-            case "bypassPermissions":
-              return "danger-full-access";
-            case "acceptEdits":
-              return "workspace-write";
-            case "plan":
-              return "workspace-write";
-            default:
-              return "workspace-write";
-          }
-        })();
-        if (!wasCreated) {
-          const startConfig = {
-            prompt: message.message,
-            sandbox,
-            "approval-policy": approvalPolicy,
-            config: {}
-          };
-          if (message.mode.model) {
-            startConfig.model = message.mode.model;
-          }
-          let resumeFile = null;
-          if (pendingModeResumeFile) {
-            resumeFile = pendingModeResumeFile;
-            pendingModeResumeFile = null;
-          } else if (storedSessionIdForResume) {
-            resumeFile = findCodexResumeFile(storedSessionIdForResume);
-            storedSessionIdForResume = null;
-          } else if (session.sessionId) {
-            resumeFile = findCodexResumeFile(session.sessionId);
-          }
-          if (resumeFile) {
-            startConfig.config = {
-              ...startConfig.config || {},
-              experimental_resume: resumeFile
-            };
-          }
-          await client.startSession(startConfig, { signal: abortController.signal });
-          const currentSessionId = client.getSessionId();
-          if (currentSessionId) {
-            session.onSessionFound(currentSessionId);
-          }
-          wasCreated = true;
-        } else {
-          await client.continueSession(message.message, { signal: abortController.signal });
+        turnInFlight = true;
+        const activeBackend = backend ?? createBackend(message.mode);
+        if (!activeBackend) {
+          throw new Error("Failed to create Codex ACP backend");
         }
+        if (!acpSessionId) {
+          const { sessionId } = await activeBackend.startSession();
+          acpSessionId = sessionId;
+          wasSessionCreated = true;
+          session.onSessionFound(sessionId);
+        }
+        session.onThinkingChange(true);
+        await activeBackend.sendPrompt(acpSessionId, message.message);
+        await waitForResponseCompleteWithAbort(activeBackend, turnSignal);
+        reasoningProcessor.completeCurrent();
       } catch (error) {
-        logger.warn("Error in codex session:", error);
+        logger.warn("Error in codex ACP session:", error);
         const isAbortError = error instanceof Error && error.name === "AbortError";
-        const isExpectedInterruption = isAbortError || abortController.signal.aborted || shouldExit || exitReason === "switch";
-        if (isExpectedInterruption) {
+        const isExpectedInterruption = isAbortError || turnSignal.aborted || shouldExit || exitReason === "switch";
+        if (exitReason === "switch") {
+          messageBuffer.addMessage("Switching to local mode...", "status");
+          session.runtimeSession.sendSessionEvent({ type: "message", message: "Switching to local mode..." });
+        } else if (isExpectedInterruption) {
+          session.runtimeSession.sendCodexMessage({
+            type: "turn_aborted",
+            id: randomUUID()
+          });
           messageBuffer.addMessage("Aborted by user", "status");
           session.runtimeSession.sendSessionEvent({ type: "message", message: "Aborted by user" });
         } else {
-          messageBuffer.addMessage("Process exited unexpectedly", "status");
-          session.runtimeSession.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
-          if (client.hasActiveSession()) {
-            storedSessionIdForResume = client.storeSessionForResume();
-          }
+          const errorMessage = normalizeCodexBackendError(error);
+          messageBuffer.addMessage(errorMessage, "status");
+          session.runtimeSession.sendSessionEvent({ type: "message", message: errorMessage });
+          await disposeBackend();
+          session.clearSessionId();
         }
       } finally {
+        turnInFlight = false;
+        emitFinalAssistantMessage();
+        if (!shouldExit) {
+          session.runtimeSession.sendCodexMessage({
+            type: "task_complete",
+            id: randomUUID()
+          });
+        }
         permissionHandler.reset();
         selectionHandler.reset();
-        reasoningProcessor.abort();
-        diffProcessor.reset();
-        session.onThinkingChange(false);
+        resetTurnState();
         if (shouldEmitCodexReadyAfterWait({
           pending: Boolean(pending),
           queueSize: session.queue.size(),
@@ -1675,15 +1450,7 @@ async function codexRemoteLauncher(session) {
       }
     }
   } finally {
-    client.setHandler(null);
-    client.setPermissionHandler(null);
-    client.setSelectionHandler(null);
-    if (exitReason === "switch") {
-      logger.debug("[Codex] Remote launcher exiting via switch; waiting for MCP transport disconnect");
-      await client.disconnect();
-    } else {
-      await client.forceCloseSession();
-    }
+    await disposeBackend();
     permissionHandler.reset();
     selectionHandler.reset();
     session.setPendingInteractionSuperseder(null);
@@ -1709,20 +1476,21 @@ async function codexRemoteLauncher(session) {
     }
     messageBuffer.clear();
   }
-  logger.debug(`[Codex] Remote launcher returning: ${exitReason || "exit"}`);
+  logger.debug(`[Codex] ACP remote launcher returning: ${exitReason || "exit"}`);
   return exitReason || "exit";
 }
 
 async function codexLoop(opts) {
   let mode = opts.startingMode ?? "local";
-  opts.session.onModeChange(mode);
+  await opts.session.onModeChange(mode);
   while (true) {
     logger.debug(`[codex-loop] Iteration with mode: ${mode}`);
     if (mode === "local") {
       const result = await codexLocalLauncher(opts.session);
       if (result.type === "switch") {
+        opts.session.clearLocalModePin();
         mode = "remote";
-        opts.session.onModeChange(mode);
+        await opts.session.onModeChange(mode);
         continue;
       }
       return result.code;
@@ -1730,13 +1498,53 @@ async function codexLoop(opts) {
     const reason = await codexRemoteLauncher(opts.session);
     if (reason === "switch") {
       mode = "local";
-      opts.session.onModeChange(mode);
+      await opts.session.onModeChange(mode);
       continue;
     }
     return 0;
   }
 }
 
+function supportsAgentStateUpdateEvents(sessionClient) {
+  return typeof sessionClient.once === "function" && typeof sessionClient.off === "function";
+}
+async function syncControlledByUserState(sessionClient, controlledByUser) {
+  if (!supportsAgentStateUpdateEvents(sessionClient)) {
+    sessionClient.updateAgentState((currentState) => ({
+      ...currentState,
+      controlledByUser
+    }));
+    return;
+  }
+  await new Promise((resolve) => {
+    let settled = false;
+    const handleUpdated = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      sessionClient.off("agent-state-updated", handleUpdated);
+      resolve();
+    };
+    const timeout = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      sessionClient.off("agent-state-updated", handleUpdated);
+      resolve();
+    }, 1500);
+    sessionClient.once("agent-state-updated", handleUpdated);
+    sessionClient.updateAgentState((currentState) => ({
+      ...currentState,
+      controlledByUser
+    }));
+  });
+}
+function shouldSupersedeCodexPendingInteractions(opts) {
+  return (opts.currentMode ?? opts.startingMode) === "remote";
+}
 async function runCodex(opts) {
   const sessionTag = randomUUID();
   connectionState.setBackend("Codex");
@@ -1760,7 +1568,15 @@ async function runCodex(opts) {
     machineId,
     startedBy: opts.startedBy
   });
-  const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+  let response = null;
+  try {
+    response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+  } catch (error) {
+    if (!isAuthenticationRequiredError(error)) {
+      throw error;
+    }
+    logger.debug("[codex] Falling back to offline session stub after authentication failure");
+  }
   let sessionClient;
   let codexSession = null;
   const { session: initialSession, reconnectionHandle } = setupOfflineReconnection({
@@ -1802,7 +1618,11 @@ async function runCodex(opts) {
       messageModel = message.meta.model || void 0;
       currentModel = messageModel;
     }
-    if (opts.startingMode === "remote") {
+    if (shouldSupersedeCodexPendingInteractions({
+      startingMode: opts.startingMode,
+      currentMode: codexSession?.mode
+    })) {
+      logger.debug("[codex] Incoming user message superseding active remote interaction");
       codexSession?.supersedePendingInteractions(INTERACTION_SUPERSEDED_ERROR);
     }
     messageQueue.push(message.content.text, {
@@ -1819,12 +1639,9 @@ async function runCodex(opts) {
     mode: opts.startingMode ?? "local",
     messageQueue,
     codexArgs: opts.codexArgs,
-    onModeChange: (mode) => {
+    onModeChange: async (mode) => {
       sessionClient.sendSessionEvent({ type: "switch", mode });
-      sessionClient.updateAgentState((currentState) => ({
-        ...currentState,
-        controlledByUser: mode === "local"
-      }));
+      await syncControlledByUserState(sessionClient, mode === "local");
     }
   });
   try {
@@ -1843,4 +1660,4 @@ async function runCodex(opts) {
   }
 }
 
-export { runCodex };
+export { runCodex, shouldSupersedeCodexPendingInteractions, supportsAgentStateUpdateEvents, syncControlledByUserState };