happy-imou-cloud 2.0.8 → 2.0.10

package/dist/{index-DM6z3aeG.cjs → index-Cuvfa15L.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
 var chalk = require('chalk');
-var api = require('./api-CN-WqYd_.cjs');
-var persistence = require('./persistence-DBGkO8gB.cjs');
+var api = require('./api-DUE5TJBE.cjs');
+var persistence = require('./persistence-D7JtnrYA.cjs');
 var z = require('zod');
-var fs$1 = require('fs/promises');
+var fs$2 = require('fs/promises');
 var os$1 = require('os');
 var tmp = require('tmp');
 var node_crypto = require('node:crypto');
@@ -14,23 +14,23 @@ var qrcode = require('qrcode-terminal');
 var promises = require('node:fs/promises');
 var node_module = require('node:module');
 var os = require('node:os');
-var node_path = require('node:path');
+var path = require('node:path');
 var open = require('open');
 var React = require('react');
 var ink = require('ink');
 var child_process = require('child_process');
-var path = require('path');
+var path$1 = require('path');
 var url = require('url');
-var fs = require('fs');
+var fs$1 = require('fs');
 var node_child_process = require('node:child_process');
 var psList = require('ps-list');
 var spawn = require('cross-spawn');
-var node_fs = require('node:fs');
+var fs = require('node:fs');
 var fastify = require('fastify');
 var fastifyTypeProviderZod = require('fastify-type-provider-zod');
+var crypto = require('crypto');
 var node_readline = require('node:readline');
 var http = require('http');
-var crypto = require('crypto');
 var util = require('util');
 var sdk = require('@agentclientprotocol/sdk');
 
@@ -70,7 +70,7 @@ async function openBrowser(url) {
   }
 }
 
-const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DM6z3aeG.cjs', document.baseURI).href)));
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-Cuvfa15L.cjs', document.baseURI).href)));
 const QRCode = require$1("qrcode-terminal/vendor/QRCode");
 const QRErrorCorrectLevel = require$1("qrcode-terminal/vendor/QRCode/QRErrorCorrectLevel");
 const pendingTempFiles = /* @__PURE__ */ new Set();
@@ -164,7 +164,7 @@ async function openWindowsQrCode(value) {
       "</body>",
       "</html>"
     ].join("");
-    const filePath = node_path.join(os.tmpdir(), `happy-auth-qrcode-${node_crypto.randomUUID()}.html`);
+    const filePath = path.join(os.tmpdir(), `happy-auth-qrcode-${node_crypto.randomUUID()}.html`);
     await promises.writeFile(filePath, html, "utf8");
     const opened = await openBrowser(filePath);
     if (opened) {
@@ -693,18 +693,28 @@ function setupCleanupHandlers() {
   });
 }
 
-const __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DM6z3aeG.cjs', document.baseURI).href))));
+const __dirname$1 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-Cuvfa15L.cjs', document.baseURI).href))));
 function projectPath() {
-  const path$1 = path.resolve(__dirname$1, "..");
-  return path$1;
+  const path = path$1.resolve(__dirname$1, "..");
+  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 (!node_fs.existsSync(api.configuration.daemonStateFile)) {
+    if (!fs.existsSync(api.configuration.daemonStateFile)) {
       return null;
     }
-    const state = JSON.parse(node_fs.readFileSync(api.configuration.daemonStateFile, "utf-8"));
+    const state = JSON.parse(fs.readFileSync(api.configuration.daemonStateFile, "utf-8"));
     return typeof state.pid === "number" ? state.pid : null;
   } catch {
     return null;
@@ -779,7 +789,7 @@ function findWindowsDaemonProcess(processes) {
   return {
     pid: daemonPid,
     command: `${daemonProcess.name || "unknown"} (PID ${daemonPid})`,
-    type: "daemon"
+    type: "daemon-indeterminate"
   };
 }
 function findWindowsHappyProcesses(processes) {
@@ -796,6 +806,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") {
@@ -803,15 +847,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 = [];
@@ -868,6 +905,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 {
+    api.logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
+    await cleanupDaemonState();
+    return "stale";
+  }
+  const processInfo = await findHappyProcessByPid(state.pid);
+  if (processInfo === "indeterminate") {
+    api.logger.debug(`[DAEMON RUN] Daemon PID ${state.pid} is alive but process identity is indeterminate`);
+    return "indeterminate";
+  }
+  if (!processInfo) {
+    api.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)) {
+    api.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 persistence.readDaemonState();
   if (!state?.httpPort) {
@@ -877,9 +954,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";
     api.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
     return {
@@ -978,18 +1054,22 @@ async function stopDaemonHttp() {
   await daemonPost("/stop");
 }
 async function checkIfDaemonRunningAndCleanupStaleState() {
+  const runtimeStatus = await getDaemonRuntimeStatus();
+  return runtimeStatus !== "not-running";
+}
+async function getDaemonRuntimeStatus() {
   const state = await persistence.readDaemonState();
   if (!state) {
-    return false;
+    return "not-running";
   }
-  try {
-    process.kill(state.pid, 0);
-    return true;
-  } catch {
-    api.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 persistence.readDaemonState();
@@ -997,11 +1077,9 @@ async function isDaemonControlServerResponsive(timeoutMs = 1e3) {
     api.logger.debug("[DAEMON CONTROL] No daemon state or control port found for readiness check");
     return false;
   }
-  try {
-    process.kill(state.pid, 0);
-  } catch {
-    api.logger.debug("[DAEMON CONTROL] Daemon PID not running during readiness check, cleaning up state");
-    await cleanupDaemonState();
+  const processStatus = await inspectDaemonStateProcess(state);
+  if (processStatus === "stale") {
+    api.logger.debug("[DAEMON CONTROL] Daemon state became stale during readiness check");
     return false;
   }
   try {
@@ -1017,7 +1095,7 @@ async function isDaemonControlServerResponsive(timeoutMs = 1e3) {
     return false;
   }
 }
-async function isDaemonRunningCurrentlyInstalledHappyVersion() {
+async function isDaemonRunningCurrentlyInstalledHappyVersion(readinessProbeTimeoutMs = 1e3) {
   api.logger.debug("[DAEMON CONTROL] Checking if daemon is running same version");
   const runningDaemon = await checkIfDaemonRunningAndCleanupStaleState();
   if (!runningDaemon) {
@@ -1030,14 +1108,14 @@ async function isDaemonRunningCurrentlyInstalledHappyVersion() {
     return false;
   }
   try {
-    const packageJsonPath = path.join(projectPath(), "package.json");
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    const packageJsonPath = path$1.join(projectPath(), "package.json");
+    const packageJson = JSON.parse(fs$1.readFileSync(packageJsonPath, "utf-8"));
     const currentCliVersion = packageJson.version;
     api.logger.debug(`[DAEMON CONTROL] Current CLI version: ${currentCliVersion}, Daemon started with version: ${state.startedWithCliVersion}`);
     if (currentCliVersion !== state.startedWithCliVersion) {
       return false;
     }
-    return await isDaemonControlServerResponsive();
+    return await isDaemonControlServerResponsive(readinessProbeTimeoutMs);
   } catch (error) {
     api.logger.debug("[DAEMON CONTROL] Error checking daemon version", error);
     return false;
@@ -1070,6 +1148,17 @@ async function stopDaemon() {
       return;
     }
     api.logger.debug(`Stopping daemon with PID ${state.pid}`);
+    const processStatus = await inspectDaemonStateProcess(state);
+    if (processStatus === "stale") {
+      api.logger.debug("Daemon state was stale while stopping, trying known control port/orphan cleanup");
+      const stoppedByKnownPort = await stopDaemonOnKnownPort();
+      if (stoppedByKnownPort) {
+        api.logger.debug(`Requested daemon stop via known control port ${api.HAPPY_CLOUD_DAEMON_PORT}`);
+        return;
+      }
+      await killOrphanDaemonProcesses();
+      return;
+    }
     try {
       await stopDaemonHttp();
       await waitForProcessDeath(state.pid, 2e3);
@@ -1079,6 +1168,10 @@ async function stopDaemon() {
     } catch (error) {
       api.logger.debug("HTTP stop failed, will force kill", error);
     }
+    if (processStatus === "indeterminate") {
+      api.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(() => {
@@ -1130,15 +1223,30 @@ function getEnvironmentInfo() {
     terminal: process.env.TERM
   };
 }
+function resolveDaemonSpawnDiagnostics(projectRoot, fileExists = fs.existsSync) {
+  const wrapperCandidates = [
+    path.join(projectRoot, "bin", "happy-cloud.mjs"),
+    path.join(projectRoot, "bin", "happy.mjs")
+  ];
+  const cliEntrypoint = path.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 (!node_fs.existsSync(logDir)) {
+  if (!fs.existsSync(logDir)) {
     return [];
   }
   try {
-    return node_fs.readdirSync(logDir).filter((file) => file.endsWith(".log")).map((file) => {
-      const path = node_path.join(logDir, file);
-      const stats = node_fs.statSync(path);
-      return { file, path, modified: stats.mtime };
+    return fs.readdirSync(logDir).filter((file) => file.endsWith(".log")).map((file) => {
+      const path$1 = path.join(logDir, file);
+      const stats = fs.statSync(path$1);
+      return { file, path: path$1, modified: stats.mtime };
     }).sort((a, b) => b.modified.getTime() - a.modified.getTime());
   } catch {
     return [];
@@ -1156,14 +1264,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 = node_path.join(projectRoot, "bin", "happy.mjs");
-    const cliEntrypoint = node_path.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: ${node_fs.existsSync(wrapperPath) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
-    console.log(`CLI Exists: ${node_fs.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(api.configuration.happyCloudHomeDir)}`);
@@ -1199,9 +1305,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 persistence.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()}`);
@@ -1209,7 +1315,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"));
@@ -1231,6 +1344,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",
@@ -1245,7 +1359,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)}`);
         });
       });
@@ -1329,7 +1443,7 @@ const isBun = () => getRuntime() === "bun";
 
 function spawnHappyCLI(args, options = {}) {
   const projectRoot = projectPath();
-  const entrypoint = node_path.join(projectRoot, "dist", "index.mjs");
+  const entrypoint = path.join(projectRoot, "dist", "index.mjs");
   let directory;
   if ("cwd" in options) {
     directory = options.cwd;
@@ -1344,7 +1458,7 @@ function spawnHappyCLI(args, options = {}) {
     entrypoint,
     ...args
   ];
-  if (!node_fs.existsSync(entrypoint)) {
+  if (!fs.existsSync(entrypoint)) {
     const errorMessage = `Entrypoint ${entrypoint} does not exist`;
     api.logger.debug(`[SPAWN HAPPY CLOUD CLI] ${errorMessage}`);
     throw new Error(errorMessage);
@@ -2275,6 +2389,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 = path.join(projectPath(), "package.json");
+  try {
+    const parsedPackageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    if (typeof parsedPackageJson.version !== "string" || parsedPackageJson.version.trim().length === 0) {
+      api.logger.warn(
+        `[DAEMON RUN] Skipping daemon version check because ${packageJsonPath} does not contain a valid string version`
+      );
+      return null;
+    }
+    return parsedPackageJson.version;
+  } catch (error) {
+    api.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 {
+      api.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) {
+    api.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}.${crypto.randomUUID()}.tmp`;
+  try {
+    await fs$2.writeFile(tmpFile, content);
+    await fs$2.rename(tmpFile, filePath);
+  } catch (error) {
+    try {
+      await fs$2.unlink(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 path.join(api.configuration.happyCloudHomeDir, SESSION_REGISTRY_DIRNAME);
+}
+function getSessionRegistryEntryPath(pid) {
+  return path.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 promises.mkdir(getSessionRegistryDir(), { recursive: true });
+}
+async function removeRegistryEntryPath(path) {
+  try {
+    await promises.unlink(path);
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return false;
+    }
+    api.logger.debug(`[SESSION REGISTRY] Failed to remove ${path}`, error);
+    return false;
+  }
+}
+function removeRegistryEntryPathSync(path) {
+  try {
+    fs.unlinkSync(path);
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      api.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 promises.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") {
+      api.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) {
+    api.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) {
+      api.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) {
+    api.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) {
+    api.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) {
+      api.logger.debug(`[SESSION REGISTRY] Failed to report session ${sessionId} to daemon`, result.error);
+    }
+  } catch (error) {
+    api.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 (!fs.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 promises.readdir(registryDir)) {
+    if (!entryFile.endsWith(".json")) {
+      continue;
+    }
+    const entryPath = path.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) {
+      api.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) {
+      api.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++;
+    api.logger.debug(`[SESSION REGISTRY] Recovered tracked session ${entry.sessionId} for PID ${entry.pid}`);
+  }
+  return { recoveredCount, removedStaleCount };
+}
+
 const initialMachineMetadata = {
   host: os$1.hostname(),
   platform: os$1.platform(),
@@ -2404,7 +2795,7 @@ async function startDaemon() {
       const { directory, sessionId, machineId: machineId2, approvedNewDirectoryCreation = true } = options;
       let directoryCreated = false;
       try {
-        await fs$1.access(directory);
+        await fs$2.access(directory);
         api.logger.debug(`[DAEMON RUN] Directory exists: ${directory}`);
       } catch (error) {
         api.logger.debug(`[DAEMON RUN] Directory doesn't exist, creating: ${directory}`);
@@ -2416,7 +2807,7 @@ async function startDaemon() {
           };
         }
         try {
-          await fs$1.mkdir(directory, { recursive: true });
+          await fs$2.mkdir(directory, { recursive: true });
           api.logger.debug(`[DAEMON RUN] Successfully created directory: ${directory}`);
           directoryCreated = true;
         } catch (mkdirError) {
@@ -2445,7 +2836,7 @@ async function startDaemon() {
         if (options.token) {
           if (options.agent === "codex") {
             const codexHomeDir = tmp__namespace.dirSync();
-            fs$1.writeFile(path.join(codexHomeDir.name, "auth.json"), options.token);
+            fs$2.writeFile(path$1.join(codexHomeDir.name, "auth.json"), options.token);
             authEnv.CODEX_HOME = codexHomeDir.name;
           } else {
             authEnv.CLAUDE_CODE_OAUTH_TOKEN = options.token;
@@ -2498,20 +2889,18 @@ 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) {
-            api.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) {
+          api.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";
           api.logger.debug(`[DAEMON RUN] Attempting to spawn session in tmux: ${sessionDesc}`);
           const tmux = getTmuxUtilities(tmuxSessionName);
-          const cliPath = path.join(projectPath(), "dist", "index.mjs");
+          const cliPath = path$1.join(projectPath(), "dist", "index.mjs");
           const agent = resolveDaemonSpawnAgent(options.agent);
           const fullCommand = `node --no-warnings --no-deprecation ${cliPath} ${buildDaemonSpawnArgs(agent).join(" ")}`;
           const windowName = `happy-${Date.now()}-${agent}`;
@@ -2710,6 +3099,17 @@ async function startDaemon() {
       onHappySessionWebhook,
       port: api.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) {
+      api.logger.debug(
+        `[DAEMON RUN] Session registry recovery completed: recovered=${recoveryResult.recoveredCount}, removedStale=${recoveryResult.removedStaleCount}`
+      );
+    }
     const fileState = {
       pid: process.pid,
       httpPort: controlPort,
@@ -2749,52 +3149,69 @@ async function startDaemon() {
       if (process.env.DEBUG) {
         api.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) {
-          api.logger.debug(`[DAEMON RUN] Removing stale session with PID ${pid} (process no longer exists)`);
-          pidToTrackedSession.delete(pid);
-        }
-      }
-      const projectVersion = JSON.parse(fs.readFileSync(path.join(projectPath(), "package.json"), "utf-8")).version;
-      if (projectVersion !== api.configuration.currentCliVersion) {
-        api.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) {
-          api.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);
-        }
-        api.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 persistence.readDaemonState();
-      if (daemonState && daemonState.pid !== process.pid) {
-        api.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: api.packageJson.version,
-          lastHeartbeat: (/* @__PURE__ */ new Date()).toLocaleString(),
-          daemonLogPath: fileState.daemonLogPath
-        };
-        persistence.writeDaemonState(updatedState);
-        if (process.env.DEBUG) {
-          api.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) {
+          api.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: api.configuration.currentCliVersion,
+          onDaemonOutdated: async () => {
+            api.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) {
+              api.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);
+            }
+            api.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: persistence.readDaemonState,
+          daemonPid: process.pid,
+          requestShutdown,
+          writeHeartbeat: async () => {
+            try {
+              const updatedState = {
+                pid: process.pid,
+                httpPort: controlPort,
+                startTime: fileState.startTime,
+                startedWithCliVersion: api.packageJson.version,
+                lastHeartbeat: (/* @__PURE__ */ new Date()).toLocaleString(),
+                daemonLogPath: fileState.daemonLogPath
+              };
+              persistence.writeDaemonState(updatedState);
+              if (process.env.DEBUG) {
+                api.logger.debug(`[DAEMON RUN] Health check completed at ${updatedState.lastHeartbeat}`);
+              }
+            } catch (error) {
+              api.logger.debug("[DAEMON RUN] Failed to write heartbeat", error);
+            }
+          }
+        });
       } catch (error) {
-        api.logger.debug("[DAEMON RUN] Failed to write heartbeat", error);
+        api.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) => {
       api.logger.debug(`[DAEMON RUN] Starting proper cleanup (source: ${source}, errorMessage: ${errorMessage})...`);
@@ -2850,7 +3267,7 @@ const PLIST_LABEL$1 = "com.happy-cloud.daemon";
 const PLIST_FILE$1 = `/Library/LaunchDaemons/${PLIST_LABEL$1}.plist`;
 async function install$1() {
   try {
-    if (fs.existsSync(PLIST_FILE$1)) {
+    if (fs$1.existsSync(PLIST_FILE$1)) {
       api.logger.info("Daemon plist already exists. Uninstalling first...");
       child_process.execSync(`launchctl unload ${PLIST_FILE$1}`, { stdio: "inherit" });
     }
@@ -2894,8 +3311,8 @@ async function install$1() {
             </dict>
             </plist>
         `);
-    fs.writeFileSync(PLIST_FILE$1, plistContent);
-    fs.chmodSync(PLIST_FILE$1, 420);
+    fs$1.writeFileSync(PLIST_FILE$1, plistContent);
+    fs$1.chmodSync(PLIST_FILE$1, 420);
     api.logger.info(`Created daemon plist at ${PLIST_FILE$1}`);
     child_process.execSync(`launchctl load ${PLIST_FILE$1}`, { stdio: "inherit" });
     api.logger.info("Daemon installed and started successfully");
@@ -2921,7 +3338,7 @@ const PLIST_LABEL = "com.happy-cli.daemon";
 const PLIST_FILE = `/Library/LaunchDaemons/${PLIST_LABEL}.plist`;
 async function uninstall$1() {
   try {
-    if (!fs.existsSync(PLIST_FILE)) {
+    if (!fs$1.existsSync(PLIST_FILE)) {
       api.logger.info("Daemon plist not found. Nothing to uninstall.");
       return;
     }
@@ -2931,7 +3348,7 @@ async function uninstall$1() {
     } catch (error) {
       api.logger.info("Failed to unload daemon (it might not be running)");
     }
-    fs.unlinkSync(PLIST_FILE);
+    fs$1.unlinkSync(PLIST_FILE);
     api.logger.info(`Removed daemon plist from ${PLIST_FILE}`);
     api.logger.info("Daemon uninstalled successfully");
   } catch (error) {
@@ -3071,8 +3488,8 @@ async function handleAuthLogout(args = []) {
         console.log(chalk.gray("Stopped daemon"));
       } catch {
       }
-      if (node_fs.existsSync(happyDir)) {
-        node_fs.rmSync(happyDir, { recursive: true, force: true });
+      if (fs.existsSync(happyDir)) {
+        fs.rmSync(happyDir, { recursive: true, force: true });
       }
       console.log(chalk.green("\u2713 Successfully logged out"));
       console.log(chalk.gray('  Run "hicloud auth login" to authenticate again'));
@@ -3107,9 +3524,11 @@ async function handleAuthStatus() {
   console.log(chalk.gray(`
   Data directory: ${api.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"));
     }
@@ -3745,10 +4164,10 @@ async function handleConnectStatus() {
 }
 function updateLocalGeminiCredentials(tokens) {
   try {
-    const geminiDir = path.join(os$1.homedir(), ".gemini");
-    const credentialsPath = path.join(geminiDir, "oauth_creds.json");
-    if (!fs.existsSync(geminiDir)) {
-      fs.mkdirSync(geminiDir, { recursive: true });
+    const geminiDir = path$1.join(os$1.homedir(), ".gemini");
+    const credentialsPath = path$1.join(geminiDir, "oauth_creds.json");
+    if (!fs$1.existsSync(geminiDir)) {
+      fs$1.mkdirSync(geminiDir, { recursive: true });
     }
     const credentials = {
       access_token: tokens.access_token,
@@ -3758,7 +4177,7 @@ function updateLocalGeminiCredentials(tokens) {
       ...tokens.id_token && { id_token: tokens.id_token },
       ...tokens.expires_in && { expires_in: tokens.expires_in }
     };
-    fs.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), "utf-8");
+    fs$1.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), "utf-8");
     console.log(chalk.gray(`  Updated local credentials: ${credentialsPath}`));
   } catch (error) {
     console.log(chalk.yellow(`  \u26A0\uFE0F Could not update local credentials: ${error}`));
@@ -3766,22 +4185,22 @@ function updateLocalGeminiCredentials(tokens) {
 }
 
 function getProjectPath(workingDirectory, claudeConfigDirOverride) {
-  const projectId = node_path.resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+  const projectId = path.resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
   const claudeConfigDirRaw = process.env.CLAUDE_CONFIG_DIR ?? "";
   const claudeConfigDirTrimmed = claudeConfigDirRaw.trim();
-  const claudeConfigDir = claudeConfigDirTrimmed ? claudeConfigDirTrimmed : node_path.join(os.homedir(), ".claude");
-  return node_path.join(claudeConfigDir, "projects", projectId);
+  const claudeConfigDir = claudeConfigDirTrimmed ? claudeConfigDirTrimmed : path.join(os.homedir(), ".claude");
+  return path.join(claudeConfigDir, "projects", projectId);
 }
 
-function claudeCheckSession(sessionId, path, transcriptPath) {
-  const projectDir = getProjectPath(path);
-  const sessionFile = transcriptPath ?? node_path.join(projectDir, `${sessionId}.jsonl`);
-  const sessionExists = node_fs.existsSync(sessionFile);
+function claudeCheckSession(sessionId, path$1, transcriptPath) {
+  const projectDir = getProjectPath(path$1);
+  const sessionFile = transcriptPath ?? path.join(projectDir, `${sessionId}.jsonl`);
+  const sessionExists = fs.existsSync(sessionFile);
   if (!sessionExists) {
     api.logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
     return false;
   }
-  const sessionData = node_fs.readFileSync(sessionFile, "utf-8").split("\n");
+  const sessionData = fs.readFileSync(sessionFile, "utf-8").split("\n");
   const hasGoodMessage = !!sessionData.find((v, index) => {
     if (!v.trim()) return false;
     try {
@@ -3802,7 +4221,7 @@ function claudeFindLastSession(workingDirectory) {
   try {
     const projectDir = getProjectPath(workingDirectory);
     const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    const files = node_fs.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+    const files = fs.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).map((f) => {
       const sessionId = f.replace(".jsonl", "");
       if (!uuidPattern.test(sessionId)) {
         return null;
@@ -3811,7 +4230,7 @@ function claudeFindLastSession(workingDirectory) {
         return {
           name: f,
           sessionId,
-          mtime: node_fs.statSync(node_path.join(projectDir, f)).mtime.getTime()
+          mtime: fs.statSync(path.join(projectDir, f)).mtime.getTime()
         };
       }
       return null;
@@ -3831,10 +4250,10 @@ class ExitCodeError extends Error {
     this.exitCode = exitCode;
   }
 }
-const claudeCliPath = node_path.resolve(node_path.join(projectPath(), "scripts", "claude_local_launcher.cjs"));
+const claudeCliPath = path.resolve(path.join(projectPath(), "scripts", "claude_local_launcher.cjs"));
 async function claudeLocal(opts) {
   const projectDir = getProjectPath(opts.path);
-  node_fs.mkdirSync(projectDir, { recursive: true });
+  fs.mkdirSync(projectDir, { recursive: true });
   const hasContinueFlag = opts.claudeArgs?.includes("--continue");
   const hasResumeFlag = opts.claudeArgs?.includes("--resume");
   const hasUserSessionControl = hasContinueFlag || hasResumeFlag;
@@ -3953,7 +4372,7 @@ async function claudeLocal(opts) {
         args.push("--settings", opts.hookSettingsPath);
         api.logger.debug(`[ClaudeLocal] Using hook settings: ${opts.hookSettingsPath}`);
       }
-      if (!claudeCliPath || !node_fs.existsSync(claudeCliPath)) {
+      if (!claudeCliPath || !fs.existsSync(claudeCliPath)) {
         throw new Error("Claude local launcher not found. Please ensure HAPPY_PROJECT_ROOT is set correctly for development.");
       }
       const env = {
@@ -6301,17 +6720,17 @@ function readGeminiLocalConfig() {
   let googleCloudProject = null;
   let googleCloudProjectEmail = null;
   const possiblePaths = [
-    path.join(os$1.homedir(), ".gemini", "oauth_creds.json"),
+    path$1.join(os$1.homedir(), ".gemini", "oauth_creds.json"),
     // Main OAuth credentials file
-    path.join(os$1.homedir(), ".gemini", "config.json"),
-    path.join(os$1.homedir(), ".config", "gemini", "config.json"),
-    path.join(os$1.homedir(), ".gemini", "auth.json"),
-    path.join(os$1.homedir(), ".config", "gemini", "auth.json")
+    path$1.join(os$1.homedir(), ".gemini", "config.json"),
+    path$1.join(os$1.homedir(), ".config", "gemini", "config.json"),
+    path$1.join(os$1.homedir(), ".gemini", "auth.json"),
+    path$1.join(os$1.homedir(), ".config", "gemini", "auth.json")
   ];
   for (const configPath of possiblePaths) {
-    if (fs.existsSync(configPath)) {
+    if (fs$1.existsSync(configPath)) {
       try {
-        const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        const config = JSON.parse(fs$1.readFileSync(configPath, "utf-8"));
         if (!token) {
           const foundToken = config.access_token || config.token || config.apiKey || config.GEMINI_API_KEY;
           if (foundToken && typeof foundToken === "string") {
@@ -6383,22 +6802,22 @@ function determineGeminiModel(explicitModel, localConfig) {
 }
 function saveGeminiModelToConfig(model) {
   try {
-    const configDir = path.join(os$1.homedir(), ".gemini");
-    const configPath = path.join(configDir, "config.json");
-    if (!fs.existsSync(configDir)) {
-      fs.mkdirSync(configDir, { recursive: true });
+    const configDir = path$1.join(os$1.homedir(), ".gemini");
+    const configPath = path$1.join(configDir, "config.json");
+    if (!fs$1.existsSync(configDir)) {
+      fs$1.mkdirSync(configDir, { recursive: true });
     }
     let config = {};
-    if (fs.existsSync(configPath)) {
+    if (fs$1.existsSync(configPath)) {
       try {
-        config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        config = JSON.parse(fs$1.readFileSync(configPath, "utf-8"));
       } catch (error) {
         api.logger.debug(`[Gemini] Failed to read existing config, creating new one`);
         config = {};
       }
     }
     config.model = model;
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+    fs$1.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
     api.logger.debug(`[Gemini] Saved model "${model}" to ${configPath}`);
   } catch (error) {
     api.logger.debug(`[Gemini] Failed to save model to config:`, error);
@@ -6406,15 +6825,15 @@ function saveGeminiModelToConfig(model) {
 }
 function saveGoogleCloudProjectToConfig(projectId, email) {
   try {
-    const configDir = path.join(os$1.homedir(), ".gemini");
-    const configPath = path.join(configDir, "config.json");
-    if (!fs.existsSync(configDir)) {
-      fs.mkdirSync(configDir, { recursive: true });
+    const configDir = path$1.join(os$1.homedir(), ".gemini");
+    const configPath = path$1.join(configDir, "config.json");
+    if (!fs$1.existsSync(configDir)) {
+      fs$1.mkdirSync(configDir, { recursive: true });
     }
     let config = {};
-    if (fs.existsSync(configPath)) {
+    if (fs$1.existsSync(configPath)) {
       try {
-        config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        config = JSON.parse(fs$1.readFileSync(configPath, "utf-8"));
       } catch {
         config = {};
       }
@@ -6423,7 +6842,7 @@ function saveGoogleCloudProjectToConfig(projectId, email) {
     if (email) {
       config.googleCloudProjectEmail = email;
     }
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+    fs$1.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
     api.logger.debug(`[Gemini] Saved Google Cloud Project "${projectId}"${email ? ` for ${email}` : ""} to ${configPath}`);
   } catch (error) {
     api.logger.debug(`[Gemini] Failed to save Google Cloud Project to config:`, error);
@@ -6531,11 +6950,11 @@ function readFirstEnv(...names) {
   return "";
 }
 function normalizeCommandPath(command) {
-  if (node_path.isAbsolute(command)) {
+  if (path.isAbsolute(command)) {
     return command;
   }
-  const resolved = node_path.resolve(process.cwd(), command);
-  return node_fs.existsSync(resolved) ? resolved : command;
+  const resolved = path.resolve(process.cwd(), command);
+  return fs.existsSync(resolved) ? resolved : command;
 }
 function resolveCommandOnPath(command) {
   const pathValue = typeof process.env.PATH === "string" ? process.env.PATH : "";
@@ -6543,13 +6962,13 @@ function resolveCommandOnPath(command) {
     return null;
   }
   const extensions = process.platform === "win32" ? (process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").map((value) => value.trim().toLowerCase()).filter(Boolean) : [""];
-  for (const dir of pathValue.split(node_path.delimiter)) {
+  for (const dir of pathValue.split(path.delimiter)) {
     const trimmedDir = dir.trim();
     if (!trimmedDir) {
       continue;
     }
-    const directCandidate = node_path.join(trimmedDir, command);
-    if (node_fs.existsSync(directCandidate)) {
+    const directCandidate = path.join(trimmedDir, command);
+    if (fs.existsSync(directCandidate)) {
       return directCandidate;
     }
     if (process.platform !== "win32") {
@@ -6560,8 +6979,8 @@ function resolveCommandOnPath(command) {
       continue;
     }
     for (const extension of extensions) {
-      const candidate = node_path.join(trimmedDir, `${command}${extension.toLowerCase()}`);
-      if (node_fs.existsSync(candidate)) {
+      const candidate = path.join(trimmedDir, `${command}${extension.toLowerCase()}`);
+      if (fs.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -6660,8 +7079,8 @@ function validateCodexAcpSpawn(options = {}) {
   const normalizedCommand = spawn.command.trim();
   const commandLower = normalizedCommand.toLowerCase();
   const npxMode = readCodexAcpNpxMode();
-  if (node_path.isAbsolute(normalizedCommand)) {
-    if (!node_fs.existsSync(normalizedCommand)) {
+  if (path.isAbsolute(normalizedCommand)) {
+    if (!fs.existsSync(normalizedCommand)) {
       return {
         ok: false,
         errorMessage: `Codex ACP is enabled, but the resolved command does not exist: ${normalizedCommand}`
@@ -6690,6 +7109,189 @@ function validateCodexAcpSpawn(options = {}) {
   return { ok: true, spawn };
 }
 
+function firstExistingPath(candidates) {
+  for (const candidate of candidates) {
+    try {
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveCodexExecutable() {
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+    const npmGlobalBin = path.join(appData, "npm");
+    const resolved = firstExistingPath([
+      path.join(npmGlobalBin, "codex.cmd"),
+      path.join(npmGlobalBin, "codex.ps1"),
+      path.join(npmGlobalBin, "codex")
+    ]);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return "codex";
+}
+
+function 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 = path.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 = fs.existsSync,
+  resolveExecutable = resolveCodexExecutable,
+  resolveOnPath = resolveCommandOnPath
+}) {
+  const resolvedExecutable = resolveExecutable();
+  if (path.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 = fs.existsSync,
+  realpath = fs.realpathSync
+}) {
+  const executableDir = path.dirname(executablePath);
+  const candidates = [
+    path.join(executableDir, "node_modules", "@openai", "codex"),
+    path.join(executableDir, "..", "lib", "node_modules", "@openai", "codex")
+  ];
+  try {
+    const realExecutablePath = realpath(executablePath);
+    candidates.push(path.join(path.dirname(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 ?? fs.existsSync;
+  const candidates = packageRoots.flatMap((packageRoot) => [
+    path.join(packageRoot, "vendor", codexTarget.targetTriple, "path"),
+    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(path.delimiter).filter(Boolean);
+  const codexToolDirs = resolveBundledCodexToolPathDirs(options);
+  const mergedPathEntries = dedupePaths(
+    [...codexToolDirs, ...currentPathEntries],
+    platform
+  );
+  if (mergedPathEntries.length > 0) {
+    env[pathKey] = mergedPathEntries.join(path.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();
@@ -6719,10 +7321,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)
@@ -6872,6 +7474,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";
 }
@@ -6916,26 +7536,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 Promise.resolve().then(function () { return require('./runClaude-CPhWaFrX.cjs'); });
+    const { runClaude } = await Promise.resolve().then(function () { return require('./runClaude-C1W_Nw0C.cjs'); });
     await runClaude(credentials, opts.claudeOptions ?? {});
     return;
   }
   if (opts.provider === "codex") {
-    const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex--QLrOs8X.cjs'); });
+    const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-D2VCWVEK.cjs'); });
     await runCodex({
       credentials,
       startedBy: opts.startedBy,
@@ -6945,7 +7559,7 @@ async function executeUnifiedProvider(opts) {
     return;
   }
   if (opts.provider === "gemini") {
-    const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-CDyhCucw.cjs'); });
+    const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-CiGnjflq.cjs'); });
     await runGemini({
       credentials,
       startedBy: opts.startedBy
@@ -6987,7 +7601,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await Promise.resolve().then(function () { return require('./command-DjIfRZQS.cjs'); });
+      const { renderRuntimeProviders } = await Promise.resolve().then(function () { return require('./command-Df7u5eAT.cjs'); });
       console.log(renderRuntimeProviders());
       return;
     }
@@ -7165,8 +7779,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await Promise.resolve().then(function () { return require('./persistence-DBGkO8gB.cjs'); });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./api-CN-WqYd_.cjs'); }).then(function (n) { return n.api; });
+        const { readCredentials: readCredentials2 } = await Promise.resolve().then(function () { return require('./persistence-D7JtnrYA.cjs'); });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./api-DUE5TJBE.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();
@@ -7313,14 +7927,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 {
@@ -7329,7 +7936,7 @@ function shouldRunMainClaudeFlow(opts) {
         if (latest) {
           console.error(`Latest daemon log: ${latest.path}`);
           try {
-            const logContent = node_fs.readFileSync(latest.path, "utf-8");
+            const logContent = fs.readFileSync(latest.path, "utf-8");
             if (logContent.includes("EADDRINUSE")) {
               console.error("Daemon control port is already in use. Retry after stopping the stale daemon or run `hicloud doctor clean`.");
             }
@@ -7602,8 +8209,8 @@ exports.getInitialGeminiModel = getInitialGeminiModel;
 exports.getProjectPath = getProjectPath;
 exports.initialMachineMetadata = initialMachineMetadata;
 exports.isBun = isBun;
-exports.notifyDaemonSessionStarted = notifyDaemonSessionStarted;
 exports.projectPath = projectPath;
+exports.publishSessionRegistration = publishSessionRegistration;
 exports.readGeminiLocalConfig = readGeminiLocalConfig;
 exports.saveGeminiModelToConfig = saveGeminiModelToConfig;
 exports.startCaffeinate = startCaffeinate;