happy-imou-cloud 2.1.49 → 2.1.51

package/dist/{runCodex-jUU6U2tZ.cjs → runCodex-DTCcGRue.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
-var persistence = require('./api-D7nAeZi7.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-CfCya6si.cjs');
-var index = require('./index-xa1kwZoj.cjs');
+var persistence = require('./types-CttABk32.cjs');
+var sessionControl = require('./sessionControl-flKnQrx0.cjs');
+var index = require('./index-B_JYgMUS.cjs');
 require('cross-spawn');
 require('@agentclientprotocol/sdk');
 var node_crypto = require('node:crypto');
@@ -26,12 +26,19 @@ require('tweetnacl');
 require('open');
 var React = require('react');
 var ink = require('ink');
-var ProviderSelectionHandler = require('./ProviderSelectionHandler-BJJc7qOR.cjs');
-var BaseReasoningProcessor = require('./BaseReasoningProcessor-Dn9NcoHz.cjs');
-require('zod');
+var ProviderSelectionHandler = require('./ProviderSelectionHandler-C7GE5QjX.cjs');
 require('socket.io-client');
 require('expo-server-sdk');
-require('./types-DVk3crez.cjs');
+var ConversationHistory = require('./ConversationHistory-Bl2doTA-.cjs');
+var RuntimeShell = require('./RuntimeShell-D_Te12wq.cjs');
+var AcpBackend = require('./AcpBackend-XPiTd6ph.cjs');
+var resolveCommand = require('./resolveCommand-DYMd9PNC.cjs');
+var codex = require('./codex-Fv2eali8.cjs');
+var BaseReasoningProcessor = require('./BaseReasoningProcessor-BD9tiwep.cjs');
+var future = require('./future-Dq4Ha1Dn.cjs');
+var bootstrapManagedProviderSession = require('./bootstrapManagedProviderSession-Bln-TwyB.cjs');
+var installFatalProcessHandlers = require('./installFatalProcessHandlers-CyURn5Bp.cjs');
+require('zod');
 require('qrcode-terminal');
 require('node:module');
 require('url');
@@ -240,12 +247,19 @@ class CodexSession {
     this.sessionId = sessionId;
     this.client.updateMetadata((metadata) => ({
       ...metadata,
-      codexSessionId: sessionId
+      codexSessionId: sessionId,
+      codexSessionCwd: this.path
     }));
     persistence.logger.debug(`[CodexSession] Session ID ${sessionId} added to metadata`);
   };
   clearSessionId = () => {
     this.sessionId = null;
+    this.client.updateMetadata((metadata) => {
+      const nextMetadata = { ...metadata };
+      delete nextMetadata.codexSessionId;
+      delete nextMetadata.codexSessionCwd;
+      return nextMetadata;
+    });
     persistence.logger.debug("[CodexSession] Session ID cleared");
   };
   handleUserObserverEphemeral = (event) => {
@@ -360,7 +374,7 @@ const CodexDisplay = ({ messageBuffer, logPath, onExit, onSwitchToLocal, title }
     }
   };
   const formatMessage = (msg) => {
-    const lines = index.formatDisplayMessage(msg.content).split("\n");
+    const lines = RuntimeShell.formatDisplayMessage(msg.content).split("\n");
     const maxLineLength = terminalWidth - 10;
     return lines.map((line) => {
       if (line.length <= maxLineLength) return line;
@@ -402,7 +416,7 @@ const CodexDisplay = ({ messageBuffer, logPath, onExit, onSwitchToLocal, title }
   ));
 };
 
-class CodexPermissionHandler extends registerKillSessionHandler.BasePermissionHandler {
+class CodexPermissionHandler extends sessionControl.BasePermissionHandler {
   constructor(session) {
     super(session);
   }
@@ -517,6 +531,113 @@ function getCodexExecutionFingerprint(mode) {
   });
 }
 
+function getCodexSessionsRoot(options = {}) {
+  const codexHomeDir = options.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 normalizePathForSessionMatch(path$1) {
+  const normalizedPath = path.normalize(path$1).replace(/[\\/]+/g, "/").replace(/\/+$/, "");
+  return process.platform === "win32" ? normalizedPath.toLowerCase() : normalizedPath;
+}
+function extractCodexSessionCwdFromFile(filePath) {
+  let contents;
+  try {
+    contents = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  for (const line of contents.split(/\r?\n/)) {
+    if (!line.trim()) {
+      continue;
+    }
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (record.type !== "session_meta" || typeof record.payload !== "object" || record.payload === null) {
+      continue;
+    }
+    const cwd = record.payload.cwd;
+    return typeof cwd === "string" && cwd.trim().length > 0 ? cwd : null;
+  }
+  return null;
+}
+function codexSessionFileMatchesCwd(filePath, cwd) {
+  const expectedCwd = cwd?.trim();
+  if (!expectedCwd) {
+    return true;
+  }
+  const actualCwd = extractCodexSessionCwdFromFile(filePath);
+  if (!actualCwd) {
+    return false;
+  }
+  return normalizePathForSessionMatch(actualCwd) === normalizePathForSessionMatch(expectedCwd);
+}
+function findCodexResumeFile(sessionId, options = {}) {
+  if (!sessionId) return null;
+  try {
+    const candidates = collectFilesRecursive(getCodexSessionsRoot(options)).filter((full) => full.endsWith(`-${sessionId}.jsonl`)).filter((full) => {
+      try {
+        return fs.statSync(full).isFile();
+      } catch {
+        return false;
+      }
+    }).filter((full) => codexSessionFileMatchesCwd(full, options.cwd)).sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+    return candidates[0] || null;
+  } catch {
+    return null;
+  }
+}
+function isCodexResumeSessionValidForCwd(sessionId, cwd, options = {}) {
+  if (!sessionId?.trim()) {
+    return false;
+  }
+  return findCodexResumeFile(sessionId, { ...options, cwd }) !== null;
+}
+function findLatestCodexSessionIdSince(startTimeMs, options = {}) {
+  try {
+    const candidates = collectFilesRecursive(getCodexSessionsRoot(options)).filter((full) => full.endsWith(".jsonl")).filter((full) => {
+      try {
+        return fs.statSync(full).mtimeMs >= startTimeMs;
+      } catch {
+        return false;
+      }
+    }).filter((full) => codexSessionFileMatchesCwd(full, options.cwd)).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 delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -622,8 +743,8 @@ function appendCodexAuthScopeHint(message, searchableLower) {
 }
 function extractLocalProcessExit(error) {
   const record = typeof error === "object" && error !== null ? error : null;
-  const text = index.formatDisplayMessage(error).trim();
-  const stderrTextFromRecord = record ? index.formatDisplayMessage(record.stderr).trim() : "";
+  const text = RuntimeShell.formatDisplayMessage(error).trim();
+  const stderrTextFromRecord = record ? RuntimeShell.formatDisplayMessage(record.stderr).trim() : "";
   const stderrFromTextMatch = text.match(/Recent stderr:\s*([\s\S]+)$/i);
   const stderrText = stderrTextFromRecord || stderrFromTextMatch?.[1]?.trim() || "";
   let exitCode = typeof record?.exitCode === "number" && Number.isFinite(record.exitCode) ? record.exitCode : null;
@@ -685,19 +806,30 @@ function formatCodexLocalProcessExit(error) {
 function shouldInjectLargeOutputRecoveryHint(error) {
   const record = typeof error === "object" && error !== null ? error : null;
   const searchableText = [
-    index.formatDisplayMessage(error).trim(),
-    record ? index.formatDisplayMessage(record.stderr).trim() : "",
-    record ? index.formatDisplayMessage(record.detail).trim() : "",
-    record ? index.formatDisplayMessage(record.data).trim() : ""
+    RuntimeShell.formatDisplayMessage(error).trim(),
+    record ? RuntimeShell.formatDisplayMessage(record.stderr).trim() : "",
+    record ? RuntimeShell.formatDisplayMessage(record.detail).trim() : "",
+    record ? RuntimeShell.formatDisplayMessage(record.data).trim() : ""
   ].filter(Boolean).join("\n").toLowerCase();
   return searchableText.includes("memory allocation of") || searchableText.includes("out of memory") || searchableText.includes("oversized command output");
 }
+function isCodexUnknownResumeSessionError(error) {
+  const record = typeof error === "object" && error !== null ? error : null;
+  const searchableText = [
+    RuntimeShell.formatDisplayMessage(error).trim(),
+    record ? RuntimeShell.formatDisplayMessage(record.message).trim() : "",
+    record ? RuntimeShell.formatDisplayMessage(record.stderr).trim() : "",
+    record ? RuntimeShell.formatDisplayMessage(record.detail).trim() : "",
+    record ? RuntimeShell.formatDisplayMessage(record.data).trim() : ""
+  ].filter(Boolean).join("\n");
+  return /unknown (session|thread)|session .* not found|thread .* not found|conversation .* not found|missing rollout path for thread|state db missing rollout path|no rollout found for thread id|resource not found/i.test(searchableText);
+}
 function normalizeCodexBackendError(error) {
   const record = typeof error === "object" && error !== null ? error : null;
-  const text = index.formatDisplayMessage(error).trim();
-  const stderrText = record ? index.formatDisplayMessage(record.stderr).trim() : "";
-  const detailText = record ? index.formatDisplayMessage(record.detail).trim() : "";
-  const dataText = record ? index.formatDisplayMessage(record.data).trim() : "";
+  const text = RuntimeShell.formatDisplayMessage(error).trim();
+  const stderrText = record ? RuntimeShell.formatDisplayMessage(record.stderr).trim() : "";
+  const detailText = record ? RuntimeShell.formatDisplayMessage(record.detail).trim() : "";
+  const dataText = record ? RuntimeShell.formatDisplayMessage(record.data).trim() : "";
   const searchableText = [text, stderrText, detailText, dataText].filter(Boolean).join("\n");
   const prefix = buildErrorPrefix(record);
   const searchableLower = searchableText.toLowerCase();
@@ -781,12 +913,12 @@ function shouldEmitCodexReadyAfterWait(opts) {
 function registerCodexRemoteRpcHandlers(clientSession, handlers) {
   clientSession.rpcHandlerManager.registerHandler("abort", handlers.handleAbort);
   clientSession.rpcHandlerManager.registerHandler("switch", handlers.handleSwitchToLocal);
-  registerKillSessionHandler.registerKillSessionHandler(clientSession.rpcHandlerManager, handlers.handleKillSession);
+  sessionControl.registerKillSessionHandler(clientSession.rpcHandlerManager, handlers.handleKillSession);
 }
 async function codexRemoteLauncher(session) {
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
-  const messageBuffer = new registerKillSessionHandler.MessageBuffer({ enabled: hasTTY });
-  const renderSessionTranscript = registerKillSessionHandler.createSessionTranscriptInkRenderer({ messageBuffer });
+  const messageBuffer = new ConversationHistory.MessageBuffer({ enabled: hasTTY });
+  const renderSessionTranscript = ConversationHistory.createSessionTranscriptInkRenderer({ messageBuffer });
   let inkInstance = null;
   let shouldExit = false;
   let shouldSwitchToLocal = false;
@@ -812,7 +944,7 @@ async function codexRemoteLauncher(session) {
   const assistantMessageStream = new persistence.AssistantMessageStream();
   const permissionHandler = new CodexPermissionHandler(session.client);
   const selectionHandler = new CodexSelectionHandler(session.client);
-  const conversationHistory = new registerKillSessionHandler.ConversationHistory({ maxMessages: 20, maxCharacters: 5e4 });
+  const conversationHistory = new ConversationHistory.ConversationHistory({ maxMessages: 20, maxCharacters: 5e4 });
   const reasoningProcessor = new ReasoningProcessor((message) => {
     session.runtimeSession.sendCodexMessage(message);
   });
@@ -827,7 +959,7 @@ async function codexRemoteLauncher(session) {
       return;
     }
     try {
-      const notification = registerKillSessionHandler.buildReadyPushNotification({
+      const notification = ConversationHistory.buildReadyPushNotification({
         providerLabel: "Codex",
         metadata: session.runtimeSession.getMetadataSnapshot?.() ?? null,
         sessionId: session.runtimeSession.sessionId
@@ -997,7 +1129,7 @@ async function codexRemoteLauncher(session) {
   };
   const setupRuntimeMessageHandler = (activeRuntimeHandle) => {
     const forwardAgentMessage = (agentMessage) => {
-      registerKillSessionHandler.forwardAgentMessageToProviderSession(agentMessage, {
+      sessionControl.forwardAgentMessageToProviderSession(agentMessage, {
         provider: "codex",
         send: (body) => session.runtimeSession.sendCodexMessage(body),
         toolResultType: "tool-call-result"
@@ -1063,7 +1195,7 @@ async function codexRemoteLauncher(session) {
         }
         case "tool-call": {
           commitActiveAssistantMessageStream();
-          const toolArgs = hasRenderableToolPayload(msg.args) ? index.truncateDisplayMessage(msg.args, 100) : "";
+          const toolArgs = hasRenderableToolPayload(msg.args) ? RuntimeShell.truncateDisplayMessage(msg.args, 100) : "";
           messageBuffer.addMessage(
             `Executing: ${msg.toolName}${toolArgs ? ` ${toolArgs}` : ""}`,
             "tool"
@@ -1072,8 +1204,8 @@ async function codexRemoteLauncher(session) {
           return;
         }
         case "tool-result": {
-          const isError = registerKillSessionHandler.inferToolResultError(msg.result);
-          const resultText = hasRenderableToolPayload(msg.result) ? index.truncateDisplayMessage(msg.result, 200) : "";
+          const isError = sessionControl.inferToolResultError(msg.result);
+          const resultText = hasRenderableToolPayload(msg.result) ? RuntimeShell.truncateDisplayMessage(msg.result, 200) : "";
           if (isError || resultText) {
             messageBuffer.addMessage(
               `${isError ? "Error:" : "Result:"} ${resultText || "Unknown error"}`.trim(),
@@ -1089,12 +1221,12 @@ async function codexRemoteLauncher(session) {
           return;
         }
         case "terminal-output": {
-          const terminalOutput = registerKillSessionHandler.renderTerminalOutputPreview(msg.data);
+          const terminalOutput = sessionControl.renderTerminalOutputPreview(msg.data);
           if (!terminalOutput) {
             return;
           }
           messageBuffer.addMessage(terminalOutput, "result");
-          const forwardedOutput = registerKillSessionHandler.prepareTerminalOutputForForwarding(msg.data);
+          const forwardedOutput = sessionControl.prepareTerminalOutputForForwarding(msg.data);
           if (forwardedOutput) {
             forwardAgentMessage({
               ...msg,
@@ -1105,8 +1237,8 @@ async function codexRemoteLauncher(session) {
         }
         case "permission-request": {
           try {
-            const permissionRequest = registerKillSessionHandler.extractPermissionRequestPushContext(msg);
-            const notification = registerKillSessionHandler.buildPermissionPushNotification({
+            const permissionRequest = ConversationHistory.extractPermissionRequestPushContext(msg);
+            const notification = ConversationHistory.buildPermissionPushNotification({
               providerLabel: "Codex",
               metadata: session.runtimeSession.getMetadataSnapshot?.() ?? null,
               sessionId: session.runtimeSession.sessionId,
@@ -1139,9 +1271,9 @@ async function codexRemoteLauncher(session) {
         }
         case "patch-apply-end": {
           if (msg.success) {
-            messageBuffer.addMessage(index.truncateDisplayMessage(msg.stdout || "Files modified successfully", 200), "result");
+            messageBuffer.addMessage(RuntimeShell.truncateDisplayMessage(msg.stdout || "Files modified successfully", 200), "result");
           } else {
-            messageBuffer.addMessage(`Error: ${index.truncateDisplayMessage(msg.stderr || "Failed to modify files", 200)}`, "result");
+            messageBuffer.addMessage(`Error: ${RuntimeShell.truncateDisplayMessage(msg.stderr || "Failed to modify files", 200)}`, "result");
           }
           forwardAgentMessage(msg);
           return;
@@ -1175,7 +1307,12 @@ async function codexRemoteLauncher(session) {
   };
   const createRuntimeHandle = async (mode) => {
     const executionMode = resolveCodexAcpExecutionMode(mode);
-    const validation = index.validateCodexAcpSpawn({
+    const resumeSessionId = session.sessionId && isCodexResumeSessionValidForCwd(session.sessionId, session.path) ? session.sessionId : null;
+    if (session.sessionId && !resumeSessionId) {
+      persistence.logger.debug(`[Codex] Refusing to resume Codex session ${session.sessionId} because its local session file does not match cwd ${session.path}`);
+      session.clearSessionId();
+    }
+    const validation = resolveCommand.validateCodexAcpSpawn({
       command: process.env.HAPPY_CODEX_ACP_COMMAND,
       model: executionMode.model,
       sandbox: executionMode.sandbox,
@@ -1185,17 +1322,17 @@ async function codexRemoteLauncher(session) {
     if (!validation.ok) {
       throw new Error(validation.errorMessage);
     }
-    const { session: nextRuntimeHandle } = await registerKillSessionHandler.launchRuntimeHandleWithFactoryResult({
+    const { session: nextRuntimeHandle } = await ConversationHistory.launchRuntimeHandleWithFactoryResult({
       provider: "codex",
       cwd: session.path,
-      createBackendResult: (opts) => index.createCodexBackend({
+      createBackendResult: (opts) => codex.createCodexBackend({
         ...opts,
         baseArgs: session.codexArgs,
         model: executionMode.model,
         sandbox: executionMode.sandbox,
         approvalPolicy: executionMode.approvalPolicy,
         permissionHandler,
-        resumeSessionId: session.sessionId,
+        resumeSessionId,
         selectionHandler: {
           handleSelection: (request) => selectionHandler.requestSelection(request)
         }
@@ -1203,7 +1340,7 @@ async function codexRemoteLauncher(session) {
     });
     runtimeHandle = nextRuntimeHandle;
     setupRuntimeMessageHandler(nextRuntimeHandle);
-    const providerSessionId = nextRuntimeHandle.backend instanceof index.AcpBackend ? nextRuntimeHandle.backend.getProviderSessionId() : null;
+    const providerSessionId = nextRuntimeHandle.backend instanceof AcpBackend.AcpBackend ? nextRuntimeHandle.backend.getProviderSessionId() : null;
     session.onSessionFound(providerSessionId ?? nextRuntimeHandle.sessionId);
     return nextRuntimeHandle;
   };
@@ -1346,12 +1483,31 @@ async function codexRemoteLauncher(session) {
       const turnSignal = abortController.signal;
       let sentTurnResultPush = false;
       let turnStatus = "task_complete";
+      let retryingWithFreshSession = false;
       currentHappyOrgTurn = message.mode.happyOrg ?? null;
       try {
         turnInFlight = true;
         shouldCommitAccumulatedResponse = false;
         const isNewRuntimeSession = runtimeHandle === null;
-        const activeRuntimeHandle = runtimeHandle ?? await createRuntimeHandle(message.mode);
+        const attemptedResumeSessionId = isNewRuntimeSession ? session.sessionId : null;
+        let activeRuntimeHandle;
+        try {
+          activeRuntimeHandle = runtimeHandle ?? await createRuntimeHandle(message.mode);
+        } catch (error) {
+          if (!isNewRuntimeSession || !attemptedResumeSessionId || !isCodexUnknownResumeSessionError(error) || turnSignal.aborted) {
+            throw error;
+          }
+          persistence.logger.debug(`[Codex] Resume session ${attemptedResumeSessionId} failed during ACP startup; retrying with a fresh session`, error);
+          queueHistoryInjectionForRestart("Codex resume session is unavailable. Retrying with a fresh Codex session...");
+          session.clearSessionId();
+          currentModeHash = null;
+          permissionHandler.reset();
+          selectionHandler.reset();
+          resetTurnState();
+          pending = message;
+          retryingWithFreshSession = true;
+          continue;
+        }
         if (!activeRuntimeHandle) {
           throw new Error("Failed to create Codex ACP backend");
         }
@@ -1375,11 +1531,28 @@ async function codexRemoteLauncher(session) {
 
 ${message.message}` : message.message;
         if (message.mode.happyOrg) {
-          promptToSend = registerKillSessionHandler.buildHappyOrgTurnPrompt(promptToSend, message.mode.happyOrg);
+          promptToSend = sessionControl.buildHappyOrgTurnPrompt(promptToSend, message.mode.happyOrg);
         }
         conversationHistory.addUserMessage(message.message);
-        await activeRuntimeHandle.sendPrompt(promptToSend);
-        await registerKillSessionHandler.waitForResponseCompleteWithAbort(activeRuntimeHandle.backend, turnSignal);
+        try {
+          await activeRuntimeHandle.sendPrompt(promptToSend);
+          await sessionControl.waitForResponseCompleteWithAbort(activeRuntimeHandle.backend, turnSignal);
+        } catch (error) {
+          if (!isNewRuntimeSession || !attemptedResumeSessionId || !isCodexUnknownResumeSessionError(error) || turnSignal.aborted) {
+            throw error;
+          }
+          persistence.logger.debug(`[Codex] Resume session ${attemptedResumeSessionId} is unavailable; retrying with a fresh ACP session`, error);
+          queueHistoryInjectionForRestart("Codex resume session is unavailable. Retrying with a fresh Codex session...");
+          await disposeRuntimeHandle();
+          session.clearSessionId();
+          currentModeHash = null;
+          permissionHandler.reset();
+          selectionHandler.reset();
+          resetTurnState();
+          pending = message;
+          retryingWithFreshSession = true;
+          continue;
+        }
         reasoningProcessor.completeCurrent();
         shouldCommitAccumulatedResponse = true;
         shouldInjectHistoryOnNextSession = false;
@@ -1409,7 +1582,10 @@ ${message.message}` : message.message;
         }
       } finally {
         turnInFlight = false;
-        const finalizedTurn = await registerKillSessionHandler.finalizeHappyOrgTurnWithBusinessAck({
+        if (retryingWithFreshSession) {
+          continue;
+        }
+        const finalizedTurn = await sessionControl.finalizeHappyOrgTurnWithBusinessAck({
           metadata: session.runtimeSession.getMetadataSnapshot?.() ?? null,
           queuedTurn: message.mode.happyOrg,
           responseText: accumulatedResponse,
@@ -1435,7 +1611,7 @@ ${message.message}` : message.message;
           emitFinalAssistantMessage(finalizedTurn.cleanedText);
           if (!shouldExit && !shouldSwitchToLocal) {
             try {
-              const notification = registerKillSessionHandler.buildTurnResultPushNotification({
+              const notification = ConversationHistory.buildTurnResultPushNotification({
                 providerLabel: "Codex",
                 metadata: finalizedTurn.nextMetadata ?? session.runtimeSession.getMetadataSnapshot?.() ?? null,
                 sessionId: session.runtimeSession.sessionId,
@@ -1504,52 +1680,6 @@ ${message.message}` : message.message;
   return shouldSwitchToLocal ? "switch" : "exit";
 }
 
-function getCodexSessionsRoot(options = {}) {
-  const codexHomeDir = options.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, options = {}) {
-  try {
-    const candidates = collectFilesRecursive(getCodexSessionsRoot(options)).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;
-}
-
 const MANAGED_CODEX_HOME_PREFIX = "happy-codex-home-";
 function isManagedCodexHomePath(value) {
   const trimmed = value?.trim();
@@ -1616,12 +1746,17 @@ function terminateCodexLocalChild(pid) {
 }
 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 = index.resolveCodexExecutable();
   const codexEnv = buildCodexLocalEnv(process.env);
   const codexHomeDir = resolveCodexLocalHomeDir(codexEnv);
+  const resumeSessionId = opts.sessionId && isCodexResumeSessionValidForCwd(opts.sessionId, opts.path, { codexHomeDir }) ? opts.sessionId : null;
+  if (opts.sessionId && !resumeSessionId) {
+    persistence.logger.debug(`[CodexLocal] Refusing to resume Codex session ${opts.sessionId} because its local session file does not match cwd ${opts.path}`);
+    opts.onResumeSessionInvalid?.(opts.sessionId);
+  }
+  const args = resumeSessionId ? ["resume", resumeSessionId, ...baseArgs] : baseArgs;
+  const startTime = Date.now();
+  let detectedSessionId = resumeSessionId;
+  const codexExecutable = codex.resolveCodexExecutable();
   persistence.logger.debug(`[CodexLocal] Spawning ${codexExecutable} with args: ${JSON.stringify(args)}`);
   releaseTerminalInputForChild();
   clearTerminalForChild();
@@ -1631,7 +1766,7 @@ async function codexLocal(opts) {
         cwd: opts.path,
         env: codexEnv,
         stdio: "inherit",
-        shell: index.shouldUseShellForCodex(codexExecutable)
+        shell: codex.shouldUseShellForCodex(codexExecutable)
       });
       const abortChild = () => {
         if (child.exitCode === null) {
@@ -1647,7 +1782,7 @@ async function codexLocal(opts) {
         if (detectedSessionId) {
           return;
         }
-        const nextSessionId = findLatestCodexSessionIdSince(startTime, { codexHomeDir });
+        const nextSessionId = findLatestCodexSessionIdSince(startTime, { codexHomeDir, cwd: opts.path });
         if (nextSessionId) {
           detectedSessionId = nextSessionId;
           persistence.logger.debug(`[CodexLocal] Detected session ID: ${nextSessionId}`);
@@ -1705,7 +1840,7 @@ async function codexLocalLauncher(session) {
   let switchWithoutSessionTimer = null;
   let reportedSessionId = session.sessionId;
   const processAbortController = new AbortController();
-  const exitFuture = new index.Future();
+  const exitFuture = new future.Future();
   try {
     let clearSwitchWithoutSessionTimer2 = function() {
       if (switchWithoutSessionTimer) {
@@ -1790,6 +1925,7 @@ async function codexLocalLauncher(session) {
           abort: processAbortController.signal,
           codexArgs: session.codexArgs,
           onSessionFound: recordSessionFound,
+          onResumeSessionInvalid: session.clearSessionId,
           onThinkingChange: session.onThinkingChange
         });
         if (sessionId) {
@@ -1863,58 +1999,6 @@ async function codexLoop(opts) {
   });
 }
 
-function normalizeFatalProcessError(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-  const message = typeof error === "string" ? error : (() => {
-    try {
-      const serialized = JSON.stringify(error);
-      return serialized && serialized !== "{}" ? serialized : String(error);
-    } catch {
-      return String(error);
-    }
-  })();
-  return new Error(message || "Unknown fatal process error");
-}
-function installFatalProcessHandlers(options) {
-  const target = options.target ?? process;
-  const exit = options.exit ?? process.exit;
-  let shuttingDown = false;
-  let disposed = false;
-  const handleFatalEvent = async (event, reason) => {
-    const error = normalizeFatalProcessError(reason);
-    persistence.logger.debug(`[${options.label}] Fatal ${event}`, error);
-    if (shuttingDown) {
-      persistence.logger.debug(`[${options.label}] Ignoring duplicate fatal ${event} while shutdown is already in progress`);
-      return;
-    }
-    shuttingDown = true;
-    try {
-      await options.cleanup({ event, error });
-    } catch (cleanupError) {
-      persistence.logger.debug(`[${options.label}] Fatal cleanup failed`, cleanupError);
-    }
-    exit(1);
-  };
-  const onUncaughtException = (error) => {
-    void handleFatalEvent("uncaughtException", error);
-  };
-  const onUnhandledRejection = (reason) => {
-    void handleFatalEvent("unhandledRejection", reason);
-  };
-  target.on("uncaughtException", onUncaughtException);
-  target.on("unhandledRejection", onUnhandledRejection);
-  return () => {
-    if (disposed) {
-      return;
-    }
-    disposed = true;
-    target.off("uncaughtException", onUncaughtException);
-    target.off("unhandledRejection", onUnhandledRejection);
-  };
-}
-
 function normalizeResumeSessionId(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -1959,6 +2043,17 @@ function normalizeCodexArgsForHappy(options) {
   };
 }
 
+function normalizePathForCodexResumeIdentity(path) {
+  const normalized = path.trim().replace(/[\\/]+/g, "/").replace(/\/+$/, "");
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function codexResumeCwdMatches(expected, actual) {
+  const normalizedExpected = expected?.trim();
+  if (!normalizedExpected) {
+    return true;
+  }
+  return normalizePathForCodexResumeIdentity(normalizedExpected) === normalizePathForCodexResumeIdentity(actual);
+}
 function resolveInitialCodexPermissionMode(opts) {
   if (opts.permissionMode) {
     return opts.permissionMode;
@@ -2027,12 +2122,12 @@ async function runCodex(opts) {
   }
   let machineId;
   try {
-    machineId = await registerKillSessionHandler.ensureManagedProviderMachine({
+    machineId = await sessionControl.ensureManagedProviderMachine({
       api,
       missingMachineIdMessage: "[START] No machine ID found in settings."
     });
   } catch (error) {
-    if (error instanceof registerKillSessionHandler.MissingMachineIdError) {
+    if (error instanceof sessionControl.MissingMachineIdError) {
       console.error(error.message);
       process.exit(1);
     }
@@ -2040,7 +2135,7 @@ async function runCodex(opts) {
   }
   let sessionClient;
   let codexSession = null;
-  const { metadata, session: initialSession, reconnectionHandle, happyOrgStartupBinding } = await BaseReasoningProcessor.bootstrapManagedProviderSession({
+  const { metadata, session: initialSession, reconnectionHandle, happyOrgStartupBinding } = await bootstrapManagedProviderSession.bootstrapManagedProviderSession({
     api,
     sessionTag,
     flavor: "codex",
@@ -2051,18 +2146,32 @@ async function runCodex(opts) {
     onSessionSwap: (newSession) => {
       sessionClient = newSession;
       codexSession?.updateClient(newSession);
-      void registerKillSessionHandler.syncControlledByUserState(
+      void sessionControl.syncControlledByUserState(
         newSession,
         (codexSession?.mode ?? requestedStartingMode) === "local"
       );
     }
   });
   sessionClient = initialSession;
-  const messageQueue = new registerKillSessionHandler.MessageQueue2(getCodexExecutionFingerprint);
+  const metadataCodexSessionCwd = typeof metadata.codexSessionCwd === "string" ? metadata.codexSessionCwd : null;
+  const requestedResumeSessionId = normalizedArgs.resumeSessionId;
+  const requestedResumeCwd = opts.resumeSessionCwd ?? metadataCodexSessionCwd;
+  const resumeSessionMatchesCwd = requestedResumeSessionId ? codexResumeCwdMatches(requestedResumeCwd, metadata.path) && isCodexResumeSessionValidForCwd(requestedResumeSessionId, metadata.path) : false;
+  const initialCodexSessionId = requestedResumeSessionId && resumeSessionMatchesCwd ? requestedResumeSessionId : null;
+  if (requestedResumeSessionId && !resumeSessionMatchesCwd) {
+    persistence.logger.debug(`[codex] Ignoring resume session ${requestedResumeSessionId} because it does not match cwd ${metadata.path}`);
+    sessionClient.updateMetadata((currentMetadata) => {
+      const nextMetadata = { ...currentMetadata };
+      delete nextMetadata.codexSessionId;
+      delete nextMetadata.codexSessionCwd;
+      return nextMetadata;
+    });
+  }
+  const messageQueue = new sessionControl.MessageQueue2(getCodexExecutionFingerprint);
   let currentPermissionMode = initialPermissionMode;
   let currentModel;
   sessionClient.onUserMessage((message) => {
-    const happyOrgResult = registerKillSessionHandler.resolveHappyOrgQueuedTurn({
+    const happyOrgResult = sessionControl.resolveHappyOrgQueuedTurn({
       metadata: sessionClient.getMetadataSnapshot?.() ?? metadata,
       message,
       sessionId: sessionClient.sessionId
@@ -2104,7 +2213,7 @@ async function runCodex(opts) {
     path: metadata.path,
     logPath: persistence.logger.logFilePath,
     startupRolePrompt: happyOrgStartupBinding?.identityPrompt ?? null,
-    sessionId: normalizedArgs.resumeSessionId,
+    sessionId: initialCodexSessionId,
     mode: requestedStartingMode,
     messageQueue,
     codexArgs: normalizedArgs.codexArgs,
@@ -2113,7 +2222,7 @@ async function runCodex(opts) {
     userObserver: userScopedObserver,
     onModeChange: async (mode) => {
       sessionClient.sendSessionEvent({ type: "switch", mode });
-      await registerKillSessionHandler.syncControlledByUserState(sessionClient, mode === "local");
+      await sessionControl.syncControlledByUserState(sessionClient, mode === "local");
     }
   });
   let exitCode = null;
@@ -2142,7 +2251,7 @@ async function runCodex(opts) {
     reconnectionHandle?.cancel();
     codexSession?.cleanup();
   };
-  const disposeFatalProcessHandlers = installFatalProcessHandlers({
+  const disposeFatalProcessHandlers = installFatalProcessHandlers.installFatalProcessHandlers({
     label: "codex",
     cleanup: async ({ event, error }) => {
       await cleanupResources({