happy-imou-cloud 2.0.1 → 2.0.3

package/dist/{runCodex-Dzy8anlX.cjs → runCodex-WRmgSK6L.cjs}

@@ -1,21 +1,19 @@
 'use strict';
 
 var node_crypto = require('node:crypto');
-var api = require('./api-B8v4tczT.cjs');
-var persistence = require('./persistence-C33AMdtv.cjs');
-var index = require('./index-BOqJ9hwi.cjs');
-var BaseReasoningProcessor = require('./BaseReasoningProcessor-01KqA3Kz.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-BkzQulD9.cjs');
-var future = require('./future-Dq4Ha1Dn.cjs');
-var node_child_process = require('node:child_process');
-var fs = require('node:fs');
-var os = require('node:os');
-var path = require('node:path');
+var api = require('./api-D9dIR956.cjs');
+var persistence = require('./persistence-PzKU0QCa.cjs');
+var index = require('./index-LYPXVO_L.cjs');
+var BaseReasoningProcessor = require('./BaseReasoningProcessor-_wxlqKB8.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-BDBPoQSA.cjs');
 var React = require('react');
 var ink = require('ink');
 require('axios');
 require('chalk');
 require('fs');
+require('node:fs');
+require('node:os');
+require('node:path');
 require('node:events');
 require('socket.io-client');
 require('zod');
@@ -33,6 +31,7 @@ require('qrcode-terminal');
 require('node:module');
 require('open');
 require('url');
+require('node:child_process');
 require('ps-list');
 require('cross-spawn');
 require('fastify');
@@ -130,7 +129,6 @@ class CodexSession {
   sessionId;
   mode;
   thinking = false;
-  localModePinned = false;
   keepAliveInterval;
   onModeChangeCallback;
   clientSwapCallbacks = [];
@@ -190,18 +188,6 @@ class CodexSession {
     this.client.keepAlive(this.thinking, mode);
     await this.onModeChangeCallback(mode);
   };
-  pinLocalMode = () => {
-    this.localModePinned = true;
-    api.logger.debug("[CodexSession] Local mode pinned");
-  };
-  clearLocalModePin = () => {
-    if (!this.localModePinned) {
-      return;
-    }
-    this.localModePinned = false;
-    api.logger.debug("[CodexSession] Local mode pin cleared");
-  };
-  isLocalModePinned = () => this.localModePinned;
   onSessionFound = (sessionId) => {
     if (this.sessionId === sessionId) {
       return;
@@ -219,262 +205,7 @@ class CodexSession {
   };
 }
 
-function getCodexSessionsRoot() {
-  const codexHomeDir = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
-  return path.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 = path.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") {
-      node_child_process.execFileSync("taskkill", ["/F", "/T", "/PID", pid.toString()], { stdio: "ignore" });
-      return;
-    }
-    process.kill(pid, "SIGTERM");
-  } catch (error) {
-    api.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();
-  api.logger.debug(`[CodexLocal] Spawning ${codexExecutable} with args: ${JSON.stringify(args)}`);
-  process.stdin.pause();
-  try {
-    await new Promise((resolve, reject) => {
-      const child = node_child_process.spawn(codexExecutable, args, {
-        cwd: opts.path,
-        env: process.env,
-        stdio: "inherit",
-        signal: opts.abort,
-        shell: shouldUseShellForCodex(codexExecutable)
-      });
-      const abortChild = () => {
-        if (child.exitCode === null) {
-          api.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;
-          api.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.Future();
-  try {
-    async function abort() {
-      if (!processAbortController.signal.aborted) {
-        processAbortController.abort();
-      }
-      await exitFuture.promise;
-    }
-    async function doSwitch() {
-      api.logger.debug("[codex-local]: switching to remote mode");
-      if (!exitReason) {
-        exitReason = { type: "switch" };
-      }
-      await abort();
-    }
-    async function doAbort() {
-      api.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()) {
-        api.logger.debug("[codex-local]: message arrived while local mode is pinned; staying local");
-        return;
-      }
-      void doSwitch();
-    });
-    if (session.queue.size() > 0) {
-      if (session.isLocalModePinned()) {
-        api.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) {
-        api.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] = React.useState([]);
   const [confirmationMode, setConfirmationMode] = React.useState(null);
   const [actionInProgress, setActionInProgress] = React.useState(null);
@@ -523,21 +254,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":
@@ -589,13 +309,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(ink.Box, { flexDirection: "column", alignItems: "center" }, actionInProgress === "exiting" ? /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "Exiting agent...") : actionInProgress === "switching" ? /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "Switching to local mode...") : confirmationMode === "exit" ? /* @__PURE__ */ React.createElement(ink.Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit the agent") : confirmationMode === "switch" ? /* @__PURE__ */ React.createElement(ink.Text, { color: "yellow", bold: true }, "\u23F8\uFE0F  Press space again to switch to local mode") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(ink.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(ink.Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
+    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", alignItems: "center" }, actionInProgress === "exiting" ? /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "Exiting agent...") : confirmationMode === "exit" ? /* @__PURE__ */ React.createElement(ink.Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit the agent") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(ink.Text, { color: "green", bold: true }, "\u{1F916} Codex Agent Running \u2022 Ctrl-C to exit")), process.env.DEBUG && logPath && /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
   ));
 };
 
@@ -847,6 +567,152 @@ class ReasoningProcessor extends BaseReasoningProcessor.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 = [];
+    api.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)) {
+      api.logger.debug(`[CodexConversationHistory] Skipping duplicate ${role} message (${trimmedContent.length} chars)`);
+      return;
+    }
+    this.messages.push({
+      role,
+      content: trimmedContent,
+      timestamp: Date.now()
+    });
+    this.trimHistory();
+    api.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 registerKillSessionHandler.hashObject(resolveCodexAcpExecutionMode(mode));
+}
+
 function createAbortError() {
   const error = new Error("Operation aborted");
   error.name = "AbortError";
@@ -899,6 +765,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;
@@ -925,58 +794,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 registerKillSessionHandler.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;
@@ -989,8 +810,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);
   });
@@ -1043,10 +866,26 @@ async function codexRemoteLauncher(session) {
       api.logger.debug("[Codex] Error disposing ACP backend:", error);
     }
   };
+  const emitStatusMessage = (message) => {
+    messageBuffer.addMessage(message, "status");
+    session.runtimeSession.sendSessionEvent({ type: "message", message });
+  };
+  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);
+      api.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,
@@ -1261,11 +1100,9 @@ async function codexRemoteLauncher(session) {
     return result.backend;
   };
   const handleSwitchToLocal = async () => {
-    api.logger.debug("[Codex] Switching to local from RPC");
-    session.pinLocalMode();
-    exitReason = "switch";
-    shouldExit = true;
-    await handleAbort();
+    const message = getCodexLegacySwitchIgnoredMessage();
+    api.logger.debug("[Codex] Ignoring legacy switch request because Codex is ACP-only");
+    emitStatusMessage(message);
   };
   session.setPendingInteractionSuperseder((reason = BaseReasoningProcessor.INTERACTION_SUPERSEDED_ERROR) => {
     return handleIncomingCodexMessageDuringRemoteTurn({
@@ -1326,17 +1163,9 @@ async function codexRemoteLauncher(session) {
     inkInstance = ink.render(React.createElement(CodexDisplay, {
       messageBuffer,
       logPath: process.env.DEBUG ? session.logPath : void 0,
-      title: "Remote Mode - Codex Messages",
+      title: "Codex Agent Messages",
       onExit: async () => {
-        api.logger.debug("[Codex] Switching to exit from local keyboard");
-        exitReason = "exit";
-        shouldExit = true;
-        await handleAbort();
-      },
-      onSwitchToLocal: async () => {
-        api.logger.debug("[Codex] Switching to local from local keyboard");
-        session.pinLocalMode();
-        exitReason = "switch";
+        api.logger.debug("[Codex] Exiting Codex ACP session from keyboard");
         shouldExit = true;
         await handleAbort();
       }
@@ -1376,8 +1205,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;
@@ -1404,27 +1232,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;
+          api.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) {
         api.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: node_crypto.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 });
+          emitStatusMessage(errorMessage);
+          if (conversationHistory.hasHistory()) {
+            shouldInjectHistoryOnNextSession = true;
+          }
           await disposeBackend();
           session.clearSessionId();
         }
@@ -1478,33 +1312,16 @@ async function codexRemoteLauncher(session) {
     }
     messageBuffer.clear();
   }
-  api.logger.debug(`[Codex] ACP remote launcher returning: ${exitReason || "exit"}`);
-  return exitReason || "exit";
+  api.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) {
-    api.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);
+  api.logger.debug(`[codex-loop] Starting ACP-only Codex launcher with display mode: ${displayMode}`);
+  await codexRemoteLauncher(opts.session);
+  return 0;
 }
 
 function supportsAgentStateUpdateEvents(sessionClient) {
@@ -1545,16 +1362,17 @@ async function syncControlledByUserState(sessionClient, controlledByUser) {
   });
 }
 function shouldSupersedeCodexPendingInteractions(opts) {
-  return (opts.currentMode ?? opts.startingMode) === "remote";
+  return true;
 }
 async function runCodex(opts) {
   const sessionTag = node_crypto.randomUUID();
   api.connectionState.setBackend("Codex");
-  if (opts.startedBy === "daemon" && opts.startingMode === "local") {
+  const requestedStartingMode = opts.startingMode ?? (opts.startedBy === "daemon" ? "remote" : "local");
+  if (opts.startedBy === "daemon" && requestedStartingMode === "local") {
     throw new Error("Daemon-spawned Codex sessions cannot use local mode.");
   }
   const api$1 = await api.ApiClient.create(opts.credentials);
-  api.logger.debug(`[codex] Starting with options: startedBy=${opts.startedBy || "terminal"}, startingMode=${opts.startingMode || "local"}`);
+  api.logger.debug(`[codex] Starting with options: startedBy=${opts.startedBy || "terminal"}, requestedStartingMode=${requestedStartingMode}, executionMode=acp-only`);
   const settings = await persistence.readSettings();
   const machineId = settings?.machineId;
   if (!machineId) {
@@ -1603,10 +1421,7 @@ async function runCodex(opts) {
       api.logger.debug("[START] Failed to report to daemon:", error);
     }
   }
-  const messageQueue = new registerKillSessionHandler.MessageQueue2((mode) => registerKillSessionHandler.hashObject({
-    permissionMode: mode.permissionMode,
-    model: mode.model
-  }));
+  const messageQueue = new registerKillSessionHandler.MessageQueue2(getCodexExecutionFingerprint);
   let currentPermissionMode;
   let currentModel;
   sessionClient.onUserMessage((message) => {
@@ -1638,7 +1453,7 @@ async function runCodex(opts) {
     path: process.cwd(),
     logPath: api.logger.logFilePath,
     sessionId: null,
-    mode: opts.startingMode ?? "local",
+    mode: requestedStartingMode,
     messageQueue,
     codexArgs: opts.codexArgs,
     onModeChange: async (mode) => {
@@ -1649,7 +1464,7 @@ async function runCodex(opts) {
   try {
     const exitCode = await codexLoop({
       session: codexSession,
-      startingMode: opts.startingMode ?? "local"
+      startingMode: requestedStartingMode
     });
     sessionClient.sendSessionDeath();
     await sessionClient.flush();