happy-imou-cloud 2.0.2 → 2.0.4

package/dist/{runCodex-C--ZwAhl.mjs → runCodex-DgKKw3IU.mjs}

@@ -1,19 +1,17 @@
 import { randomUUID } from 'node:crypto';
-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 path, { join } from 'node:path';
+import { l as logger, b as connectionState, A as ApiClient, i as isAuthenticationRequiredError } from './api-CIHTNilH.mjs';
+import { readSettings } from './persistence-sLEqV8vk.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-vNYxNqVZ.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-Di1yEMMv.mjs';
+import { h as hashObject, a as MessageBuffer, r as registerKillSessionHandler, M as MessageQueue2 } from './registerKillSessionHandler-uVHqIC4h.mjs';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import 'axios';
 import 'chalk';
 import 'fs';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
 import 'node:events';
 import 'socket.io-client';
 import 'zod';
@@ -31,6 +29,7 @@ import 'qrcode-terminal';
 import 'node:module';
 import 'open';
 import 'url';
+import 'node:child_process';
 import 'ps-list';
 import 'cross-spawn';
 import 'fastify';
@@ -128,7 +127,6 @@ class CodexSession {
   sessionId;
   mode;
   thinking = false;
-  localModePinned = false;
   keepAliveInterval;
   onModeChangeCallback;
   clientSwapCallbacks = [];
@@ -188,18 +186,6 @@ class CodexSession {
     this.client.keepAlive(this.thinking, 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;
@@ -217,262 +203,7 @@ class CodexSession {
   };
 }
 
-function getCodexSessionsRoot() {
-  const codexHomeDir = process.env.CODEX_HOME || join(os.homedir(), ".codex");
-  return join(codexHomeDir, "sessions");
-}
-function collectFilesRecursive(dir, acc = []) {
-  let entries;
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return acc;
-  }
-  for (const entry of entries) {
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      collectFilesRecursive(full, acc);
-    } else if (entry.isFile()) {
-      acc.push(full);
-    }
-  }
-  return acc;
-}
-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 findLatestCodexSessionIdSince(startTimeMs) {
-  try {
-    const candidates = collectFilesRecursive(getCodexSessionsRoot()).filter((full) => full.endsWith(".jsonl")).filter((full) => {
-      try {
-        return fs.statSync(full).mtimeMs >= startTimeMs;
-      } catch {
-        return false;
-      }
-    }).sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
-    for (const candidate of candidates) {
-      const sessionId = extractCodexSessionIdFromPath(candidate);
-      if (sessionId) {
-        return sessionId;
-      }
-    }
-  } catch {
-    return null;
-  }
-  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) {
-    super(`Codex process exited with code: ${exitCode}`);
-    this.name = "CodexExitCodeError";
-    this.exitCode = exitCode;
-  }
-}
-function terminateCodexLocalChild(pid) {
-  if (!pid) {
-    return;
-  }
-  try {
-    if (process.platform === "win32") {
-      execFileSync("taskkill", ["/F", "/T", "/PID", pid.toString()], { stdio: "ignore" });
-      return;
-    }
-    process.kill(pid, "SIGTERM");
-  } catch (error) {
-    logger.debug("[CodexLocal] Failed to terminate child process", error);
-  }
-}
-async function codexLocal(opts) {
-  const baseArgs = [...opts.codexArgs ?? []];
-  const args = opts.sessionId ? ["resume", opts.sessionId, ...baseArgs] : baseArgs;
-  const startTime = Date.now();
-  let detectedSessionId = opts.sessionId;
-  const codexExecutable = resolveCodexExecutable();
-  logger.debug(`[CodexLocal] Spawning ${codexExecutable} with args: ${JSON.stringify(args)}`);
-  process.stdin.pause();
-  try {
-    await new Promise((resolve, reject) => {
-      const child = spawn(codexExecutable, args, {
-        cwd: opts.path,
-        env: process.env,
-        stdio: "inherit",
-        signal: opts.abort,
-        shell: shouldUseShellForCodex(codexExecutable)
-      });
-      const abortChild = () => {
-        if (child.exitCode === null) {
-          logger.debug(`[CodexLocal] Abort received, terminating child tree pid=${child.pid ?? "none"}`);
-          terminateCodexLocalChild(child.pid);
-        }
-      };
-      opts.abort.addEventListener("abort", abortChild, { once: true });
-      const sessionPoll = setInterval(() => {
-        if (detectedSessionId) {
-          return;
-        }
-        const nextSessionId = findLatestCodexSessionIdSince(startTime);
-        if (nextSessionId) {
-          detectedSessionId = nextSessionId;
-          logger.debug(`[CodexLocal] Detected session ID: ${nextSessionId}`);
-          opts.onSessionFound(nextSessionId);
-        }
-      }, 1e3);
-      child.on("error", (error) => {
-        clearInterval(sessionPoll);
-        opts.abort.removeEventListener("abort", abortChild);
-        reject(error);
-      });
-      child.on("exit", (code, signal) => {
-        clearInterval(sessionPoll);
-        opts.abort.removeEventListener("abort", abortChild);
-        opts.onThinkingChange?.(false);
-        if (signal === "SIGTERM" && opts.abort.aborted) {
-          resolve();
-          return;
-        }
-        if (signal) {
-          reject(new Error(`Codex terminated with signal: ${signal}`));
-          return;
-        }
-        if (code !== 0 && code !== null) {
-          reject(new CodexExitCodeError(code));
-          return;
-        }
-        resolve();
-      });
-    });
-  } finally {
-    process.stdin.resume();
-    opts.onThinkingChange?.(false);
-  }
-  return detectedSessionId;
-}
-
-async function codexLocalLauncher(session) {
-  let exitReason = null;
-  const processAbortController = new AbortController();
-  const exitFuture = new Future();
-  try {
-    async function abort() {
-      if (!processAbortController.signal.aborted) {
-        processAbortController.abort();
-      }
-      await exitFuture.promise;
-    }
-    async function doSwitch() {
-      logger.debug("[codex-local]: switching to remote mode");
-      if (!exitReason) {
-        exitReason = { type: "switch" };
-      }
-      await abort();
-    }
-    async function doAbort() {
-      logger.debug("[codex-local]: abort requested");
-      if (!exitReason) {
-        exitReason = { type: "switch" };
-      }
-      session.queue.reset();
-      await abort();
-    }
-    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) {
-      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) {
-        return exitReason;
-      }
-      try {
-        const sessionId = await codexLocal({
-          path: session.path,
-          sessionId: session.sessionId,
-          abort: processAbortController.signal,
-          codexArgs: session.codexArgs,
-          onSessionFound: session.onSessionFound,
-          onThinkingChange: session.onThinkingChange
-        });
-        if (sessionId) {
-          session.onSessionFound(sessionId);
-        }
-        if (!exitReason) {
-          exitReason = { type: "exit", code: 0 };
-          break;
-        }
-      } catch (error) {
-        logger.debug("[codex-local]: launch error", error);
-        if (error instanceof CodexExitCodeError && !exitReason) {
-          exitReason = { type: "exit", code: error.exitCode };
-          break;
-        }
-        if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "EINVAL") && !exitReason) {
-          exitReason = { type: "exit", code: 1 };
-          session.runtimeSession.sendSessionEvent({ type: "message", message: "Codex CLI not found. Check your local Codex installation." });
-          break;
-        }
-        if (!exitReason) {
-          session.runtimeSession.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
-          continue;
-        }
-        break;
-      }
-    }
-  } finally {
-    exitFuture.resolve(void 0);
-    session.client.rpcHandlerManager.registerHandler("abort", async () => {
-    });
-    session.client.rpcHandlerManager.registerHandler("switch", async () => {
-    });
-    session.queue.setOnMessage(null);
-  }
-  return exitReason || { type: "exit", code: 0 };
-}
-
-const CodexDisplay = ({ messageBuffer, logPath, onExit, onSwitchToLocal, title }) => {
+const CodexDisplay = ({ messageBuffer, logPath, onExit, title }) => {
   const [messages, setMessages] = useState([]);
   const [confirmationMode, setConfirmationMode] = useState(null);
   const [actionInProgress, setActionInProgress] = useState(null);
@@ -521,21 +252,10 @@ const CodexDisplay = ({ messageBuffer, logPath, onExit, onSwitchToLocal, title }
       }
       return;
     }
-    if (input === " ") {
-      if (confirmationMode === "switch") {
-        resetConfirmation();
-        setActionInProgress("switching");
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        onSwitchToLocal?.();
-      } else {
-        setConfirmationWithTimeout("switch");
-      }
-      return;
-    }
     if (confirmationMode) {
       resetConfirmation();
     }
-  }, [confirmationMode, actionInProgress, onExit, onSwitchToLocal, setConfirmationWithTimeout, resetConfirmation]));
+  }, [confirmationMode, actionInProgress, onExit, setConfirmationWithTimeout, resetConfirmation]));
   const getMessageColor = (type) => {
     switch (type) {
       case "user":
@@ -587,13 +307,13 @@ const CodexDisplay = ({ messageBuffer, logPath, onExit, onSwitchToLocal, title }
     {
       width: terminalWidth,
       borderStyle: "round",
-      borderColor: actionInProgress ? "gray" : confirmationMode === "exit" ? "red" : confirmationMode === "switch" ? "yellow" : "green",
+      borderColor: actionInProgress ? "gray" : confirmationMode === "exit" ? "red" : "green",
       paddingX: 2,
       justifyContent: "center",
       alignItems: "center",
       flexDirection: "column"
     },
-    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", alignItems: "center" }, actionInProgress === "exiting" ? /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "Exiting agent...") : actionInProgress === "switching" ? /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "Switching to local mode...") : confirmationMode === "exit" ? /* @__PURE__ */ React.createElement(Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit the agent") : confirmationMode === "switch" ? /* @__PURE__ */ React.createElement(Text, { color: "yellow", bold: true }, "\u23F8\uFE0F  Press space again to switch to local mode") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Text, { color: "green", bold: true }, "\u{1F916} Codex Agent Running \u2022 Press space for local \u2022 Ctrl-C to exit")), process.env.DEBUG && logPath && /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
+    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", alignItems: "center" }, actionInProgress === "exiting" ? /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "Exiting agent...") : confirmationMode === "exit" ? /* @__PURE__ */ React.createElement(Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit the agent") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Text, { color: "green", bold: true }, "\u{1F916} Codex Agent Running \u2022 Ctrl-C to exit")), process.env.DEBUG && logPath && /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
   ));
 };
 
@@ -845,6 +565,152 @@ class ReasoningProcessor extends BaseReasoningProcessor {
   }
 }
 
+class ConversationHistory {
+  messages = [];
+  maxMessages;
+  maxCharacters;
+  constructor(options = {}) {
+    this.maxMessages = options.maxMessages ?? 20;
+    this.maxCharacters = options.maxCharacters ?? 5e4;
+  }
+  isDuplicate(role, content) {
+    if (this.messages.length === 0) {
+      return false;
+    }
+    for (let index = this.messages.length - 1; index >= 0; index -= 1) {
+      const message = this.messages[index];
+      if (message.role !== role) {
+        continue;
+      }
+      const normalizedIncoming = content.trim().replace(/\s+/g, " ");
+      const normalizedExisting = message.content.replace(/\s+/g, " ");
+      return normalizedIncoming === normalizedExisting;
+    }
+    return false;
+  }
+  addUserMessage(content) {
+    this.addMessage("user", content);
+  }
+  addAssistantMessage(content) {
+    this.addMessage("assistant", content);
+  }
+  hasHistory() {
+    return this.messages.length > 0;
+  }
+  size() {
+    return this.messages.length;
+  }
+  clear() {
+    this.messages = [];
+    logger.debug("[CodexConversationHistory] History cleared");
+  }
+  getContextForNewSession() {
+    if (this.messages.length === 0) {
+      return "";
+    }
+    const formattedMessages = this.messages.map((message) => {
+      const role = message.role === "user" ? "User" : "Assistant";
+      const content = message.content.length > 2e3 ? `${message.content.slice(0, 2e3)}... [truncated]` : message.content;
+      return `${role}: ${content}`;
+    }).join("\n\n");
+    return [
+      "[PREVIOUS CONVERSATION CONTEXT]",
+      "Continue from the prior Codex session using the conversation below as context.",
+      "",
+      formattedMessages,
+      "",
+      "[END OF PREVIOUS CONTEXT]",
+      ""
+    ].join("\n");
+  }
+  getSummary() {
+    const totalChars = this.messages.reduce((sum, message) => sum + message.content.length, 0);
+    const userCount = this.messages.filter((message) => message.role === "user").length;
+    const assistantCount = this.messages.filter((message) => message.role === "assistant").length;
+    return `${this.messages.length} messages (${userCount} user, ${assistantCount} assistant), ${totalChars} chars`;
+  }
+  addMessage(role, content) {
+    const trimmedContent = content.trim();
+    if (!trimmedContent) {
+      return;
+    }
+    if (this.isDuplicate(role, trimmedContent)) {
+      logger.debug(`[CodexConversationHistory] Skipping duplicate ${role} message (${trimmedContent.length} chars)`);
+      return;
+    }
+    this.messages.push({
+      role,
+      content: trimmedContent,
+      timestamp: Date.now()
+    });
+    this.trimHistory();
+    logger.debug(`[CodexConversationHistory] Added ${role} message (${trimmedContent.length} chars), total: ${this.messages.length}`);
+  }
+  trimHistory() {
+    while (this.messages.length > this.maxMessages) {
+      this.messages.shift();
+    }
+    let totalChars = this.messages.reduce((sum, message) => sum + message.content.length, 0);
+    while (totalChars > this.maxCharacters && this.messages.length > 1) {
+      const removed = this.messages.shift();
+      if (removed) {
+        totalChars -= removed.content.length;
+      }
+    }
+  }
+}
+
+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
+  };
+}
+function getCodexExecutionFingerprint(mode) {
+  return hashObject(resolveCodexAcpExecutionMode(mode));
+}
+
 function createAbortError() {
   const error = new Error("Operation aborted");
   error.name = "AbortError";
@@ -870,7 +736,8 @@ function normalizeCodexBackendError(error) {
   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 dataText = record ? formatDisplayMessage(record.data).trim() : "";
+  const searchableText = [text, stderrText, detailText, dataText].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)}]` : ""
@@ -883,6 +750,9 @@ function normalizeCodexBackendError(error) {
     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 (typeof record?.message === "string" && record.message.trim().toLowerCase() === "internal error" && dataText) {
+    return prefix ? `${prefix} ${dataText}` : dataText;
+  }
   if (error instanceof Error && text) {
     return text;
   }
@@ -897,6 +767,9 @@ function normalizeCodexBackendError(error) {
   }
   return text || "Codex backend exited unexpectedly";
 }
+function getCodexLegacySwitchIgnoredMessage() {
+  return "Codex now runs in ACP-only mode. Staying in the current session.";
+}
 function shouldEmitCodexReadyAfterWait(opts) {
   if (opts.readyAlreadySent) {
     return false;
@@ -923,58 +796,10 @@ function handleIncomingCodexMessageDuringRemoteTurn(opts) {
   }
   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;
   let inkInstance = null;
-  let exitReason = null;
   let shouldExit = false;
   let abortController = new AbortController();
   let turnInFlight = false;
@@ -987,8 +812,10 @@ async function codexRemoteLauncher(session) {
   let accumulatedResponse = "";
   let isResponseInProgress = false;
   let taskStartedSent = false;
+  let shouldInjectHistoryOnNextSession = false;
   const permissionHandler = new CodexPermissionHandler(session.client);
   const selectionHandler = new CodexSelectionHandler(session.client);
+  const conversationHistory = new ConversationHistory({ maxMessages: 20, maxCharacters: 5e4 });
   const reasoningProcessor = new ReasoningProcessor((message) => {
     session.runtimeSession.sendCodexMessage(message);
   });
@@ -1041,10 +868,34 @@ async function codexRemoteLauncher(session) {
       logger.debug("[Codex] Error disposing ACP backend:", error);
     }
   };
+  const emitStatusMessage = (message) => {
+    messageBuffer.addMessage(message, "status");
+    session.runtimeSession.sendSessionEvent({ type: "message", message });
+  };
+  const emitUserVisibleErrorMessage = (message) => {
+    emitStatusMessage(message);
+    session.runtimeSession.sendCodexMessage({
+      type: "message",
+      message,
+      id: randomUUID()
+    });
+  };
+  const queueHistoryInjectionForRestart = (reason) => {
+    messageBuffer.addMessage("\u2550".repeat(40), "status");
+    if (conversationHistory.hasHistory()) {
+      shouldInjectHistoryOnNextSession = true;
+      const message = `${reason} Preserving ${conversationHistory.size()} earlier messages of context.`;
+      emitStatusMessage(message);
+      logger.debug(`[Codex] Will inject conversation history after restart: ${conversationHistory.getSummary()}`);
+      return;
+    }
+    emitStatusMessage(reason);
+  };
   const emitFinalAssistantMessage = () => {
     if (!accumulatedResponse.trim()) {
       return;
     }
+    conversationHistory.addAssistantMessage(accumulatedResponse);
     session.runtimeSession.sendCodexMessage({
       type: "message",
       message: accumulatedResponse,
@@ -1123,7 +974,8 @@ async function codexRemoteLauncher(session) {
             type: "tool-call-result",
             callId: msg.callId,
             output: msg.result,
-            id: randomUUID()
+            id: randomUUID(),
+            isError
           });
           return;
         }
@@ -1201,7 +1053,8 @@ async function codexRemoteLauncher(session) {
               stderr: msg.stderr,
               success: msg.success
             },
-            id: randomUUID()
+            id: randomUUID(),
+            isError: !msg.success
           });
           return;
         }
@@ -1259,11 +1112,9 @@ async function codexRemoteLauncher(session) {
     return result.backend;
   };
   const handleSwitchToLocal = async () => {
-    logger.debug("[Codex] Switching to local from RPC");
-    session.pinLocalMode();
-    exitReason = "switch";
-    shouldExit = true;
-    await handleAbort();
+    const message = getCodexLegacySwitchIgnoredMessage();
+    logger.debug("[Codex] Ignoring legacy switch request because Codex is ACP-only");
+    emitStatusMessage(message);
   };
   session.setPendingInteractionSuperseder((reason = INTERACTION_SUPERSEDED_ERROR) => {
     return handleIncomingCodexMessageDuringRemoteTurn({
@@ -1324,17 +1175,9 @@ async function codexRemoteLauncher(session) {
     inkInstance = render(React.createElement(CodexDisplay, {
       messageBuffer,
       logPath: process.env.DEBUG ? session.logPath : void 0,
-      title: "Remote Mode - Codex Messages",
+      title: "Codex Agent Messages",
       onExit: async () => {
-        logger.debug("[Codex] Switching to exit from local keyboard");
-        exitReason = "exit";
-        shouldExit = true;
-        await handleAbort();
-      },
-      onSwitchToLocal: async () => {
-        logger.debug("[Codex] Switching to local from local keyboard");
-        session.pinLocalMode();
-        exitReason = "switch";
+        logger.debug("[Codex] Exiting Codex ACP session from keyboard");
         shouldExit = true;
         await handleAbort();
       }
@@ -1374,8 +1217,7 @@ async function codexRemoteLauncher(session) {
         break;
       }
       if (wasSessionCreated && currentModeHash && message.hash !== currentModeHash) {
-        messageBuffer.addMessage("\u2550".repeat(40), "status");
-        messageBuffer.addMessage("Starting new Codex session (mode changed)...", "status");
+        queueHistoryInjectionForRestart("Starting new Codex session (execution settings changed)...");
         await disposeBackend();
         session.clearSessionId();
         currentModeHash = null;
@@ -1402,27 +1244,33 @@ async function codexRemoteLauncher(session) {
           session.onSessionFound(sessionId);
         }
         session.onThinkingChange(true);
-        await activeBackend.sendPrompt(acpSessionId, message.message);
+        let promptToSend = message.message;
+        if (shouldInjectHistoryOnNextSession && conversationHistory.hasHistory()) {
+          const historyContext = conversationHistory.getContextForNewSession();
+          promptToSend = historyContext + promptToSend;
+          logger.debug(`[Codex] Injected conversation history context (${historyContext.length} chars)`);
+        }
+        conversationHistory.addUserMessage(message.message);
+        await activeBackend.sendPrompt(acpSessionId, promptToSend);
         await waitForResponseCompleteWithAbort(activeBackend, turnSignal);
         reasoningProcessor.completeCurrent();
+        shouldInjectHistoryOnNextSession = false;
       } catch (error) {
         logger.warn("Error in codex ACP session:", error);
         const isAbortError = error instanceof Error && error.name === "AbortError";
-        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) {
+        const isExpectedInterruption = isAbortError || turnSignal.aborted || shouldExit;
+        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" });
+          emitStatusMessage("Aborted by user");
         } else {
           const errorMessage = normalizeCodexBackendError(error);
-          messageBuffer.addMessage(errorMessage, "status");
-          session.runtimeSession.sendSessionEvent({ type: "message", message: errorMessage });
+          emitUserVisibleErrorMessage(errorMessage);
+          if (conversationHistory.hasHistory()) {
+            shouldInjectHistoryOnNextSession = true;
+          }
           await disposeBackend();
           session.clearSessionId();
         }
@@ -1476,33 +1324,16 @@ async function codexRemoteLauncher(session) {
     }
     messageBuffer.clear();
   }
-  logger.debug(`[Codex] ACP remote launcher returning: ${exitReason || "exit"}`);
-  return exitReason || "exit";
+  logger.debug("[Codex] ACP remote launcher returning: exit");
+  return "exit";
 }
 
 async function codexLoop(opts) {
-  let mode = opts.startingMode ?? "local";
-  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";
-        await opts.session.onModeChange(mode);
-        continue;
-      }
-      return result.code;
-    }
-    const reason = await codexRemoteLauncher(opts.session);
-    if (reason === "switch") {
-      mode = "local";
-      await opts.session.onModeChange(mode);
-      continue;
-    }
-    return 0;
-  }
+  const displayMode = opts.startingMode ?? "local";
+  await opts.session.onModeChange(displayMode);
+  logger.debug(`[codex-loop] Starting ACP-only Codex launcher with display mode: ${displayMode}`);
+  await codexRemoteLauncher(opts.session);
+  return 0;
 }
 
 function supportsAgentStateUpdateEvents(sessionClient) {
@@ -1543,16 +1374,46 @@ async function syncControlledByUserState(sessionClient, controlledByUser) {
   });
 }
 function shouldSupersedeCodexPendingInteractions(opts) {
-  return (opts.currentMode ?? opts.startingMode) === "remote";
+  return true;
+}
+function resolveInitialCodexPermissionMode(opts) {
+  if (opts.permissionMode) {
+    return opts.permissionMode;
+  }
+  const startingMode = opts.startingMode ?? (opts.startedBy === "daemon" ? "remote" : "local");
+  if (opts.startedBy === "daemon" && startingMode === "remote") {
+    return "yolo";
+  }
+  return void 0;
+}
+function resolveQueuedCodexPermissionMode(opts) {
+  if (opts.preserveCurrentOnDefault && opts.messagePermissionMode === "default" && opts.currentPermissionMode) {
+    return opts.currentPermissionMode;
+  }
+  return opts.messagePermissionMode ?? opts.currentPermissionMode ?? "default";
+}
+function resolveIncomingCodexPermissionMode(opts) {
+  const resolvedPermissionMode = resolveQueuedCodexPermissionMode(opts);
+  return {
+    resolvedPermissionMode,
+    nextCurrentPermissionMode: resolvedPermissionMode
+  };
 }
 async function runCodex(opts) {
   const sessionTag = randomUUID();
   connectionState.setBackend("Codex");
-  if (opts.startedBy === "daemon" && opts.startingMode === "local") {
+  const requestedStartingMode = opts.startingMode ?? (opts.startedBy === "daemon" ? "remote" : "local");
+  const initialPermissionMode = resolveInitialCodexPermissionMode({
+    permissionMode: opts.permissionMode,
+    startedBy: opts.startedBy,
+    startingMode: requestedStartingMode
+  });
+  const preserveCurrentPermissionModeForRemoteDefault = opts.startedBy === "daemon" && requestedStartingMode === "remote";
+  if (opts.startedBy === "daemon" && requestedStartingMode === "local") {
     throw new Error("Daemon-spawned Codex sessions cannot use local mode.");
   }
   const api = await ApiClient.create(opts.credentials);
-  logger.debug(`[codex] Starting with options: startedBy=${opts.startedBy || "terminal"}, startingMode=${opts.startingMode || "local"}`);
+  logger.debug(`[codex] Starting with options: startedBy=${opts.startedBy || "terminal"}, requestedStartingMode=${requestedStartingMode}, executionMode=acp-only`);
   const settings = await readSettings();
   const machineId = settings?.machineId;
   if (!machineId) {
@@ -1601,18 +1462,21 @@ async function runCodex(opts) {
       logger.debug("[START] Failed to report to daemon:", error);
     }
   }
-  const messageQueue = new MessageQueue2((mode) => hashObject({
-    permissionMode: mode.permissionMode,
-    model: mode.model
-  }));
-  let currentPermissionMode;
+  const messageQueue = new MessageQueue2(getCodexExecutionFingerprint);
+  let currentPermissionMode = initialPermissionMode;
   let currentModel;
   sessionClient.onUserMessage((message) => {
-    let messagePermissionMode = currentPermissionMode;
+    const previousPermissionMode = currentPermissionMode;
+    let messagePermissionMode = previousPermissionMode;
     if (message.meta?.permissionMode) {
       messagePermissionMode = message.meta.permissionMode;
-      currentPermissionMode = messagePermissionMode;
     }
+    const permissionResolution = resolveIncomingCodexPermissionMode({
+      messagePermissionMode,
+      currentPermissionMode: previousPermissionMode,
+      preserveCurrentOnDefault: preserveCurrentPermissionModeForRemoteDefault
+    });
+    currentPermissionMode = permissionResolution.nextCurrentPermissionMode;
     let messageModel = currentModel;
     if (message.meta?.hasOwnProperty("model")) {
       messageModel = message.meta.model || void 0;
@@ -1626,7 +1490,7 @@ async function runCodex(opts) {
       codexSession?.supersedePendingInteractions(INTERACTION_SUPERSEDED_ERROR);
     }
     messageQueue.push(message.content.text, {
-      permissionMode: messagePermissionMode || "default",
+      permissionMode: permissionResolution.resolvedPermissionMode,
       model: messageModel
     });
   });
@@ -1636,7 +1500,7 @@ async function runCodex(opts) {
     path: process.cwd(),
     logPath: logger.logFilePath,
     sessionId: null,
-    mode: opts.startingMode ?? "local",
+    mode: requestedStartingMode,
     messageQueue,
     codexArgs: opts.codexArgs,
     onModeChange: async (mode) => {
@@ -1647,7 +1511,7 @@ async function runCodex(opts) {
   try {
     const exitCode = await codexLoop({
       session: codexSession,
-      startingMode: opts.startingMode ?? "local"
+      startingMode: requestedStartingMode
     });
     sessionClient.sendSessionDeath();
     await sessionClient.flush();
@@ -1660,4 +1524,4 @@ async function runCodex(opts) {
   }
 }
 
-export { runCodex, shouldSupersedeCodexPendingInteractions, supportsAgentStateUpdateEvents, syncControlledByUserState };
+export { resolveIncomingCodexPermissionMode, resolveInitialCodexPermissionMode, resolveQueuedCodexPermissionMode, runCodex, shouldSupersedeCodexPendingInteractions, supportsAgentStateUpdateEvents, syncControlledByUserState };