very-happy-cli 0.2.122 → 0.2.123

package/dist/{index-DKRU6E-x.cjs → index-5b9YhV-1.cjs}

@@ -3,7 +3,7 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var persistence = require('./types-Jag0GwhO.cjs');
+var persistence = require('./types-Cd_tUN3U.cjs');
 var spawn = require('cross-spawn');
 var path = require('node:path');
 var node_readline = require('node:readline');
@@ -7320,24 +7320,297 @@ function decideHandover(run) {
   return { action: "handover" };
 }
 
-function decideAutoUpdate(context) {
-  if (!context.enabled) return { action: "skip", reason: "auto-update disabled" };
-  const target = context.autoUpdateVersion;
-  if (!target) return { action: "skip", reason: "no version approved for automatic install" };
-  const ordering = persistence.compareExactVersions(context.currentVersion, target);
-  if (ordering === null) return { action: "skip", reason: "version numbers not comparable" };
-  if (ordering === 0) return { action: "skip", reason: "already current" };
-  if (ordering > 0) return { action: "skip", reason: `already ahead of the approved ${target}` };
-  if (context.failedVersion === target) {
-    return { action: "skip", reason: `already failed to install ${target} once` };
-  }
-  if (!context.idle) return { action: "skip", reason: "machine is busy" };
-  return { action: "install", version: target };
+function serialTask(task) {
+  let running = false;
+  return async () => {
+    if (running) return;
+    running = true;
+    try {
+      await task();
+    } finally {
+      running = false;
+    }
+  };
 }
+
 function autoUpdateInstallArgs(version) {
   return ["i", "-g", "--allow-scripts=very-happy-cli,node-pty", `very-happy-cli@${version}`];
 }
 
+const processDefaults = {
+  spawn: node_child_process.spawn,
+  killGroup: (pid) => {
+    process.kill(-pid, "SIGKILL");
+  },
+  platform: process.platform,
+  timeoutMs: 10 * 6e4,
+  terminationGraceMs: 5e3
+};
+const runNpmProcess = (args, deps = processDefaults) => new Promise((resolveResult) => {
+  let stdout = "";
+  let stderr = "";
+  let timedOut = false;
+  let settled = false;
+  let grace;
+  let timer;
+  let treeKilled = false;
+  const done = (result) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    clearTimeout(grace);
+    resolveResult(result);
+  };
+  if (args.some((arg) => !/^[A-Za-z0-9@=.,+/_-]+$/.test(arg))) {
+    done({ code: null, stdout, stderr: "Invalid npm argument" });
+    return;
+  }
+  const child = deps.platform === "win32" ? deps.spawn("cmd.exe", ["/d", "/s", "/c", `npm ${args.join(" ")}`], { stdio: ["ignore", "pipe", "pipe"] }) : deps.spawn("npm", args, { stdio: ["ignore", "pipe", "pipe"], detached: true });
+  timer = setTimeout(() => {
+    timedOut = true;
+    grace = setTimeout(() => done({ code: null, stdout, stderr, terminationConfirmed: false }), deps.terminationGraceMs);
+    if (!child.pid) return;
+    if (deps.platform === "win32") {
+      const killer = deps.spawn("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+      killer.on("error", () => void 0);
+      killer.on("close", (code) => {
+        treeKilled = code === 0;
+      });
+    } else {
+      try {
+        deps.killGroup(child.pid);
+        treeKilled = true;
+      } catch {
+      }
+    }
+  }, deps.timeoutMs);
+  child.stdout?.on("data", (data) => {
+    stdout = (stdout + String(data)).slice(-8192);
+  });
+  child.stderr?.on("data", (data) => {
+    stderr = (stderr + String(data)).slice(-8192);
+  });
+  child.on("error", () => done({ code: null, stdout, stderr, terminationConfirmed: !timedOut }));
+  child.on("close", (code) => done({ code: timedOut ? null : code, stdout, stderr, terminationConfirmed: !timedOut || treeKilled }));
+});
+const runNpm = (args) => runNpmProcess(args);
+const defaults = { npm: runNpm, fs: { lstat: promises.lstat, readlink: promises.readlink, unlink: promises.unlink, rm: promises.rm, readFile: promises.readFile, symlink: promises.symlink }, platform: process.platform };
+function ownedCliLink(link, target, packageDir) {
+  const resolved = path.resolve(path.dirname(link), target);
+  return resolved.startsWith(path.join(packageDir, "bin") + path.sep);
+}
+async function installCliSafely(version, deps = defaults) {
+  const parsed = persistence.parseExactVersion(version);
+  if (!parsed) throw new Error("Invalid exact CLI version");
+  const args = autoUpdateInstallArgs(parsed.exact);
+  if (deps.platform === "win32") {
+    const result2 = await deps.npm(args);
+    return result2.terminationConfirmed === false ? "blocked" : result2.code;
+  }
+  const rootResult = await deps.npm(["root", "-g"]);
+  if (rootResult.terminationConfirmed === false) return "blocked";
+  const prefixResult = await deps.npm(["prefix", "-g"]);
+  if (prefixResult.terminationConfirmed === false) return "blocked";
+  const root = rootResult.stdout.trim();
+  const prefix = prefixResult.stdout.trim();
+  if (rootResult.code !== 0 || prefixResult.code !== 0 || !path.isAbsolute(root) || !path.isAbsolute(prefix) || path.basename(root) !== "node_modules" || path.resolve(prefix) === "/" || root.includes("\n") || prefix.includes("\n")) {
+    throw new Error("Cannot verify global npm paths; use manual install");
+  }
+  if (path.resolve(root) !== path.resolve(prefix, "lib/node_modules")) throw new Error("Unexpected npm root/prefix relationship");
+  const packageDir = path.join(root, "very-happy-cli");
+  const packageStat = await deps.fs.lstat(packageDir).catch((error) => {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  });
+  if (packageStat && (!packageStat.isDirectory() || packageStat.isSymbolicLink())) {
+    throw new Error("Refusing to modify a linked or non-directory CLI package");
+  }
+  if (packageStat) {
+    const manifest = JSON.parse(await deps.fs.readFile(path.join(packageDir, "package.json"), "utf8"));
+    if (manifest.name !== "very-happy-cli") throw new Error("Cannot verify installed CLI package identity");
+  }
+  const ownLinks = [];
+  for (const name of ["very-happy", "very-happy-mcp"]) {
+    const link = path.join(prefix, "bin", name);
+    const stat = await deps.fs.lstat(link).catch((error) => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (!stat) continue;
+    if (!stat.isSymbolicLink() || !ownedCliLink(link, await deps.fs.readlink(link), packageDir)) {
+      throw new Error("CLI bin is owned by another installation; use manual recovery");
+    }
+    ownLinks.push({ link, target: await deps.fs.readlink(link) });
+  }
+  let result = null;
+  let safeToRestore = true;
+  try {
+    for (const { link } of ownLinks) await deps.fs.unlink(link);
+    const first = await deps.npm(args);
+    if (first.terminationConfirmed === false) {
+      safeToRestore = false;
+      return "blocked";
+    }
+    result = first.code;
+    if (first.code === 0 || first.code === null) return first.code;
+    if (!/\b(?:EEXIST|ENOTEMPTY)\b/.test(first.stderr ?? "")) return first.code;
+    const failedStat = await deps.fs.lstat(packageDir).catch((error) => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (failedStat && (!packageStat || !failedStat.isDirectory() || failedStat.isSymbolicLink())) {
+      throw new Error("Refusing to remove an unverified CLI package");
+    }
+    if (failedStat) await deps.fs.rm(packageDir, { recursive: true, force: true });
+    const second = await deps.npm(args);
+    result = second.code;
+    if (second.terminationConfirmed === false) {
+      safeToRestore = false;
+      return "blocked";
+    }
+    return result;
+  } finally {
+    if (result !== 0 && safeToRestore) {
+      for (const { link, target } of ownLinks) {
+        const entry = await deps.fs.lstat(path.resolve(path.dirname(link), target)).catch(() => null);
+        const current = await deps.fs.lstat(link).catch(() => null);
+        if (entry?.isFile() && !current) await deps.fs.symlink(target, link).catch(() => void 0);
+      }
+    }
+  }
+}
+
+function createUpdateController(deps) {
+  let policy = null;
+  let outcome = null;
+  let running = false;
+  let operation = null;
+  let blocked = false;
+  let handoverHold;
+  let lastPublished = "";
+  const now = deps.now ?? Date.now;
+  function publish(state, version, detail) {
+    if (!policy) return;
+    const fingerprint = JSON.stringify([policy.checkedAt, state, version, detail]);
+    if (fingerprint === lastPublished) return;
+    lastPublished = fingerprint;
+    outcome = { state, version, detail, at: now() };
+    deps.publish({ ...policy, retrySupported: !blocked, handoverHold, autoUpdate: outcome });
+  }
+  async function evaluate() {
+    if (!policy || running) return;
+    const target = policy.autoUpdateVersion ?? null;
+    if (outcome?.version === target && ["failed", "installed"].includes(outcome.state)) {
+      const fingerprint = JSON.stringify([policy.checkedAt, outcome.state, outcome.version, outcome.detail]);
+      if (fingerprint !== lastPublished) {
+        lastPublished = fingerprint;
+        deps.publish({ ...policy, retrySupported: !blocked, handoverHold, autoUpdate: outcome });
+      }
+      return;
+    }
+    if (now() - policy.checkedAt > 65 * 6e4) {
+      publish("policy_stale", target);
+      return;
+    }
+    if (!await deps.enabled()) {
+      publish("disabled", target);
+      return;
+    }
+    if (running) return;
+    if (now() - policy.checkedAt > 65 * 6e4) {
+      publish("policy_stale", target);
+      return;
+    }
+    if (!target) {
+      publish("unapproved", null);
+      return;
+    }
+    const order = persistence.compareExactVersions(policy.currentVersion, target);
+    if (order !== -1) {
+      publish(order === null ? "policy_stale" : "current", target);
+      return;
+    }
+    if (!deps.idle()) {
+      publish("waiting_idle", target);
+      return;
+    }
+    running = true;
+    publish("installing", target);
+    try {
+      const code = await deps.install(target);
+      blocked = code === "blocked";
+      publish(
+        blocked ? "manual_required" : code === 0 ? "installed" : "failed",
+        target,
+        blocked ? "installer_termination_unconfirmed" : code === 0 ? void 0 : "npm_install_failed"
+      );
+    } catch {
+      publish("failed", target, "npm_install_failed");
+    } finally {
+      running = false;
+    }
+  }
+  async function tick() {
+    if (operation || blocked) return;
+    operation = "tick";
+    try {
+      await evaluate();
+    } finally {
+      operation = null;
+    }
+  }
+  async function refresh() {
+    if (operation || blocked) return;
+    operation = "refresh";
+    try {
+      const next = await deps.policy();
+      if (!next) return;
+      policy = next;
+      await evaluate();
+    } finally {
+      operation = null;
+    }
+  }
+  async function retry(version) {
+    if (operation || blocked) return { error: blocked ? "manual_recovery_required" : "update_in_progress" };
+    if (typeof version !== "string" || outcome?.state !== "failed" || outcome.version !== version) {
+      return { error: "no_matching_failed_update" };
+    }
+    operation = "retry";
+    try {
+      const next = await deps.policy();
+      if (!next || next.autoUpdateVersion !== version || now() - next.checkedAt > 65 * 6e4) {
+        return { error: "update_policy_changed_or_unavailable" };
+      }
+      if (!await deps.enabled()) return { error: "auto_update_disabled" };
+      policy = next;
+      outcome = null;
+      handoverHold = null;
+      publish("waiting_idle", version);
+      setTimeout(() => {
+        void tick().catch(() => publish("policy_stale", version));
+      }, 0);
+      return { accepted: true };
+    } finally {
+      operation = null;
+    }
+  }
+  async function withHandover(task) {
+    if (operation || blocked) return;
+    operation = "handover";
+    try {
+      await task();
+    } finally {
+      operation = null;
+    }
+  }
+  function holdHandover(reason) {
+    handoverHold = { reason, at: now() };
+    publish("failed", policy?.autoUpdateVersion ?? null, "handover_preflight_failed");
+  }
+  return { refresh, retry, tick, withHandover, holdHandover, isRunning: () => running };
+}
+
 const CLAUDE_KEYCHAIN_SERVICE_PREFIX = "Claude Code";
 function keychainIdentity(env = process.env, deps = {}) {
   const home = deps.home ?? os.homedir();
@@ -7401,7 +7674,7 @@ function parseJsonObject(text) {
     return null;
   }
 }
-function resolveSdkClaudeBinary(platform = process.platform, arch = process.arch, resolver = (s) => node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DKRU6E-x.cjs', document.baseURI).href))).resolve(s)) {
+function resolveSdkClaudeBinary(platform = process.platform, arch = process.arch, resolver = (s) => node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-5b9YhV-1.cjs', document.baseURI).href))).resolve(s)) {
   const platformArch = `${platform}-${arch}`;
   const candidates = [
     `@anthropic-ai/claude-agent-sdk-${platformArch}/claude`,
@@ -8614,45 +8887,7 @@ async function preflightNewBundle(bundlePath) {
     }
   }
 }
-function withHandoverHold(state, reason) {
-  if (!state) return state;
-  return reason ? { ...state, handoverHold: { reason, at: Date.now() } } : { ...state, handoverHold: null };
-}
 const HANDOVER_PREFLIGHT_TIMEOUT_MS = 3e4;
-function runNpmInstall(args) {
-  return new Promise((resolve) => {
-    let settled = false;
-    const done = (code) => {
-      if (!settled) {
-        settled = true;
-        resolve(code);
-      }
-    };
-    let child;
-    try {
-      child = node_child_process.spawn("npm", args, { stdio: "ignore", env: process.env });
-    } catch {
-      done(null);
-      return;
-    }
-    const timer = setTimeout(() => {
-      try {
-        child.kill("SIGKILL");
-      } catch {
-      }
-      done(null);
-    }, AUTO_UPDATE_INSTALL_TIMEOUT_MS);
-    child.on("error", () => {
-      clearTimeout(timer);
-      done(null);
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      done(code);
-    });
-  });
-}
-const AUTO_UPDATE_INSTALL_TIMEOUT_MS = 10 * 6e4;
 async function startDaemon() {
   let claudeAuthServiceRef = null;
   let cliUpdateStateRef = null;
@@ -9740,67 +9975,30 @@ async function startDaemon() {
         host: initialMachineMetadata.host
       })).then(() => persistence.logger.debug(`[DAEMON RUN] claimed the machine record for host ${initialMachineMetadata.host}`)).catch((error) => persistence.logger.debug("[DAEMON RUN] could not refresh the recorded host:", error));
     }
-    let autoUpdateFailedVersion = null;
-    let autoUpdateRunning = false;
-    const maybeAutoUpdate = async (cliUpdate) => {
-      if (autoUpdateRunning) return;
-      const settings = await persistence.readSettings();
-      const decision = decideAutoUpdate({
-        enabled: (settings.cliAutoUpdate ?? "idle") !== "off",
-        currentVersion: cliUpdate.currentVersion,
-        autoUpdateVersion: cliUpdate.autoUpdateVersion ?? null,
-        idle: pidToTrackedSession.size === 0 && !apiMachine.hasLiveTerminals(),
-        failedVersion: autoUpdateFailedVersion
-      });
-      if (decision.action === "skip") {
-        persistence.logger.debug(`[DAEMON RUN] auto-update skipped: ${decision.reason}`);
-        return;
-      }
-      autoUpdateRunning = true;
-      const target = decision.version;
-      const report = (state, detail) => {
-        cliUpdateStateRef = { ...cliUpdate, autoUpdate: { state, version: target, detail, at: Date.now() } };
-        void apiMachine.setCliUpdateState(cliUpdateStateRef);
-      };
-      persistence.logger.warn(`[DAEMON RUN] auto-updating CLI to ${target} (machine idle)`);
-      report("installing");
-      try {
-        const code = await runNpmInstall(autoUpdateInstallArgs(target));
-        if (code === 0) {
-          persistence.logger.warn(`[DAEMON RUN] auto-update installed ${target}; handover follows once it verifies`);
-          report("installed");
+    let lastUpdateLog = "";
+    const updateController = createUpdateController({
+      policy: () => persistence.fetchCliUpdateState(persistence.configuration.serverUrl, persistence.packageJson.version),
+      enabled: async () => ((await persistence.readSettings()).cliAutoUpdate ?? "idle") !== "off",
+      idle: () => pidToTrackedSession.size === 0 && !apiMachine.hasLiveTerminals(),
+      install: installCliSafely,
+      publish: (state) => {
+        cliUpdateStateRef = state;
+        fileState = { ...fileState, cliUpdate: state };
+        persistence.writeDaemonState(fileState);
+        apiMachine.setCliUpdateState(state);
+        const logKey = JSON.stringify([state.autoUpdate?.state, state.autoUpdate?.version, state.autoUpdate?.detail]);
+        if (logKey !== lastUpdateLog) {
+          lastUpdateLog = logKey;
+          persistence.logger.warn(`[DAEMON RUN] CLI update: ${state.autoUpdate?.state} target=${state.autoUpdate?.version ?? "none"} detail=${state.autoUpdate?.detail ?? "none"}`);
         } else {
-          autoUpdateFailedVersion = target;
-          persistence.logger.warn(`[DAEMON RUN] auto-update of ${target} failed with exit ${code}`);
-          report("failed", `npm exited ${code}`);
+          persistence.logger.debug("[DAEMON RUN] CLI update policy refreshed");
         }
-      } catch (error) {
-        autoUpdateFailedVersion = target;
-        persistence.logger.warn(`[DAEMON RUN] auto-update of ${target} could not run:`, error);
-        report("failed", String(error).slice(0, 200));
-      } finally {
-        autoUpdateRunning = false;
-      }
-    };
-    let cliUpdateCheckRunning = false;
-    const refreshCliUpdate = async () => {
-      if (cliUpdateCheckRunning) return;
-      cliUpdateCheckRunning = true;
-      try {
-        const cliUpdate = await persistence.fetchCliUpdateState(persistence.configuration.serverUrl, persistence.packageJson.version);
-        if (!cliUpdate) return;
-        fileState = { ...fileState, cliUpdate };
-        persistence.writeDaemonState(fileState);
-        cliUpdateStateRef = cliUpdate;
-        apiMachine.setCliUpdateState(cliUpdate);
-        persistence.logger.debug(`[DAEMON RUN] CLI update policy checked: ${cliUpdate.status} (recommended=${cliUpdate.recommendedVersion ?? "none"}, minimum=${cliUpdate.minimumVersion ?? "none"})`);
-        await maybeAutoUpdate(cliUpdate);
-      } catch (error) {
-        persistence.logger.debug("[DAEMON RUN] CLI update policy check failed:", error);
-      } finally {
-        cliUpdateCheckRunning = false;
       }
-    };
+    });
+    apiMachine.setCliUpdateRetryHandler(updateController.retry);
+    const refreshCliUpdate = () => updateController.refresh().catch((error) => {
+      persistence.logger.debug("[DAEMON RUN] CLI update policy check failed:", error);
+    });
     void refreshCliUpdate();
     const cliUpdateIntervalMs = persistence.resolveCliUpdateCheckInterval(process.env.HAPPY_CLI_UPDATE_CHECK_INTERVAL);
     if (process.env.HAPPY_CLI_UPDATE_CHECK_INTERVAL && cliUpdateIntervalMs === persistence.DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS && process.env.HAPPY_CLI_UPDATE_CHECK_INTERVAL.trim() !== String(persistence.DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS)) {
@@ -9808,77 +10006,79 @@ async function startDaemon() {
     }
     const cliUpdateInterval = setInterval(() => void refreshCliUpdate(), cliUpdateIntervalMs);
     const heartbeatIntervalMs = parseInt(process.env.HAPPY_DAEMON_HEARTBEAT_INTERVAL || "60000");
-    let heartbeatRunning = false;
-    const restartOnStaleVersionAndHeartbeat = setInterval(async () => {
-      if (heartbeatRunning) {
-        return;
-      }
-      heartbeatRunning = true;
-      if (process.env.DEBUG) {
-        persistence.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) {
-          persistence.logger.debug(`[DAEMON RUN] Finalizing stale session with PID ${pid} (process no longer exists)`);
-          onChildExited(pid);
+    const restartOnStaleVersionAndHeartbeat = setInterval(serialTask(async () => {
+      try {
+        if (process.env.DEBUG) {
+          persistence.logger.debug(`[DAEMON RUN] Health check started at ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
         }
-      }
-      let bundleReplaced = false;
-      if (initialBundleMtimeMs > 0) {
-        try {
-          const currentMtimeMs = fs$1.statSync(bundlePath).mtimeMs;
-          bundleReplaced = currentMtimeMs !== initialBundleMtimeMs;
-        } catch {
+        for (const [pid, _] of pidToTrackedSession.entries()) {
+          try {
+            process.kill(pid, 0);
+          } catch (error) {
+            persistence.logger.debug(`[DAEMON RUN] Finalizing stale session with PID ${pid} (process no longer exists)`);
+            onChildExited(pid);
+          }
         }
-      }
-      if (bundleReplaced) {
-        const preflight = await preflightNewBundle(bundlePath);
-        if (preflight.action === "hold") {
-          if (lastHandoverHold !== preflight.reason) {
-            lastHandoverHold = preflight.reason;
-            persistence.logger.warn(`[DAEMON RUN] holding handover: ${preflight.reason}`);
-            void apiMachine.setCliUpdateState(withHandoverHold(cliUpdateStateRef, preflight.reason));
+        await updateController.tick();
+        await updateController.withHandover(async () => {
+          let bundleReplaced = false;
+          if (initialBundleMtimeMs > 0) {
+            try {
+              const currentMtimeMs = fs$1.statSync(bundlePath).mtimeMs;
+              bundleReplaced = currentMtimeMs !== initialBundleMtimeMs;
+            } catch {
+            }
           }
-          return;
+          if (bundleReplaced && !updateController.isRunning() && pidToTrackedSession.size === 0 && !apiMachine.hasLiveTerminals()) {
+            const preflight = await preflightNewBundle(bundlePath);
+            if (preflight.action === "hold") {
+              if (lastHandoverHold !== preflight.reason) {
+                lastHandoverHold = preflight.reason;
+                persistence.logger.warn(`[DAEMON RUN] holding handover: ${preflight.reason}`);
+              }
+              updateController.holdHandover(preflight.reason);
+              return;
+            }
+            if (updateController.isRunning() || pidToTrackedSession.size > 0 || apiMachine.hasLiveTerminals()) return;
+            lastHandoverHold = null;
+            persistence.logger.debug("[DAEMON RUN] Daemon bundle replaced on disk and verified, handing off to new daemon");
+            clearInterval(restartOnStaleVersionAndHeartbeat);
+            clearInterval(cliUpdateInterval);
+            claudeAuthService.stop();
+            apiMachine.shutdown();
+            await stopControlServer();
+            await cleanupDaemonState();
+            await persistence.releaseDaemonLock(daemonLockHandle);
+            await stopCaffeinate();
+            try {
+              spawnHappyCLI(["daemon", "start"], {
+                detached: true,
+                stdio: "ignore"
+              });
+            } catch (error) {
+              persistence.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);
+            }
+            process.exit(0);
+          }
+        });
+        const daemonState = await persistence.readDaemonState();
+        if (daemonState && daemonState.pid !== process.pid) {
+          persistence.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.");
         }
-        lastHandoverHold = null;
-        persistence.logger.debug("[DAEMON RUN] Daemon bundle replaced on disk and verified, handing off to new daemon");
-        clearInterval(restartOnStaleVersionAndHeartbeat);
-        clearInterval(cliUpdateInterval);
-        claudeAuthService.stop();
-        apiMachine.shutdown();
-        await stopControlServer();
-        await cleanupDaemonState();
-        await persistence.releaseDaemonLock(daemonLockHandle);
-        await stopCaffeinate();
         try {
-          spawnHappyCLI(["daemon", "start"], {
-            detached: true,
-            stdio: "ignore"
-          });
+          fileState = withDaemonHeartbeat(fileState, (/* @__PURE__ */ new Date()).toLocaleString());
+          persistence.writeDaemonState(fileState);
+          if (process.env.DEBUG) {
+            persistence.logger.debug(`[DAEMON RUN] Health check completed at ${fileState.lastHeartbeat}`);
+          }
         } catch (error) {
-          persistence.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);
-        }
-        process.exit(0);
-      }
-      const daemonState = await persistence.readDaemonState();
-      if (daemonState && daemonState.pid !== process.pid) {
-        persistence.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 {
-        fileState = withDaemonHeartbeat(fileState, (/* @__PURE__ */ new Date()).toLocaleString());
-        persistence.writeDaemonState(fileState);
-        if (process.env.DEBUG) {
-          persistence.logger.debug(`[DAEMON RUN] Health check completed at ${fileState.lastHeartbeat}`);
+          persistence.logger.debug("[DAEMON RUN] Failed to write heartbeat", error);
         }
       } catch (error) {
-        persistence.logger.debug("[DAEMON RUN] Failed to write heartbeat", error);
+        persistence.logger.debug("[DAEMON RUN] Heartbeat failed:", error);
       }
-      heartbeatRunning = false;
-    }, heartbeatIntervalMs);
+    }), heartbeatIntervalMs);
     const cleanupAndShutdown = async (source, errorMessage) => {
       persistence.logger.debug(`[DAEMON RUN] Starting proper cleanup (source: ${source}, errorMessage: ${errorMessage})...`);
       if (restartOnStaleVersionAndHeartbeat) {
@@ -11318,7 +11518,7 @@ function registerSideQuestionHandler(rpc, deps) {
   const retainMs = deps.retainMs ?? SIDE_QUESTION_RETAIN_MS;
   const maxRunMs = deps.maxRunMs ?? SIDE_QUESTION_MAX_RUN_MS;
   const run = deps.run ?? (async (input) => {
-    const { query } = await Promise.resolve().then(function () { return require('./index-BHg0P9cY.cjs'); });
+    const { query } = await Promise.resolve().then(function () { return require('./index-DWBKJ5zy.cjs'); });
     return runSideQuestion(query, input);
   });
   const slots = /* @__PURE__ */ new Map();
@@ -11420,7 +11620,7 @@ const MAX_TITLE_CHARS = 60;
 const GENERATION_TIMEOUT_MS = 3e4;
 function resolveClaudeBinary() {
   try {
-    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-DKRU6E-x.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-5b9YhV-1.cjs', document.baseURI).href)));
     const utilsPath = path.resolve(path.join(persistence.projectPath(), "scripts", "claude_version_utils.cjs"));
     const { getClaudeCliPath } = require$1(utilsPath);
     const path$1 = getClaudeCliPath();
@@ -13637,9 +13837,9 @@ function resolveLocalSignupBootstrap(configuredMode, configuredInviteCodes, gene
   };
 }
 
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DKRU6E-x.cjs', document.baseURI).href)));
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-5b9YhV-1.cjs', document.baseURI).href)));
 const __dirname$1 = path.dirname(__filename$1);
-const require_ = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DKRU6E-x.cjs', document.baseURI).href)));
+const require_ = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-5b9YhV-1.cjs', document.baseURI).href)));
 const PRISMA_QUERY_ENGINE_FILES = {
   "arm64-darwin": "libquery_engine-darwin-arm64.dylib.node",
   "x64-darwin": "libquery_engine-darwin.dylib.node",
@@ -16269,7 +16469,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     process.exit(0);
   } else if (subcommand === "install-terminal-hooks") {
     try {
-      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await Promise.resolve().then(function () { return require('./installTerminalHooks-CGqopr1A.cjs'); });
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await Promise.resolve().then(function () { return require('./installTerminalHooks-DWCa5j7u.cjs'); });
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -16286,7 +16486,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "spawn") {
     try {
-      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-7U_4QTHw.cjs'); });
+      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-BtV9dU1i.cjs'); });
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -16298,7 +16498,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "sessions") {
     try {
-      const { handleSessionsCommand } = await Promise.resolve().then(function () { return require('./sessions-CTuUV0TW.cjs'); });
+      const { handleSessionsCommand } = await Promise.resolve().then(function () { return require('./sessions-DXYxV6Np.cjs'); });
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -16310,7 +16510,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "send") {
     try {
-      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-B0Wojz18.cjs'); });
+      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-BINA__Ke.cjs'); });
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -16416,9 +16616,9 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     if (geminiSubcommand === "project" && args[2] === "set" && args[3]) {
       const projectId = args[3];
       try {
-        const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return require('./config-rQdv_Yr0.cjs'); });
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./types-Jag0GwhO.cjs'); }).then(function (n) { return n.persistence; });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-Jag0GwhO.cjs'); }).then(function (n) { return n.api; });
+        const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return require('./config-4RaHrVSV.cjs'); });
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./types-Cd_tUN3U.cjs'); }).then(function (n) { return n.persistence; });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-Cd_tUN3U.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -16449,7 +16649,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
     if (geminiSubcommand === "project" && args[2] === "get") {
       try {
-        const { readGeminiLocalConfig } = await Promise.resolve().then(function () { return require('./config-rQdv_Yr0.cjs'); });
+        const { readGeminiLocalConfig } = await Promise.resolve().then(function () { return require('./config-4RaHrVSV.cjs'); });
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -16489,7 +16689,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-DYawZQTu.cjs'); });
+      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-DmWxHIwS.cjs'); });
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -16519,7 +16719,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       }
     };
     try {
-      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-uPpFZhhr.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-Beh0UZf8.cjs'); });
       const parsed = parsePiRunnerArgs(args.slice(1));
       const resolved = resolveAcpAgentConfig(["pi", ...parsed.passthrough]);
       const { credentials } = await authAndSetupMachineIfNeeded();
@@ -16546,7 +16746,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "acp") {
     try {
-      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-uPpFZhhr.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-Beh0UZf8.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -16586,7 +16786,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "openclaw") {
     try {
-      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-C2XjFP2m.cjs'); });
+      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-boyJtPBq.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -16637,7 +16837,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "mcp" && args.length === 1) {
     try {
-      const { handleMcpCommand } = await Promise.resolve().then(function () { return require('./mcp-FlbfMw6_.cjs'); });
+      const { handleMcpCommand } = await Promise.resolve().then(function () { return require('./mcp-BBya5dsZ.cjs'); });
       await handleMcpCommand();
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}