happy-imou-cloud 2.1.44 → 2.1.46

package/dist/{index-DxF1W0nt.mjs → index-CUVIZLuf.mjs}

@@ -1,5 +1,5 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
-import { l as logger, q as encodeBase64, c as configuration, t as readCredentials, u as ensureSigningCredentials, r as readSettings, v as updateSettings, w as encodeBase64Url, m as delay, x as buildClientHeaders, y as decodeBase64, z as writeCredentialsLegacy, B as writeCredentialsDataKey, C as readDaemonState, D as HAPPY_CLOUD_DAEMON_PORT, E as clearDaemonState, F as packageJson, i as isAuthenticationRequiredError, G as acquireDaemonLock, I as writeDaemonState, A as ApiClient, J as releaseDaemonLock, K as validateProfileForAgent, L as getProfileEnvironmentVariables, M as clearCredentials, N as clearMachineId, O as readHappyOrgDispatchTruthSnapshot, P as processHappyOrgRepoRequests, Q as readHappyOrgRepoTaskBoard, R as HappyOrgTurnReportSchema, S as recordHappyOrgTurnReport, T as MessageContentSchema, U as buildSocketAuth, V as encrypt, H as HeadTailPreviewBuffer, W as getLatestDaemonLog } from './api-BhMVpzwg.mjs';
+import { l as logger, q as encodeBase64, c as configuration, t as readCredentials, u as ensureSigningCredentials, r as readSettings, v as updateSettings, w as encodeBase64Url, m as delay, x as buildClientHeaders, y as decodeBase64, z as writeCredentialsLegacy, B as writeCredentialsDataKey, C as readDaemonState, D as HAPPY_CLOUD_DAEMON_PORT, E as clearDaemonState, F as packageJson, i as isAuthenticationRequiredError, G as buildSessionRuntimeIndex, I as acquireDaemonLock, J as writeDaemonState, A as ApiClient, K as releaseDaemonLock, L as validateProfileForAgent, M as getProfileEnvironmentVariables, N as clearCredentials, O as clearMachineId, P as readHappyOrgDispatchTruthSnapshot, Q as processHappyOrgRepoRequests, R as readHappyOrgRepoTaskBoard, S as HappyOrgTurnReportSchema, T as recordHappyOrgTurnReport, U as MessageContentSchema, V as buildSocketAuth, W as encrypt, H as HeadTailPreviewBuffer, X as getLatestDaemonLog } from './api-DTSpLLTK.mjs';
 import { z } from 'zod';
 import fs, { writeFile as writeFile$1, rename, unlink as unlink$1 } from 'fs/promises';
 import os$1, { homedir } from 'os';
@@ -11,7 +11,7 @@ import qrcode from 'qrcode-terminal';
 import { writeFile, unlink, readdir, readFile, mkdir } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import os, { tmpdir, homedir as homedir$1 } from 'node:os';
-import path, { join, resolve as resolve$1, dirname as dirname$1, normalize, isAbsolute, delimiter, basename } from 'node:path';
+import path, { join, resolve as resolve$1, dirname as dirname$1, normalize, isAbsolute, delimiter, relative, basename } from 'node:path';
 import open from 'open';
 import React, { useState } from 'react';
 import { useInput, Box, Text, render } from 'ink';
@@ -2830,16 +2830,27 @@ function createSessionMetadata(opts) {
   };
 }
 
+function archiveManagedSessionWithObserver(opts) {
+  if (!opts.userScopedObserver || !opts.sessionIndex) {
+    return false;
+  }
+  return opts.userScopedObserver.syncSessionRuntimeIndex(opts.sessionId, {
+    ...opts.sessionIndex,
+    lifecycleState: "archived"
+  }, {
+    markInactive: true
+  });
+}
 async function archiveManagedSessionById(opts) {
   try {
-    const sessionClient = opts.api.sessionSyncClient({ id: opts.sessionId });
+    const sessionClient = opts.api.sessionSyncClient(opts.session);
     await closeProviderSession(sessionClient, {
       archiveReason: opts.archiveReason,
       archivedBy: "daemon"
     });
   } catch (error) {
     logger.debug(
-      `[DAEMON RUN] Failed to archive managed session ${opts.sessionId}: ${opts.archiveReason}`,
+      `[DAEMON RUN] Failed to archive managed session ${opts.session.id}: ${opts.archiveReason}`,
       error
     );
   }
@@ -2868,7 +2879,7 @@ async function precreateDaemonManagedSession(opts) {
 async function archivePrecreatedManagedSession(opts) {
   await archiveManagedSessionById({
     api: opts.api,
-    sessionId: opts.session.id,
+    session: opts.session,
     archiveReason: opts.archiveReason
   });
 }
@@ -2877,11 +2888,15 @@ async function archiveDetachedManagedSessionIfNeeded(opts) {
   if (trackedSession.startedBy !== "daemon" || !trackedSession.happySessionId || trackedSession.happySessionMetadataFromLocalWebhook || trackedSession.skipDetachedManagedSessionArchive) {
     return false;
   }
-  await archiveManagedSessionById({
-    api: opts.api,
+  if (!archiveManagedSessionWithObserver({
+    userScopedObserver: opts.userScopedObserver,
     sessionId: trackedSession.happySessionId,
-    archiveReason: opts.archiveReason
-  });
+    sessionIndex: trackedSession.sessionIndex
+  })) {
+    logger.debug(
+      `[DAEMON RUN] Detached managed session ${trackedSession.happySessionId} cannot be archived because runtime index sync is unavailable`
+    );
+  }
   return true;
 }
 
@@ -2959,6 +2974,7 @@ function createTrackedSessionFromRemoteIndexEntry(entry) {
   return {
     startedBy,
     happySessionId: entry.id,
+    sessionIndex: entry.sessionIndex ?? null,
     pid: entry.sessionIndex?.hostPid ?? 0
   };
 }
@@ -2985,6 +3001,7 @@ async function recoverTrackedSessionsFromRemoteIndex({
   machineId,
   trackedSessionPids,
   trackSession,
+  removeTrackedSession,
   userScopedObserver,
   lookupHappyProcessByPid = findHappyProcessByPid,
   archiveStaleSessions = true,
@@ -2999,7 +3016,13 @@ async function recoverTrackedSessionsFromRemoteIndex({
   for (const session of sessions) {
     const sessionIndex = session.sessionIndex;
     const pid = sessionIndex?.hostPid;
-    if (!sessionIndex || sessionIndex.machineId !== machineId || typeof pid !== "number" || sessionIndex.lifecycleState === "archived") {
+    if (!sessionIndex || sessionIndex.machineId !== machineId || typeof pid !== "number") {
+      continue;
+    }
+    if (sessionIndex.lifecycleState === "archived" || session.active === false) {
+      if (alreadyTracked.has(pid)) {
+        removeTrackedSession?.(pid, session.id);
+      }
       continue;
     }
     if (alreadyTracked.has(pid)) {
@@ -3039,6 +3062,7 @@ async function recoverTrackedSessionsFromRemoteIndex({
       }
       const archived = await archiveStaleRemoteSession(userScopedObserver, session);
       if (archived) {
+        removeTrackedSession?.(pid, session.id);
         archivedStaleCount++;
       } else {
         skippedStaleCount++;
@@ -3107,6 +3131,7 @@ function createTrackedSessionFromRegistryEntry(entry) {
     startedBy: metadata.startedBy === "daemon" ? "daemon" : "happy directly - likely by user from terminal",
     happySessionId: entry.sessionId,
     happySessionMetadataFromLocalWebhook: metadata,
+    sessionIndex: buildSessionRuntimeIndex(metadata),
     pid: entry.pid
   };
 }
@@ -3499,11 +3524,13 @@ async function startDaemon() {
     const pidToTrackedSession = /* @__PURE__ */ new Map();
     const pidToAwaiter = /* @__PURE__ */ new Map();
     const getCurrentChildren = () => Array.from(pidToTrackedSession.values());
+    let userScopedObserver = null;
     const removeTrackedSession = (pid, archiveReason) => {
       const trackedSession = pidToTrackedSession.get(pid);
       if (trackedSession && api) {
         void archiveDetachedManagedSessionIfNeeded({
           api,
+          userScopedObserver,
           trackedSession,
           archiveReason
         });
@@ -3523,6 +3550,7 @@ async function startDaemon() {
       if (existingSession && existingSession.startedBy === "daemon") {
         existingSession.happySessionId = sessionId;
         existingSession.happySessionMetadataFromLocalWebhook = sessionMetadata;
+        existingSession.sessionIndex = buildSessionRuntimeIndex(sessionMetadata);
         logger.debug(`[DAEMON RUN] Updated daemon-spawned session ${sessionId} with metadata`);
         const awaiter = pidToAwaiter.get(pid);
         if (awaiter) {
@@ -3538,6 +3566,7 @@ async function startDaemon() {
           startedBy: "happy directly - likely by user from terminal",
           happySessionId: sessionId,
           happySessionMetadataFromLocalWebhook: sessionMetadata,
+          sessionIndex: buildSessionRuntimeIndex(sessionMetadata),
           pid
         };
         pidToTrackedSession.set(pid, trackedSession);
@@ -3696,6 +3725,7 @@ async function startDaemon() {
                 requestedSessionId: options.sessionId,
                 precreatedSessionId: precreatedCodexSession?.id
               }),
+              sessionIndex: buildSessionRuntimeIndex(precreatedCodexSession?.metadata),
               skipDetachedManagedSessionArchive: reuseExistingManagedSession,
               pid: tmuxResult.pid,
               // Real PID from tmux -P flag
@@ -3840,6 +3870,7 @@ ${stderrSnapshot}`);
               requestedSessionId: options.sessionId,
               precreatedSessionId: precreatedCodexSession?.id
             }),
+            sessionIndex: buildSessionRuntimeIndex(precreatedCodexSession?.metadata),
             skipDetachedManagedSessionArchive: reuseExistingManagedSession,
             pid: happyProcess.pid,
             childProcess: happyProcess,
@@ -4028,7 +4059,6 @@ ${stderrSnapshot}`);
     };
     api = await ApiClient.create(credentials);
     const activeApi = api;
-    let userScopedObserver = null;
     if (credentials.signing) {
       try {
         userScopedObserver = activeApi.userScopedObserverClient?.() ?? null;
@@ -4063,6 +4093,13 @@ ${stderrSnapshot}`);
         trackSession: (pid, trackedSession) => {
           pidToTrackedSession.set(pid, trackedSession);
         },
+        removeTrackedSession: (pid, sessionId) => {
+          const trackedSession = pidToTrackedSession.get(pid);
+          if (trackedSession?.happySessionId === sessionId) {
+            pidToTrackedSession.delete(pid);
+            logger.debug(`[DAEMON RUN] Removed archived remote session ${sessionId} from tracking`);
+          }
+        },
         userScopedObserver,
         archiveStaleSessions: opts.archiveStaleSessions,
         skipArchivalSessionIds: pendingManagedRespawnSessionIds
@@ -8609,11 +8646,15 @@ class AcpBackend {
   transport;
   sessionPreferences;
   sessionConfigOptions = null;
+  agentCapabilities = null;
   /** Keep a short rolling stderr buffer so startup failures can surface the real cause. */
   recentStderrLines = [];
   acpMaxMultilineStdoutBytes;
   oversizedStdoutNoticeEmittedForCurrentTurn = false;
   resourceCleanupDone = false;
+  getProviderSessionId() {
+    return this.acpSessionId;
+  }
   recordRecentStderr(text) {
     const normalized = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
     if (normalized.length === 0) {
@@ -8650,6 +8691,14 @@ class AcpBackend {
   updateSessionConfigOptions(configOptions) {
     this.sessionConfigOptions = Array.isArray(configOptions) ? configOptions : null;
   }
+  supportsLoadSession() {
+    const capabilities = this.agentCapabilities;
+    return capabilities?.loadSession === true;
+  }
+  supportsResumeSession() {
+    const capabilities = this.agentCapabilities;
+    return capabilities?.sessionCapabilities?.resume != null;
+  }
   syncSessionConfigOptionsFromUpdate(update) {
     const configOptions = update.configOptions;
     if (!Array.isArray(configOptions)) {
@@ -9231,7 +9280,7 @@ Recent stderr: ${recentStderrSummaryLine}` : `Signal: ${signal}`;
         await delay(initDelayMs);
       }
       logger.debug(`[AcpBackend] Initializing connection (timeout: ${initTimeout}ms)...`);
-      await withRetry(
+      const initializeResponse = await withRetry(
         async () => {
           let timeoutHandle = null;
           try {
@@ -9272,6 +9321,7 @@ Recent stderr: ${recentStderrSummaryLine}` : `Signal: ${signal}`;
           shouldRetry: (error) => !(error instanceof AcpProcessStartupError)
         }
       );
+      this.agentCapabilities = initializeResponse.agentCapabilities ?? null;
       logger.debug(`[AcpBackend] Initialize completed`);
       const mcpServers = this.options.mcpServers ? Object.entries(this.options.mcpServers).map(([name, config]) => ({
         name,
@@ -9283,7 +9333,21 @@ Recent stderr: ${recentStderrSummaryLine}` : `Signal: ${signal}`;
         cwd: this.options.cwd,
         mcpServers
       };
-      logger.debug(`[AcpBackend] Creating new session...`);
+      const requestedResumeSessionId = typeof this.options.resumeSessionId === "string" && this.options.resumeSessionId.trim() ? this.options.resumeSessionId.trim() : null;
+      const sessionOperation = requestedResumeSessionId && this.supportsResumeSession() ? "resume" : requestedResumeSessionId && this.supportsLoadSession() ? "load" : "new";
+      const sessionRequest = sessionOperation === "resume" ? {
+        cwd: this.options.cwd,
+        mcpServers,
+        sessionId: requestedResumeSessionId
+      } : sessionOperation === "load" ? {
+        cwd: this.options.cwd,
+        mcpServers,
+        sessionId: requestedResumeSessionId
+      } : newSessionRequest;
+      if (requestedResumeSessionId && sessionOperation === "new") {
+        throw new Error("ACP agent does not support session resume/load; refusing to fork the Codex conversation");
+      }
+      logger.debug(`[AcpBackend] ${sessionOperation === "new" ? "Creating new" : `${sessionOperation === "resume" ? "Resuming" : "Loading"} existing`} session...`);
       const sessionResponse = await withRetry(
         async () => {
           let timeoutHandle = null;
@@ -9291,7 +9355,7 @@ Recent stderr: ${recentStderrSummaryLine}` : `Signal: ${signal}`;
             const result = await raceWithProcessExit(
               this.process,
               () => Promise.race([
-                this.connection.newSession(newSessionRequest).then((res) => {
+                (sessionOperation === "resume" ? this.connection.resumeSession(sessionRequest) : sessionOperation === "load" ? this.connection.loadSession(sessionRequest) : this.connection.newSession(sessionRequest)).then((res) => {
                   if (timeoutHandle) {
                     clearTimeout(timeoutHandle);
                     timeoutHandle = null;
@@ -9318,14 +9382,14 @@ Recent stderr: ${recentStderrSummaryLine}` : `Signal: ${signal}`;
           }
         },
         {
-          operationName: "NewSession",
+          operationName: sessionOperation === "resume" ? "ResumeSession" : sessionOperation === "load" ? "LoadSession" : "NewSession",
           maxAttempts: RETRY_CONFIG.maxAttempts,
           baseDelayMs: RETRY_CONFIG.baseDelayMs,
           maxDelayMs: RETRY_CONFIG.maxDelayMs,
           shouldRetry: (error) => !(error instanceof AcpProcessStartupError)
         }
       );
-      this.acpSessionId = sessionResponse.sessionId;
+      this.acpSessionId = requestedResumeSessionId ?? sessionResponse.sessionId;
       this.updateSessionConfigOptions(sessionResponse.configOptions);
       logger.debug(`[AcpBackend] Session created: ${this.acpSessionId}`);
       await this.applySessionConfigPresets();
@@ -10004,8 +10068,23 @@ function readCodexAcpConfigOverrides() {
   const raw = readFirstEnv("HAPPY_CODEX_ACP_CONFIG_OVERRIDES", "HAPPIER_CODEX_ACP_CONFIG_OVERRIDES");
   return raw.split("\n").map((line) => line.trim()).filter(Boolean);
 }
+function sanitizeCodexAcpBaseArgs(baseArgs = []) {
+  const sanitized = [];
+  for (let index = 0; index < baseArgs.length; index += 1) {
+    const arg = baseArgs[index];
+    if (arg === "--dangerously-bypass-approvals-and-sandbox" || arg === "--yolo" || arg.startsWith("--ask-for-approval=") || arg.startsWith("--approval-policy=") || arg.startsWith("--sandbox=")) {
+      continue;
+    }
+    if (arg === "--ask-for-approval" || arg === "--approval-policy" || arg === "--sandbox") {
+      index += 1;
+      continue;
+    }
+    sanitized.push(arg);
+  }
+  return sanitized;
+}
 function buildCodexAcpConfigArgs(options) {
-  const args = [...options.baseArgs ?? []];
+  const args = sanitizeCodexAcpBaseArgs(options.baseArgs);
   const overrides = [...readCodexAcpConfigOverrides()];
   if (options.model) {
     overrides.push(`model=${JSON.stringify(options.model)}`);
@@ -10134,6 +10213,9 @@ function resolveCodexExecutable() {
   }
   return "codex";
 }
+function shouldUseShellForCodex(executable) {
+  return process.platform === "win32" && /\.(cmd|bat|ps1)$/i.test(executable);
+}
 
 const CODEX_HOME_SEED_FILES = [
   "auth.json",
@@ -10147,6 +10229,24 @@ const CODEX_HOME_SEED_DIRS = [
 ];
 const MAX_CODEX_SKILL_DESCRIPTION_LENGTH = 1024;
 const MANAGED_CODEX_HOME_PREFIX = "happy-codex-home-";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isApiKeyOnlyCodexAuth(value) {
+  if (!isPlainObject(value)) {
+    return false;
+  }
+  const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== void 0 && entryValue !== null);
+  return entries.length === 1 && typeof value.OPENAI_API_KEY === "string" && value.OPENAI_API_KEY.trim().length > 0;
+}
+function shouldUseSourceCodexHomeForMutableAuth(sourceHomeDir) {
+  try {
+    const auth = JSON.parse(readFileSync(join(sourceHomeDir, "auth.json"), "utf8"));
+    return !isApiKeyOnlyCodexAuth(auth);
+  } catch {
+    return false;
+  }
+}
 function getCodexPlatformTarget(platform, arch) {
   if (platform === "win32" && arch === "x64") {
     return {
@@ -10410,7 +10510,135 @@ function seedCodexSkillEntries(sourceSkillsDir, isolatedHomeDir, sourceLabel) {
     }
   }
 }
-function seedIsolatedCodexHome(sourceHomeDir, isolatedHomeDir, bundledSkillsDir) {
+function isWithinDirectory(parentDir, childPath, platform) {
+  const normalizedParent = normalizePathForComparison(parentDir, platform);
+  const normalizedChild = normalizePathForComparison(childPath, platform);
+  return normalizedChild === normalizedParent || normalizedChild.startsWith(`${normalizedParent}/`);
+}
+function extractCodexSessionIdFromFilePath(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 findCodexSessionFile(sourceHomeDir, resumeSessionId, platform) {
+  const sessionsRoot = join(sourceHomeDir, "sessions");
+  const stack = [sessionsRoot];
+  let bestMatch = null;
+  while (stack.length > 0) {
+    const currentDir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      if (!isWithinDirectory(sessionsRoot, fullPath, platform)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile() || extractCodexSessionIdFromFilePath(fullPath) !== resumeSessionId) {
+        continue;
+      }
+      try {
+        const mtimeMs = statSync(fullPath).mtimeMs;
+        if (!bestMatch || mtimeMs > bestMatch.mtimeMs) {
+          bestMatch = { path: fullPath, mtimeMs };
+        }
+      } catch {
+      }
+    }
+  }
+  return bestMatch?.path ?? null;
+}
+function seedCodexResumeSessionFile(sourceHomeDir, isolatedHomeDir, resumeSessionId, platform) {
+  const normalizedResumeSessionId = typeof resumeSessionId === "string" && resumeSessionId.trim() ? resumeSessionId.trim() : null;
+  if (!normalizedResumeSessionId) {
+    return;
+  }
+  const sourceSessionFile = findCodexSessionFile(sourceHomeDir, normalizedResumeSessionId, platform);
+  if (!sourceSessionFile) {
+    logger.debug(`[codex] No source CODEX_HOME session file found for resume id ${normalizedResumeSessionId}`);
+    return;
+  }
+  const sourceSessionsRoot = join(sourceHomeDir, "sessions");
+  const relativeSessionPath = relative(sourceSessionsRoot, sourceSessionFile);
+  if (!relativeSessionPath || relativeSessionPath.startsWith("..") || isAbsolute(relativeSessionPath)) {
+    logger.debug(`[codex] Refusing to seed CODEX_HOME session outside sessions root: ${sourceSessionFile}`);
+    return;
+  }
+  try {
+    copyCodexHomeEntry(
+      sourceSessionFile,
+      join(isolatedHomeDir, "sessions", relativeSessionPath)
+    );
+  } catch (error) {
+    logger.debug(`[codex] Failed to seed CODEX_HOME session file for ${normalizedResumeSessionId}`, error);
+  }
+}
+function shouldSyncCodexSessionFileBack(sourcePath, destPath) {
+  let sourceStat;
+  try {
+    sourceStat = statSync(sourcePath);
+  } catch {
+    return false;
+  }
+  if (!sourceStat.isFile()) {
+    return false;
+  }
+  let destStat;
+  try {
+    destStat = statSync(destPath);
+  } catch {
+    return true;
+  }
+  return sourceStat.mtimeMs >= destStat.mtimeMs || sourceStat.size !== destStat.size;
+}
+function syncCodexSessionFilesBackToSource(isolatedHomeDir, sourceHomeDir, platform) {
+  const isolatedSessionsRoot = join(isolatedHomeDir, "sessions");
+  const sourceSessionsRoot = join(sourceHomeDir, "sessions");
+  const stack = [isolatedSessionsRoot];
+  while (stack.length > 0) {
+    const currentDir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      if (!isWithinDirectory(isolatedSessionsRoot, fullPath, platform)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile() || extractCodexSessionIdFromFilePath(fullPath) === null) {
+        continue;
+      }
+      const relativeSessionPath = relative(isolatedSessionsRoot, fullPath);
+      if (!relativeSessionPath || relativeSessionPath.startsWith("..") || isAbsolute(relativeSessionPath)) {
+        logger.debug(`[codex] Refusing to sync CODEX_HOME session outside sessions root: ${fullPath}`);
+        continue;
+      }
+      const destPath = join(sourceSessionsRoot, relativeSessionPath);
+      if (!shouldSyncCodexSessionFileBack(fullPath, destPath)) {
+        continue;
+      }
+      try {
+        copyCodexHomeEntry(fullPath, destPath);
+      } catch (error) {
+        logger.debug(`[codex] Failed to sync CODEX_HOME session file back to source: ${fullPath}`, error);
+      }
+    }
+  }
+}
+function seedIsolatedCodexHome(sourceHomeDir, isolatedHomeDir, bundledSkillsDir, resumeSessionId, platform) {
   if (existsSync(sourceHomeDir)) {
     for (const fileName of CODEX_HOME_SEED_FILES) {
       try {
@@ -10431,6 +10659,7 @@ function seedIsolatedCodexHome(sourceHomeDir, isolatedHomeDir, bundledSkillsDir)
     seedCodexSkillEntries(bundledSkillsDir, isolatedHomeDir, "bundled skills");
   }
   seedCodexSkillEntries(join(sourceHomeDir, "skills"), isolatedHomeDir, "source CODEX_HOME");
+  seedCodexResumeSessionFile(sourceHomeDir, isolatedHomeDir, resumeSessionId, platform);
 }
 function prepareCodexAcpEnvironment(overrides = {}, options = {}) {
   const env = buildCodexAcpEnv(overrides, options);
@@ -10448,17 +10677,26 @@ function prepareCodexAcpEnvironment(overrides = {}, options = {}) {
       return { env };
     }
   }
+  const sourceHomeDir = options.sourceHomeDir ?? join(homedir$1(), ".codex");
+  const bundledSkillsDir = options.bundledSkillsDir ?? join(projectPath(), "skills");
+  if (shouldUseSourceCodexHomeForMutableAuth(sourceHomeDir)) {
+    logger.debug("[codex] Using source CODEX_HOME for mutable Codex auth credentials");
+    env.CODEX_HOME = sourceHomeDir;
+    return {
+      env,
+      codexHomePath: sourceHomeDir
+    };
+  }
   const tempDirFactory = options.tempDirFactory ?? mkdtempSync;
   const isolatedHomeDir = tempDirFactory(join(tmpdir(), "happy-codex-home-"));
   mkdirSync$1(isolatedHomeDir, { recursive: true });
-  const sourceHomeDir = options.sourceHomeDir ?? join(homedir$1(), ".codex");
-  const bundledSkillsDir = options.bundledSkillsDir ?? join(projectPath(), "skills");
-  seedIsolatedCodexHome(sourceHomeDir, isolatedHomeDir, bundledSkillsDir);
+  seedIsolatedCodexHome(sourceHomeDir, isolatedHomeDir, bundledSkillsDir, options.resumeSessionId, platform);
   env.CODEX_HOME = isolatedHomeDir;
   return {
     env,
     codexHomePath: isolatedHomeDir,
     cleanup: () => {
+      syncCodexSessionFilesBackToSource(isolatedHomeDir, sourceHomeDir, platform);
       rmSync(isolatedHomeDir, { recursive: true, force: true });
     }
   };
@@ -10491,6 +10729,8 @@ function createCodexBackend(options) {
   const preparedEnv = prepareCodexAcpEnvironment({
     ...options.env,
     NODE_ENV: "production"
+  }, {
+    resumeSessionId: options.resumeSessionId
   });
   const backendOptions = {
     agentName: "codex",
@@ -10501,7 +10741,8 @@ function createCodexBackend(options) {
     permissionHandler: options.permissionHandler,
     selectionHandler: options.selectionHandler,
     transportHandler: resolveCodexTransport(spawn.command),
-    resourceCleanup: preparedEnv.cleanup
+    resourceCleanup: preparedEnv.cleanup,
+    resumeSessionId: options.resumeSessionId
   };
   return {
     backend: new AcpBackend(backendOptions),
@@ -11935,14 +12176,14 @@ var launch = /*#__PURE__*/Object.freeze({
 const unifiedProviderExecutors = {
   claude: async (opts) => {
     const claudeOptions = opts.claudeOptions ?? {};
-    const { runClaude } = await import('./runClaude-BpwlCyVT.mjs');
+    const { runClaude } = await import('./runClaude-CFeIMCY2.mjs');
     await runClaude(opts.credentials, {
       ...claudeOptions,
       startingMode: claudeOptions.startingMode ?? (claudeOptions.startedBy === "daemon" ? "remote" : void 0)
     });
   },
   codex: async (opts) => {
-    const { runCodex } = await import('./runCodex-BMNR2hNp.mjs');
+    const { runCodex } = await import('./runCodex-ByjUfTyr.mjs');
     await runCodex({
       credentials: opts.credentials,
       startedBy: opts.startedBy,
@@ -11951,7 +12192,7 @@ const unifiedProviderExecutors = {
     });
   },
   gemini: async (opts) => {
-    const { runGemini } = await import('./runGemini-D4Af8oH1.mjs');
+    const { runGemini } = await import('./runGemini-CihCRgcR.mjs');
     await runGemini({
       credentials: opts.credentials,
       startedBy: opts.startedBy
@@ -12034,7 +12275,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await import('./command-h3Rr4Abu.mjs');
+      const { renderRuntimeProviders } = await import('./command-umgXYSY2.mjs');
       console.log(renderRuntimeProviders());
       return;
     }
@@ -12240,8 +12481,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await import('./api-BhMVpzwg.mjs').then(function (n) { return n.X; });
-        const { ApiClient: ApiClient2 } = await import('./api-BhMVpzwg.mjs').then(function (n) { return n.Y; });
+        const { readCredentials: readCredentials2 } = await import('./api-DTSpLLTK.mjs').then(function (n) { return n.Y; });
+        const { ApiClient: ApiClient2 } = await import('./api-DTSpLLTK.mjs').then(function (n) { return n.Z; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();
@@ -12659,4 +12900,4 @@ ${chalk.bold("Examples:")}
   }
 }
 
-export { AbortError as A, getEnvironmentInfo as B, startCaffeinate as C, ExitCodeError as E, Future as F, GEMINI_MODEL_ENV as G, PushableAsyncIterable as P, RuntimeShell as R, createSessionMetadata as a, closeProviderSession as b, createDefaultRuntimeShell as c, createGeminiBackend as d, stopCaffeinate as e, formatDisplayMessage as f, getInitialGeminiModel as g, createCodexBackend as h, readManagedSessionTag as i, resolveManagedSessionTag as j, initialMachineMetadata as k, resolveCanonicalToolNameV2 as l, isTerminalReferenceOnlyPayload as m, getProjectPath as n, claudeLocal as o, publishSessionRegistration as p, trimIdent as q, readGeminiLocalConfig as r, saveGeminiModelToConfig as s, truncateDisplayMessage as t, createClaudeBackend as u, validateCodexAcpSpawn as v, claudeCheckSession as w, projectPath as x, mapToClaudeMode as y, query as z };
+export { AcpBackend as A, mapToClaudeMode as B, query as C, AbortError as D, ExitCodeError as E, Future as F, GEMINI_MODEL_ENV as G, getEnvironmentInfo as H, startCaffeinate as I, PushableAsyncIterable as P, RuntimeShell as R, createSessionMetadata as a, closeProviderSession as b, createDefaultRuntimeShell as c, createGeminiBackend as d, stopCaffeinate as e, formatDisplayMessage as f, getInitialGeminiModel as g, createCodexBackend as h, resolveCodexExecutable as i, shouldUseShellForCodex as j, readManagedSessionTag as k, resolveManagedSessionTag as l, initialMachineMetadata as m, resolveCanonicalToolNameV2 as n, isTerminalReferenceOnlyPayload as o, publishSessionRegistration as p, getProjectPath as q, readGeminiLocalConfig as r, saveGeminiModelToConfig as s, truncateDisplayMessage as t, claudeLocal as u, validateCodexAcpSpawn as v, trimIdent as w, createClaudeBackend as x, claudeCheckSession as y, projectPath as z };