happy-imou-cloud 2.0.8 → 2.0.10

package/dist/{index-DhheEtRl.mjs → index-CzvgPwr1.mjs}

@@ -1,34 +1,34 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
-import { l as logger, e as encodeBase64, c as configuration, h as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, j as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, k as encodeBase64Url, f as delay, m as buildClientHeaders, n as decodeBase64, H as HAPPY_CLOUD_DAEMON_PORT, p as packageJson, A as ApiClient, o as getLatestDaemonLog } from './api-D-uiH_TF.mjs';
-import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-DiNg1DPF.mjs';
+import { l as logger, e as encodeBase64, c as configuration, h as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, j as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, k as encodeBase64Url, f as delay, m as buildClientHeaders, n as decodeBase64, H as HAPPY_CLOUD_DAEMON_PORT, p as packageJson, A as ApiClient, o as getLatestDaemonLog } from './api-BjxmW-0W.mjs';
+import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-BxP6Jw1f.mjs';
 import { z } from 'zod';
-import fs from 'fs/promises';
+import fs, { writeFile as writeFile$1, rename, unlink as unlink$1 } from 'fs/promises';
 import os, { homedir } from 'os';
 import * as tmp from 'tmp';
 import { randomUUID, randomBytes } from 'node:crypto';
 import tweetnacl from 'tweetnacl';
 import axios from 'axios';
 import qrcode from 'qrcode-terminal';
-import { writeFile, unlink } from 'node:fs/promises';
+import { writeFile, unlink, readdir, readFile, mkdir } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import os$1, { tmpdir, homedir as homedir$1 } from 'node:os';
-import { join, resolve as resolve$1, isAbsolute, delimiter } from 'node:path';
+import path, { join, resolve as resolve$1, isAbsolute, delimiter, normalize, dirname as dirname$1 } from 'node:path';
 import open from 'open';
 import React, { useState } from 'react';
 import { useInput, Box, Text, render } from 'ink';
 import { spawn, execSync, exec } from 'child_process';
 import { dirname, resolve, join as join$1 } from 'path';
 import { fileURLToPath } from 'url';
-import { readFileSync as readFileSync$1, existsSync as existsSync$1, writeFileSync, chmodSync, unlinkSync, mkdirSync } from 'fs';
+import { readFileSync as readFileSync$1, existsSync as existsSync$1, writeFileSync, chmodSync, unlinkSync as unlinkSync$1, mkdirSync } from 'fs';
 import { execFileSync, spawn as spawn$2 } from 'node:child_process';
 import psList from 'ps-list';
 import spawn$1 from 'cross-spawn';
-import { existsSync, readFileSync, readdirSync, statSync, rmSync, mkdirSync as mkdirSync$1 } from 'node:fs';
+import fs$1, { existsSync, readFileSync, readdirSync, statSync, unlinkSync, rmSync, mkdirSync as mkdirSync$1, realpathSync } from 'node:fs';
 import fastify from 'fastify';
 import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
+import { randomUUID as randomUUID$1, randomBytes as randomBytes$1, createHash } from 'crypto';
 import { createInterface } from 'node:readline';
 import { createServer } from 'http';
-import { randomBytes as randomBytes$1, createHash } from 'crypto';
 import { promisify } from 'util';
 import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
 
@@ -677,6 +677,16 @@ function projectPath() {
   return path;
 }
 
+function classifyHappyProcessLookup(proc) {
+  const match = classifyHappyProcess(proc);
+  if (match) {
+    return match;
+  }
+  if (process.platform === "win32" && isWindowsCliHostProcess(proc.name) && proc.cmd.trim().length === 0) {
+    return "indeterminate";
+  }
+  return null;
+}
 function getDaemonPid() {
   try {
     if (!existsSync(configuration.daemonStateFile)) {
@@ -757,7 +767,7 @@ function findWindowsDaemonProcess(processes) {
   return {
     pid: daemonPid,
     command: `${daemonProcess.name || "unknown"} (PID ${daemonPid})`,
-    type: "daemon"
+    type: "daemon-indeterminate"
   };
 }
 function findWindowsHappyProcesses(processes) {
@@ -774,6 +784,40 @@ function findWindowsHappyProcesses(processes) {
   }
   return Array.from(matches.values());
 }
+function toProcessSnapshot(proc) {
+  return {
+    pid: proc.pid,
+    name: proc.name || "",
+    cmd: proc.cmd || ""
+  };
+}
+async function findHappyProcessByPid(pid) {
+  try {
+    if (process.platform === "win32") {
+      const windowsProcesses = getWindowsProcessSnapshots();
+      if (windowsProcesses.length > 0) {
+        const proc3 = windowsProcesses.find((candidate) => candidate.pid === pid);
+        if (!proc3) {
+          return null;
+        }
+        return classifyHappyProcessLookup(proc3);
+      }
+      const fallbackProcesses = (await psList()).map(toProcessSnapshot);
+      const proc2 = fallbackProcesses.find((candidate) => candidate.pid === pid);
+      if (!proc2) {
+        return null;
+      }
+      return classifyHappyProcessLookup(proc2);
+    }
+    const proc = (await psList()).map(toProcessSnapshot).find((candidate) => candidate.pid === pid);
+    if (!proc) {
+      return null;
+    }
+    return classifyHappyProcess(proc);
+  } catch (error) {
+    return "indeterminate";
+  }
+}
 async function findAllHappyProcesses() {
   try {
     if (process.platform === "win32") {
@@ -781,15 +825,8 @@ async function findAllHappyProcesses() {
       if (windowsProcesses.length > 0) {
         return findWindowsHappyProcesses(windowsProcesses);
       }
-      const fallbackProcesses = await psList();
-      const fallbackDaemon = findWindowsDaemonProcess(
-        fallbackProcesses.map((proc) => ({
-          pid: proc.pid,
-          name: proc.name || "",
-          cmd: proc.cmd || ""
-        }))
-      );
-      return fallbackDaemon ? [fallbackDaemon] : [];
+      const fallbackProcesses = (await psList()).map(toProcessSnapshot);
+      return findWindowsHappyProcesses(fallbackProcesses);
     }
     const processes = await psList();
     const allProcesses = [];
@@ -846,6 +883,46 @@ async function killRunawayHappyProcesses() {
   return { killed, errors };
 }
 
+const CONFIRMED_DAEMON_PROCESS_TYPES = /* @__PURE__ */ new Set([
+  "daemon",
+  "dev-daemon"
+]);
+function currentProcessLooksLikeDaemon() {
+  return process.argv.join(" ").includes("daemon start-sync");
+}
+async function inspectDaemonStateProcess(state) {
+  if (!state) {
+    return "stale";
+  }
+  try {
+    process.kill(state.pid, 0);
+  } catch {
+    logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
+    await cleanupDaemonState();
+    return "stale";
+  }
+  const processInfo = await findHappyProcessByPid(state.pid);
+  if (processInfo === "indeterminate") {
+    logger.debug(`[DAEMON RUN] Daemon PID ${state.pid} is alive but process identity is indeterminate`);
+    return "indeterminate";
+  }
+  if (!processInfo) {
+    logger.debug(`[DAEMON RUN] PID ${state.pid} is alive but is not a Happy daemon process, cleaning up state`);
+    await cleanupDaemonState();
+    return "stale";
+  }
+  if (processInfo.type === "current" && currentProcessLooksLikeDaemon()) {
+    return "confirmed";
+  }
+  if (!CONFIRMED_DAEMON_PROCESS_TYPES.has(processInfo.type)) {
+    logger.debug(
+      `[DAEMON RUN] PID ${state.pid} resolved to Happy process type ${processInfo.type}, not a daemon; cleaning up state`
+    );
+    await cleanupDaemonState();
+    return "stale";
+  }
+  return "confirmed";
+}
 async function daemonPost(path, body) {
   const state = await readDaemonState();
   if (!state?.httpPort) {
@@ -855,9 +932,8 @@ async function daemonPost(path, body) {
       error: errorMessage
     };
   }
-  try {
-    process.kill(state.pid, 0);
-  } catch (error) {
+  const processStatus = await inspectDaemonStateProcess(state);
+  if (processStatus === "stale") {
     const errorMessage = "Daemon is not running, file is stale";
     logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
     return {
@@ -956,18 +1032,22 @@ async function stopDaemonHttp() {
   await daemonPost("/stop");
 }
 async function checkIfDaemonRunningAndCleanupStaleState() {
+  const runtimeStatus = await getDaemonRuntimeStatus();
+  return runtimeStatus !== "not-running";
+}
+async function getDaemonRuntimeStatus() {
   const state = await readDaemonState();
   if (!state) {
-    return false;
+    return "not-running";
   }
-  try {
-    process.kill(state.pid, 0);
-    return true;
-  } catch {
-    logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
-    await cleanupDaemonState();
-    return false;
+  const processStatus = await inspectDaemonStateProcess(state);
+  if (processStatus === "confirmed") {
+    return "running";
   }
+  if (processStatus === "indeterminate") {
+    return "indeterminate";
+  }
+  return "not-running";
 }
 async function isDaemonControlServerResponsive(timeoutMs = 1e3) {
   const state = await readDaemonState();
@@ -975,11 +1055,9 @@ async function isDaemonControlServerResponsive(timeoutMs = 1e3) {
     logger.debug("[DAEMON CONTROL] No daemon state or control port found for readiness check");
     return false;
   }
-  try {
-    process.kill(state.pid, 0);
-  } catch {
-    logger.debug("[DAEMON CONTROL] Daemon PID not running during readiness check, cleaning up state");
-    await cleanupDaemonState();
+  const processStatus = await inspectDaemonStateProcess(state);
+  if (processStatus === "stale") {
+    logger.debug("[DAEMON CONTROL] Daemon state became stale during readiness check");
     return false;
   }
   try {
@@ -995,7 +1073,7 @@ async function isDaemonControlServerResponsive(timeoutMs = 1e3) {
     return false;
   }
 }
-async function isDaemonRunningCurrentlyInstalledHappyVersion() {
+async function isDaemonRunningCurrentlyInstalledHappyVersion(readinessProbeTimeoutMs = 1e3) {
   logger.debug("[DAEMON CONTROL] Checking if daemon is running same version");
   const runningDaemon = await checkIfDaemonRunningAndCleanupStaleState();
   if (!runningDaemon) {
@@ -1015,7 +1093,7 @@ async function isDaemonRunningCurrentlyInstalledHappyVersion() {
     if (currentCliVersion !== state.startedWithCliVersion) {
       return false;
     }
-    return await isDaemonControlServerResponsive();
+    return await isDaemonControlServerResponsive(readinessProbeTimeoutMs);
   } catch (error) {
     logger.debug("[DAEMON CONTROL] Error checking daemon version", error);
     return false;
@@ -1048,6 +1126,17 @@ async function stopDaemon() {
       return;
     }
     logger.debug(`Stopping daemon with PID ${state.pid}`);
+    const processStatus = await inspectDaemonStateProcess(state);
+    if (processStatus === "stale") {
+      logger.debug("Daemon state was stale while stopping, trying known control port/orphan cleanup");
+      const stoppedByKnownPort = await stopDaemonOnKnownPort();
+      if (stoppedByKnownPort) {
+        logger.debug(`Requested daemon stop via known control port ${HAPPY_CLOUD_DAEMON_PORT}`);
+        return;
+      }
+      await killOrphanDaemonProcesses();
+      return;
+    }
     try {
       await stopDaemonHttp();
       await waitForProcessDeath(state.pid, 2e3);
@@ -1057,6 +1146,10 @@ async function stopDaemon() {
     } catch (error) {
       logger.debug("HTTP stop failed, will force kill", error);
     }
+    if (processStatus === "indeterminate") {
+      logger.debug(`Skipping force kill for PID ${state.pid} because daemon identity is indeterminate`);
+      return;
+    }
     try {
       process.kill(state.pid, "SIGKILL");
       await waitForProcessDeath(state.pid, 2e3).catch(() => {
@@ -1108,6 +1201,21 @@ function getEnvironmentInfo() {
     terminal: process.env.TERM
   };
 }
+function resolveDaemonSpawnDiagnostics(projectRoot, fileExists = existsSync) {
+  const wrapperCandidates = [
+    join(projectRoot, "bin", "happy-cloud.mjs"),
+    join(projectRoot, "bin", "happy.mjs")
+  ];
+  const cliEntrypoint = join(projectRoot, "dist", "index.mjs");
+  const wrapperPath = wrapperCandidates.find((candidate) => fileExists(candidate)) ?? wrapperCandidates[0];
+  return {
+    projectRoot,
+    wrapperPath,
+    cliEntrypoint,
+    wrapperExists: fileExists(wrapperPath),
+    cliEntrypointExists: fileExists(cliEntrypoint)
+  };
+}
 function getLogFiles(logDir) {
   if (!existsSync(logDir)) {
     return [];
@@ -1134,14 +1242,12 @@ async function runDoctorCommand(filter) {
     console.log(`Node.js Version: ${chalk.green(process.version)}`);
     console.log("");
     console.log(chalk.bold("\u{1F527} Daemon Spawn Diagnostics"));
-    const projectRoot = projectPath();
-    const wrapperPath = join(projectRoot, "bin", "happy.mjs");
-    const cliEntrypoint = join(projectRoot, "dist", "index.mjs");
-    console.log(`Project Root: ${chalk.blue(projectRoot)}`);
-    console.log(`Wrapper Script: ${chalk.blue(wrapperPath)}`);
-    console.log(`CLI Entrypoint: ${chalk.blue(cliEntrypoint)}`);
-    console.log(`Wrapper Exists: ${existsSync(wrapperPath) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
-    console.log(`CLI Exists: ${existsSync(cliEntrypoint) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
+    const diagnostics = resolveDaemonSpawnDiagnostics(projectPath());
+    console.log(`Project Root: ${chalk.blue(diagnostics.projectRoot)}`);
+    console.log(`Wrapper Script: ${chalk.blue(diagnostics.wrapperPath)}`);
+    console.log(`CLI Entrypoint: ${chalk.blue(diagnostics.cliEntrypoint)}`);
+    console.log(`Wrapper Exists: ${diagnostics.wrapperExists ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
+    console.log(`CLI Exists: ${diagnostics.cliEntrypointExists ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
     console.log("");
     console.log(chalk.bold("\u2699\uFE0F  Configuration"));
     console.log(`Happy Home: ${chalk.blue(configuration.happyCloudHomeDir)}`);
@@ -1177,9 +1283,9 @@ async function runDoctorCommand(filter) {
   }
   console.log(chalk.bold("\n\u{1F916} Daemon Status"));
   try {
-    const isRunning = await checkIfDaemonRunningAndCleanupStaleState();
+    const daemonStatus = await getDaemonRuntimeStatus();
     const state = await readDaemonState();
-    if (isRunning && state) {
+    if (daemonStatus === "running" && state) {
       console.log(chalk.green("\u2713 Daemon is running"));
       console.log(`  PID: ${state.pid}`);
       console.log(`  Started: ${new Date(state.startTime).toLocaleString()}`);
@@ -1187,7 +1293,14 @@ async function runDoctorCommand(filter) {
       if (state.httpPort) {
         console.log(`  HTTP Port: ${state.httpPort}`);
       }
-    } else if (state && !isRunning) {
+    } else if (daemonStatus === "indeterminate" && state) {
+      console.log(chalk.yellow("\u26A0\uFE0F  Daemon state exists, but process identity could not be confirmed"));
+      console.log(`  PID: ${state.pid}`);
+      console.log(`  CLI Version: ${state.startedWithCliVersion}`);
+      if (state.httpPort) {
+        console.log(`  HTTP Port: ${state.httpPort}`);
+      }
+    } else if (state) {
       console.log(chalk.yellow("\u26A0\uFE0F  Daemon state exists but process not running (stale)"));
     } else {
       console.log(chalk.red("\u274C Daemon is not running"));
@@ -1209,6 +1322,7 @@ async function runDoctorCommand(filter) {
         const typeLabels = {
           "current": "\u{1F4CD} Current Process",
           "daemon": "\u{1F916} Daemon",
+          "daemon-indeterminate": "\u26A0\uFE0F  Possible Daemon (identity unconfirmed)",
           "daemon-version-check": "\u{1F50D} Daemon Version Check (stuck)",
           "daemon-spawned-session": "\u{1F517} Daemon-Spawned Sessions",
           "user-session": "\u{1F464} User Sessions",
@@ -1223,7 +1337,7 @@ async function runDoctorCommand(filter) {
         console.log(chalk.blue(`
 ${typeLabels[type] || type}:`));
         processes.forEach(({ pid, command }) => {
-          const color = type === "current" ? chalk.green : type.startsWith("dev") ? chalk.cyan : type.includes("daemon") ? chalk.blue : chalk.gray;
+          const color = type === "current" ? chalk.green : type === "daemon-indeterminate" ? chalk.yellow : type.startsWith("dev") ? chalk.cyan : type.includes("daemon") ? chalk.blue : chalk.gray;
           console.log(`  ${color(`PID ${pid}`)}: ${chalk.gray(command)}`);
         });
       });
@@ -2253,6 +2367,283 @@ function buildDaemonChildEnv(baseEnv, extraEnv) {
   return childEnv;
 }
 
+const DIFFERENT_DAEMON_RUNNING_MESSAGE = "A different daemon was started without killing us. We should kill ourselves.";
+function readProjectCliVersionFromDisk() {
+  const packageJsonPath = join(projectPath(), "package.json");
+  try {
+    const parsedPackageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    if (typeof parsedPackageJson.version !== "string" || parsedPackageJson.version.trim().length === 0) {
+      logger.warn(
+        `[DAEMON RUN] Skipping daemon version check because ${packageJsonPath} does not contain a valid string version`
+      );
+      return null;
+    }
+    return parsedPackageJson.version;
+  } catch (error) {
+    logger.warn(
+      `[DAEMON RUN] Skipping daemon version check because ${packageJsonPath} could not be read or parsed`,
+      error instanceof Error ? error.message : String(error)
+    );
+    return null;
+  }
+}
+async function runDaemonHealthCheck({
+  trackedSessionPids,
+  removeTrackedSession,
+  currentCliVersion,
+  readProjectCliVersion = readProjectCliVersionFromDisk,
+  onDaemonOutdated,
+  readDaemonState,
+  daemonPid,
+  requestShutdown,
+  writeHeartbeat
+}) {
+  for (const pid of trackedSessionPids) {
+    try {
+      process.kill(pid, 0);
+    } catch {
+      logger.debug(`[DAEMON RUN] Removing stale session with PID ${pid} (process no longer exists)`);
+      removeTrackedSession(pid);
+    }
+  }
+  const projectVersion = readProjectCliVersion();
+  if (projectVersion && projectVersion !== currentCliVersion) {
+    await onDaemonOutdated();
+    return;
+  }
+  const daemonState = await readDaemonState();
+  if (daemonState && daemonState.pid !== daemonPid) {
+    logger.debug(`[DAEMON RUN] ${DIFFERENT_DAEMON_RUNNING_MESSAGE}`);
+    requestShutdown("exception", DIFFERENT_DAEMON_RUNNING_MESSAGE);
+    return;
+  }
+  await writeHeartbeat();
+}
+
+async function atomicFileWrite(filePath, content) {
+  const tmpFile = `${filePath}.${randomUUID$1()}.tmp`;
+  try {
+    await writeFile$1(tmpFile, content);
+    await rename(tmpFile, filePath);
+  } catch (error) {
+    try {
+      await unlink$1(tmpFile);
+    } catch {
+    }
+    throw error;
+  }
+}
+
+const SESSION_REGISTRY_VERSION = 1;
+const SESSION_REGISTRY_DIRNAME = "session-registry";
+const NON_SESSION_PROCESS_TYPES = /* @__PURE__ */ new Set([
+  "current",
+  "daemon",
+  "daemon-indeterminate",
+  "dev-daemon",
+  "daemon-launcher",
+  "dev-daemon-launcher",
+  "daemon-version-check",
+  "dev-daemon-version-check",
+  "doctor",
+  "dev-doctor"
+]);
+const registeredCleanupPids = /* @__PURE__ */ new Set();
+function getSessionRegistryDir() {
+  return join(configuration.happyCloudHomeDir, SESSION_REGISTRY_DIRNAME);
+}
+function getSessionRegistryEntryPath(pid) {
+  return join(getSessionRegistryDir(), `${pid}.json`);
+}
+function normalizeMetadataForPid(metadata, pid) {
+  if (metadata.hostPid === pid) {
+    return metadata;
+  }
+  return {
+    ...metadata,
+    hostPid: pid
+  };
+}
+function createTrackedSessionFromRegistryEntry(entry) {
+  const metadata = normalizeMetadataForPid(entry.metadata, entry.pid);
+  return {
+    startedBy: metadata.startedBy === "daemon" ? "daemon" : "happy directly - likely by user from terminal",
+    happySessionId: entry.sessionId,
+    happySessionMetadataFromLocalWebhook: metadata,
+    pid: entry.pid
+  };
+}
+async function ensureSessionRegistryDir() {
+  await mkdir(getSessionRegistryDir(), { recursive: true });
+}
+async function removeRegistryEntryPath(path) {
+  try {
+    await unlink(path);
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return false;
+    }
+    logger.debug(`[SESSION REGISTRY] Failed to remove ${path}`, error);
+    return false;
+  }
+}
+function removeRegistryEntryPathSync(path) {
+  try {
+    unlinkSync(path);
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      logger.debug(`[SESSION REGISTRY] Failed to remove ${path} during process cleanup`, error);
+    }
+  }
+}
+function installRegistryCleanup(pid) {
+  if (registeredCleanupPids.has(pid)) {
+    return;
+  }
+  registeredCleanupPids.add(pid);
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) {
+      return;
+    }
+    cleaned = true;
+    removeRegistryEntryPathSync(getSessionRegistryEntryPath(pid));
+  };
+  process.once("exit", cleanup);
+}
+async function readRegistryEntry(path) {
+  try {
+    const raw = JSON.parse(await readFile(path, "utf8"));
+    if (raw.version !== SESSION_REGISTRY_VERSION || typeof raw.pid !== "number" || typeof raw.sessionId !== "string" || !raw.sessionId || !raw.metadata || typeof raw.metadata !== "object") {
+      logger.debug(`[SESSION REGISTRY] Invalid entry schema at ${path}, pruning`);
+      await removeRegistryEntryPath(path);
+      return null;
+    }
+    return {
+      version: SESSION_REGISTRY_VERSION,
+      pid: raw.pid,
+      sessionId: raw.sessionId,
+      metadata: normalizeMetadataForPid(raw.metadata, raw.pid),
+      updatedAt: typeof raw.updatedAt === "number" ? raw.updatedAt : Date.now()
+    };
+  } catch (error) {
+    logger.debug(`[SESSION REGISTRY] Failed to read ${path}, pruning`, error);
+    await removeRegistryEntryPath(path);
+    return null;
+  }
+}
+async function resolveLiveHappySessionPids(listLiveHappyProcesses) {
+  try {
+    const liveHappyProcesses = await listLiveHappyProcesses();
+    if (liveHappyProcesses.length === 0) {
+      return null;
+    }
+    const liveSessionProcesses = liveHappyProcesses.filter((proc) => !NON_SESSION_PROCESS_TYPES.has(proc.type));
+    if (liveSessionProcesses.length === 0) {
+      logger.debug(
+        "[SESSION REGISTRY] Process discovery did not report any session processes, falling back to PID checks"
+      );
+      return null;
+    }
+    return new Set(
+      liveSessionProcesses.map((proc) => proc.pid)
+    );
+  } catch (error) {
+    logger.debug("[SESSION REGISTRY] Failed to list live Happy processes, falling back to PID checks", error);
+    return null;
+  }
+}
+async function persistLocalSessionRegistration(sessionId, metadata) {
+  const pid = metadata.hostPid ?? process.pid;
+  const normalizedMetadata = normalizeMetadataForPid(metadata, pid);
+  await ensureSessionRegistryDir();
+  await atomicFileWrite(
+    getSessionRegistryEntryPath(pid),
+    JSON.stringify({
+      version: SESSION_REGISTRY_VERSION,
+      pid,
+      sessionId,
+      metadata: normalizedMetadata,
+      updatedAt: Date.now()
+    }, null, 2)
+  );
+}
+async function publishSessionRegistration(sessionId, metadata) {
+  const pid = metadata.hostPid ?? process.pid;
+  try {
+    await persistLocalSessionRegistration(sessionId, metadata);
+    installRegistryCleanup(pid);
+  } catch (error) {
+    logger.debug(`[SESSION REGISTRY] Failed to persist local registration for session ${sessionId}`, error);
+  }
+  try {
+    const result = await notifyDaemonSessionStarted(sessionId, normalizeMetadataForPid(metadata, pid));
+    if (result?.error) {
+      logger.debug(`[SESSION REGISTRY] Failed to report session ${sessionId} to daemon`, result.error);
+    }
+  } catch (error) {
+    logger.debug(`[SESSION REGISTRY] Failed to report session ${sessionId} to daemon`, error);
+  }
+}
+async function recoverTrackedSessionsFromLocalRegistry({
+  trackedSessionPids,
+  trackSession,
+  listLiveHappyProcesses = findAllHappyProcesses,
+  lookupHappyProcessByPid = findHappyProcessByPid
+}) {
+  const registryDir = getSessionRegistryDir();
+  if (!existsSync(registryDir)) {
+    return { recoveredCount: 0, removedStaleCount: 0 };
+  }
+  const alreadyTracked = new Set(trackedSessionPids);
+  const liveHappySessionPids = await resolveLiveHappySessionPids(listLiveHappyProcesses);
+  let recoveredCount = 0;
+  let removedStaleCount = 0;
+  for (const entryFile of await readdir(registryDir)) {
+    if (!entryFile.endsWith(".json")) {
+      continue;
+    }
+    const entryPath = join(registryDir, entryFile);
+    const entry = await readRegistryEntry(entryPath);
+    if (!entry) {
+      continue;
+    }
+    let lookupResult;
+    try {
+      lookupResult = liveHappySessionPids?.has(entry.pid) ? { pid: entry.pid, type: "known-session" } : await lookupHappyProcessByPid(entry.pid);
+    } catch (error) {
+      logger.debug(
+        `[SESSION REGISTRY] Failed to inspect PID ${entry.pid}, keeping registry entry until next recovery tick`,
+        error
+      );
+      lookupResult = "indeterminate";
+    }
+    const sessionPidIsAlive = lookupResult !== null && lookupResult !== "indeterminate" && !NON_SESSION_PROCESS_TYPES.has(lookupResult.type);
+    const shouldKeepEntryWithoutRecovery = lookupResult === "indeterminate";
+    if (shouldKeepEntryWithoutRecovery) {
+      logger.debug(
+        `[SESSION REGISTRY] Keeping registry entry for PID ${entry.pid} because process identity is indeterminate`
+      );
+      continue;
+    }
+    if (!sessionPidIsAlive) {
+      if (await removeRegistryEntryPath(entryPath)) {
+        removedStaleCount++;
+      }
+      continue;
+    }
+    if (alreadyTracked.has(entry.pid)) {
+      continue;
+    }
+    trackSession(entry.pid, createTrackedSessionFromRegistryEntry(entry));
+    alreadyTracked.add(entry.pid);
+    recoveredCount++;
+    logger.debug(`[SESSION REGISTRY] Recovered tracked session ${entry.sessionId} for PID ${entry.pid}`);
+  }
+  return { recoveredCount, removedStaleCount };
+}
+
 const initialMachineMetadata = {
   host: os.hostname(),
   platform: os.platform(),
@@ -2476,14 +2867,12 @@ async function startDaemon() {
             errorMessage: spawnError.errorMessage
           };
         }
-        const tmuxAvailable = await isTmuxAvailable();
-        let useTmux = tmuxAvailable;
         let tmuxSessionName = extraEnv.TMUX_SESSION_NAME;
-        if (!tmuxAvailable || tmuxSessionName === void 0) {
-          useTmux = false;
-          if (tmuxSessionName !== void 0) {
-            logger.debug(`[DAEMON RUN] tmux session name specified but tmux not available, falling back to regular spawning`);
-          }
+        const tmuxRequested = tmuxSessionName !== void 0;
+        const tmuxAvailable = tmuxRequested ? await isTmuxAvailable() : false;
+        let useTmux = tmuxRequested && tmuxAvailable;
+        if (tmuxRequested && !tmuxAvailable) {
+          logger.debug(`[DAEMON RUN] tmux session name specified but tmux not available, falling back to regular spawning`);
         }
         if (useTmux && tmuxSessionName !== void 0) {
           const sessionDesc = tmuxSessionName || "current/most recent session";
@@ -2688,6 +3077,17 @@ async function startDaemon() {
       onHappySessionWebhook,
       port: HAPPY_CLOUD_DAEMON_PORT
     });
+    const recoveryResult = await recoverTrackedSessionsFromLocalRegistry({
+      trackedSessionPids: pidToTrackedSession.keys(),
+      trackSession: (pid, trackedSession) => {
+        pidToTrackedSession.set(pid, trackedSession);
+      }
+    });
+    if (recoveryResult.recoveredCount > 0 || recoveryResult.removedStaleCount > 0) {
+      logger.debug(
+        `[DAEMON RUN] Session registry recovery completed: recovered=${recoveryResult.recoveredCount}, removedStale=${recoveryResult.removedStaleCount}`
+      );
+    }
     const fileState = {
       pid: process.pid,
       httpPort: controlPort,
@@ -2727,52 +3127,69 @@ async function startDaemon() {
       if (process.env.DEBUG) {
         logger.debug(`[DAEMON RUN] Health check started at ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
       }
-      for (const [pid, _] of pidToTrackedSession.entries()) {
-        try {
-          process.kill(pid, 0);
-        } catch (error) {
-          logger.debug(`[DAEMON RUN] Removing stale session with PID ${pid} (process no longer exists)`);
-          pidToTrackedSession.delete(pid);
-        }
-      }
-      const projectVersion = JSON.parse(readFileSync$1(join$1(projectPath(), "package.json"), "utf-8")).version;
-      if (projectVersion !== configuration.currentCliVersion) {
-        logger.debug("[DAEMON RUN] Daemon is outdated, triggering self-restart with latest version, clearing heartbeat interval");
-        clearInterval(restartOnStaleVersionAndHeartbeat);
-        try {
-          spawnHappyCLI(["daemon", "start"], {
-            detached: true,
-            stdio: "ignore"
-          });
-        } catch (error) {
-          logger.debug("[DAEMON RUN] Failed to spawn new daemon, this is quite likely to happen during integration tests as we are cleaning out dist/ directory", error);
-        }
-        logger.debug("[DAEMON RUN] Hanging for a bit - waiting for CLI to kill us because we are running outdated version of the code");
-        await new Promise((resolve) => setTimeout(resolve, 1e4));
-        process.exit(0);
-      }
-      const daemonState = await readDaemonState();
-      if (daemonState && daemonState.pid !== process.pid) {
-        logger.debug("[DAEMON RUN] Somehow a different daemon was started without killing us. We should kill ourselves.");
-        requestShutdown("exception", "A different daemon was started without killing us. We should kill ourselves.");
-      }
       try {
-        const updatedState = {
-          pid: process.pid,
-          httpPort: controlPort,
-          startTime: fileState.startTime,
-          startedWithCliVersion: packageJson.version,
-          lastHeartbeat: (/* @__PURE__ */ new Date()).toLocaleString(),
-          daemonLogPath: fileState.daemonLogPath
-        };
-        writeDaemonState(updatedState);
-        if (process.env.DEBUG) {
-          logger.debug(`[DAEMON RUN] Health check completed at ${updatedState.lastHeartbeat}`);
+        const recoveryResult2 = await recoverTrackedSessionsFromLocalRegistry({
+          trackedSessionPids: pidToTrackedSession.keys(),
+          trackSession: (pid, trackedSession) => {
+            pidToTrackedSession.set(pid, trackedSession);
+          }
+        });
+        if (recoveryResult2.recoveredCount > 0 || recoveryResult2.removedStaleCount > 0) {
+          logger.debug(
+            `[DAEMON RUN] Session registry recovery tick completed: recovered=${recoveryResult2.recoveredCount}, removedStale=${recoveryResult2.removedStaleCount}`
+          );
         }
+        await runDaemonHealthCheck({
+          trackedSessionPids: pidToTrackedSession.keys(),
+          removeTrackedSession: (pid) => {
+            pidToTrackedSession.delete(pid);
+          },
+          currentCliVersion: configuration.currentCliVersion,
+          onDaemonOutdated: async () => {
+            logger.debug("[DAEMON RUN] Daemon is outdated, triggering self-restart with latest version, clearing heartbeat interval");
+            clearInterval(restartOnStaleVersionAndHeartbeat);
+            try {
+              spawnHappyCLI(["daemon", "start"], {
+                detached: true,
+                stdio: "ignore"
+              });
+            } catch (error) {
+              logger.debug("[DAEMON RUN] Failed to spawn new daemon, this is quite likely to happen during integration tests as we are cleaning out dist/ directory", error);
+            }
+            logger.debug("[DAEMON RUN] Hanging for a bit - waiting for CLI to kill us because we are running outdated version of the code");
+            await new Promise((resolve) => setTimeout(resolve, 1e4));
+            process.exit(0);
+          },
+          readDaemonState,
+          daemonPid: process.pid,
+          requestShutdown,
+          writeHeartbeat: async () => {
+            try {
+              const updatedState = {
+                pid: process.pid,
+                httpPort: controlPort,
+                startTime: fileState.startTime,
+                startedWithCliVersion: packageJson.version,
+                lastHeartbeat: (/* @__PURE__ */ new Date()).toLocaleString(),
+                daemonLogPath: fileState.daemonLogPath
+              };
+              writeDaemonState(updatedState);
+              if (process.env.DEBUG) {
+                logger.debug(`[DAEMON RUN] Health check completed at ${updatedState.lastHeartbeat}`);
+              }
+            } catch (error) {
+              logger.debug("[DAEMON RUN] Failed to write heartbeat", error);
+            }
+          }
+        });
       } catch (error) {
-        logger.debug("[DAEMON RUN] Failed to write heartbeat", error);
+        logger.warn(
+          "[DAEMON RUN] Health check failed; keeping daemon alive until the next tick",
+          error instanceof Error ? error.message : String(error)
+        );
+      } finally {
+        heartbeatRunning = false;
       }
-      heartbeatRunning = false;
     }, heartbeatIntervalMs);
     const cleanupAndShutdown = async (source, errorMessage) => {
       logger.debug(`[DAEMON RUN] Starting proper cleanup (source: ${source}, errorMessage: ${errorMessage})...`);
@@ -2909,7 +3326,7 @@ async function uninstall$1() {
     } catch (error) {
       logger.info("Failed to unload daemon (it might not be running)");
     }
-    unlinkSync(PLIST_FILE);
+    unlinkSync$1(PLIST_FILE);
     logger.info(`Removed daemon plist from ${PLIST_FILE}`);
     logger.info("Daemon uninstalled successfully");
   } catch (error) {
@@ -3085,9 +3502,11 @@ async function handleAuthStatus() {
   console.log(chalk.gray(`
   Data directory: ${configuration.happyCloudHomeDir}`));
   try {
-    const running = await checkIfDaemonRunningAndCleanupStaleState();
-    if (running) {
+    const daemonStatus = await getDaemonRuntimeStatus();
+    if (daemonStatus === "running") {
       console.log(chalk.green("\u2713 Daemon running"));
+    } else if (daemonStatus === "indeterminate") {
+      console.log(chalk.yellow("\u26A0\uFE0F  Daemon status indeterminate"));
     } else {
       console.log(chalk.gray("\u2717 Daemon not running"));
     }
@@ -6668,6 +7087,189 @@ function validateCodexAcpSpawn(options = {}) {
   return { ok: true, spawn };
 }
 
+function firstExistingPath(candidates) {
+  for (const candidate of candidates) {
+    try {
+      if (fs$1.existsSync(candidate)) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveCodexExecutable() {
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || path.join(os$1.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 getCodexPlatformTarget(platform, arch) {
+  if (platform === "win32" && arch === "x64") {
+    return {
+      packageName: "codex-win32-x64",
+      targetTriple: "x86_64-pc-windows-msvc"
+    };
+  }
+  if (platform === "win32" && arch === "arm64") {
+    return {
+      packageName: "codex-win32-arm64",
+      targetTriple: "aarch64-pc-windows-msvc"
+    };
+  }
+  if ((platform === "linux" || platform === "android") && arch === "x64") {
+    return {
+      packageName: "codex-linux-x64",
+      targetTriple: "x86_64-unknown-linux-musl"
+    };
+  }
+  if ((platform === "linux" || platform === "android") && arch === "arm64") {
+    return {
+      packageName: "codex-linux-arm64",
+      targetTriple: "aarch64-unknown-linux-musl"
+    };
+  }
+  if (platform === "darwin" && arch === "x64") {
+    return {
+      packageName: "codex-darwin-x64",
+      targetTriple: "x86_64-apple-darwin"
+    };
+  }
+  if (platform === "darwin" && arch === "arm64") {
+    return {
+      packageName: "codex-darwin-arm64",
+      targetTriple: "aarch64-apple-darwin"
+    };
+  }
+  return null;
+}
+function dedupePaths(paths, platform) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const entry of paths) {
+    const normalized = normalize(entry);
+    const key = platform === "win32" ? normalized.toLowerCase() : normalized;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    unique.push(entry);
+  }
+  return unique;
+}
+function resolveCodexShimPath({
+  platform = process.platform,
+  exists = existsSync,
+  resolveExecutable = resolveCodexExecutable,
+  resolveOnPath = resolveCommandOnPath
+}) {
+  const resolvedExecutable = resolveExecutable();
+  if (isAbsolute(resolvedExecutable) && exists(resolvedExecutable)) {
+    return resolvedExecutable;
+  }
+  const commandNames = platform === "win32" ? ["codex.cmd", "codex.ps1", "codex"] : ["codex"];
+  for (const commandName of commandNames) {
+    const resolved = resolveOnPath(commandName);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return null;
+}
+function resolveCodexPackageRoots(executablePath, {
+  platform = process.platform,
+  exists = existsSync,
+  realpath = realpathSync
+}) {
+  const executableDir = dirname$1(executablePath);
+  const candidates = [
+    join(executableDir, "node_modules", "@openai", "codex"),
+    join(executableDir, "..", "lib", "node_modules", "@openai", "codex")
+  ];
+  try {
+    const realExecutablePath = realpath(executablePath);
+    candidates.push(join(dirname$1(realExecutablePath), ".."));
+  } catch {
+  }
+  return dedupePaths(
+    candidates.filter((candidate) => exists(candidate)),
+    platform
+  );
+}
+function resolvePathEnvKey(env) {
+  return Object.prototype.hasOwnProperty.call(env, "Path") && !Object.prototype.hasOwnProperty.call(env, "PATH") ? "Path" : "PATH";
+}
+function resolveBundledCodexToolPathDirs(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const codexTarget = getCodexPlatformTarget(platform, arch);
+  if (!codexTarget) {
+    return [];
+  }
+  const codexShimPath = resolveCodexShimPath(options);
+  if (!codexShimPath) {
+    return [];
+  }
+  const packageRoots = resolveCodexPackageRoots(codexShimPath, options);
+  if (packageRoots.length === 0) {
+    return [];
+  }
+  const exists = options.exists ?? existsSync;
+  const candidates = packageRoots.flatMap((packageRoot) => [
+    join(packageRoot, "vendor", codexTarget.targetTriple, "path"),
+    join(
+      packageRoot,
+      "node_modules",
+      "@openai",
+      codexTarget.packageName,
+      "vendor",
+      codexTarget.targetTriple,
+      "path"
+    )
+  ]);
+  return dedupePaths(
+    candidates.filter((candidate) => exists(candidate)),
+    platform
+  );
+}
+function buildCodexAcpEnv(overrides = {}, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const env = {
+    ...process.env,
+    ...overrides
+  };
+  const pathKey = resolvePathEnvKey(env);
+  const alternatePathKey = pathKey === "PATH" ? "Path" : "PATH";
+  const currentPathValue = env[pathKey] ?? env[alternatePathKey] ?? "";
+  const currentPathEntries = currentPathValue.split(delimiter).filter(Boolean);
+  const codexToolDirs = resolveBundledCodexToolPathDirs(options);
+  const mergedPathEntries = dedupePaths(
+    [...codexToolDirs, ...currentPathEntries],
+    platform
+  );
+  if (mergedPathEntries.length > 0) {
+    env[pathKey] = mergedPathEntries.join(delimiter);
+  }
+  delete env[alternatePathKey];
+  const stringEnvEntries = [];
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value === "string") {
+      stringEnvEntries.push([key, value]);
+    }
+  }
+  return Object.fromEntries(stringEnvEntries);
+}
+
 class CodexAcpTransport extends CodexTransport {
   constructor(initTimeoutMs) {
     super();
@@ -6697,10 +7299,10 @@ function createCodexBackend(options) {
     cwd: options.cwd,
     command: spawn.command,
     args: spawn.args,
-    env: {
+    env: buildCodexAcpEnv({
       ...options.env,
       NODE_ENV: "production"
-    },
+    }),
     permissionHandler: options.permissionHandler,
     selectionHandler: options.selectionHandler,
     transportHandler: resolveCodexTransport(spawn.command)
@@ -6850,6 +7452,24 @@ function createDefaultRuntimeShell() {
   return new RuntimeShell();
 }
 
+const DAEMON_STARTUP_TIMEOUT_MS = 3e4;
+const DAEMON_STARTUP_POLL_INTERVAL_MS = 250;
+async function waitForDaemonReady(timeoutMs = DAEMON_STARTUP_TIMEOUT_MS, pollIntervalMs = DAEMON_STARTUP_POLL_INTERVAL_MS) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const remainingMs = deadline - Date.now();
+    if (await isDaemonRunningCurrentlyInstalledHappyVersion(Math.max(1, remainingMs))) {
+      return true;
+    }
+    const sleepMs = Math.min(pollIntervalMs, deadline - Date.now());
+    if (sleepMs <= 0) {
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, sleepMs));
+  }
+  return false;
+}
+
 function isRuntimeProvider(value) {
   return value === "claude" || value === "codex" || value === "gemini" || value === "cursor";
 }
@@ -6894,26 +7514,20 @@ async function ensureUnifiedDaemonStarted() {
     env: process.env
   });
   daemonProcess.unref();
-  for (let i = 0; i < 100; i++) {
-    if (await isDaemonRunningCurrentlyInstalledHappyVersion()) {
-      return;
-    }
-    if (await isDaemonControlServerResponsive(500)) {
-      return;
-    }
-    await new Promise((resolve) => setTimeout(resolve, 100));
+  if (await waitForDaemonReady()) {
+    return;
   }
   throw new Error("Failed to start Happy background service.");
 }
 async function executeUnifiedProvider(opts) {
   const credentials = await ensureUnifiedRuntimePrerequisites(opts.credentials);
   if (opts.provider === "claude") {
-    const { runClaude } = await import('./runClaude-DAR_hw3C.mjs');
+    const { runClaude } = await import('./runClaude-B_fTMxc4.mjs');
     await runClaude(credentials, opts.claudeOptions ?? {});
     return;
   }
   if (opts.provider === "codex") {
-    const { runCodex } = await import('./runCodex-B4QAb-Go.mjs');
+    const { runCodex } = await import('./runCodex-CUgOiIEz.mjs');
     await runCodex({
       credentials,
       startedBy: opts.startedBy,
@@ -6923,7 +7537,7 @@ async function executeUnifiedProvider(opts) {
     return;
   }
   if (opts.provider === "gemini") {
-    const { runGemini } = await import('./runGemini-DqowSR2w.mjs');
+    const { runGemini } = await import('./runGemini-2_FEtJYa.mjs');
     await runGemini({
       credentials,
       startedBy: opts.startedBy
@@ -6965,7 +7579,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await import('./command-DGFsZx58.mjs');
+      const { renderRuntimeProviders } = await import('./command-ComOeFLY.mjs');
       console.log(renderRuntimeProviders());
       return;
     }
@@ -7143,8 +7757,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await import('./persistence-DiNg1DPF.mjs');
-        const { ApiClient: ApiClient2 } = await import('./api-D-uiH_TF.mjs').then(function (n) { return n.q; });
+        const { readCredentials: readCredentials2 } = await import('./persistence-BxP6Jw1f.mjs');
+        const { ApiClient: ApiClient2 } = await import('./api-BjxmW-0W.mjs').then(function (n) { return n.q; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();
@@ -7291,14 +7905,7 @@ function shouldRunMainClaudeFlow(opts) {
         env: process.env
       });
       child.unref();
-      let started = false;
-      for (let i = 0; i < 100; i++) {
-        if (await checkIfDaemonRunningAndCleanupStaleState() && await isDaemonControlServerResponsive(500)) {
-          started = true;
-          break;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 100));
-      }
+      const started = await waitForDaemonReady();
       if (started) {
         console.log("Daemon started successfully");
       } else {
@@ -7567,4 +8174,4 @@ ${chalk.bold("Examples:")}
   }
 }
 
-export { ExitCodeError as E, GEMINI_MODEL_ENV as G, createGeminiBackend as a, stopCaffeinate as b, createDefaultRuntimeShell as c, createCodexBackend as d, getProjectPath as e, formatDisplayMessage as f, getInitialGeminiModel as g, claudeLocal as h, initialMachineMetadata as i, isBun as j, trimIdent as k, claudeCheckSession as l, getEnvironmentInfo as m, notifyDaemonSessionStarted as n, startCaffeinate as o, projectPath as p, readGeminiLocalConfig as r, saveGeminiModelToConfig as s, truncateDisplayMessage as t, validateCodexAcpSpawn as v };
+export { ExitCodeError as E, GEMINI_MODEL_ENV as G, createGeminiBackend as a, stopCaffeinate as b, createDefaultRuntimeShell as c, projectPath as d, createCodexBackend as e, formatDisplayMessage as f, getInitialGeminiModel as g, getProjectPath as h, initialMachineMetadata as i, claudeLocal as j, isBun as k, trimIdent as l, claudeCheckSession as m, getEnvironmentInfo as n, startCaffeinate as o, publishSessionRegistration as p, readGeminiLocalConfig as r, saveGeminiModelToConfig as s, truncateDisplayMessage as t, validateCodexAcpSpawn as v };