very-happy-cli 0.2.122 → 0.2.123

package/dist/{index-BTnlYGaP.mjs → index-36AkXNF2.mjs}

@@ -1,13 +1,13 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
 import os, { homedir, userInfo, tmpdir } from 'node:os';
 import { randomUUID, randomBytes, createHash as createHash$1, timingSafeEqual } from 'node:crypto';
-import { o as readDaemonState, l as logger, c as configuration, q as clearDaemonState, t as getProjectPath, p as projectPath, u as initializeSandbox, v as wrapCommand, g as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, k as delay, x as AsyncLock, S as STREAM_DELTA_MAX_CHARS, y as ensurePrivateDirectory, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, z as hardenPrivateFile, j as packageJson, B as commandOnPath, e as readSettings, C as readCredentials, D as credentialRelayProblem, E as deriveLocalCliUpdateSummary, f as encodeBase64, F as readSettingsOutcome, G as updateSettings, H as encodeBase64Url, J as decodeBase64, K as writeCredentialsLegacy, L as writeCredentialsDataKey, N as readCredentialsForConfiguredRelay, O as encrypt, r as readPersistedSessions, P as isClaudeSessionId, w as writePrivateFileSync, Q as getLocalHappyAgentCredentialPath, T as readLocalHappyAgentCredentials, U as decryptWithDataKey, V as decryptLegacy, W as compareExactVersions, X as extractCompleteLines, Y as decideBackfill, Z as parseTerminalHookPayload, _ as tmuxArgs, $ as scrubTmuxClientEnv, a0 as decideMirrorBinding, a1 as MIRROR_BACKFILL_LINES_DEFAULT, a2 as persistSession, a3 as mirrorLineKey, a4 as mirrorLocalId, a5 as detectCLIAvailability, a6 as detectResumeSupport, a7 as acquireDaemonLock, a8 as summarizeSpawnSessionForLog, a9 as deletePersistedSessions, aa as shellescape, ab as decrypt, ac as writeDaemonState, A as ApiClient, ad as writeSettings, ae as fetchCliUpdateState, af as resolveCliUpdateCheckInterval, ag as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, ah as releaseDaemonLock, i as isValidSessionId, ai as listVhTerminals, aj as isValidTerminalId, ak as readVhTerminal, al as sendToVhTerminal, am as TITLE_PROMPT_PREFIX, an as BOARD_ANALYZER_PROMPT_PREFIX, d as connectionState, ao as startOfflineReconnection, ap as clearCredentials, aq as clearMachineId, m as ensurePrivateDirectorySync, ar as SandboxConfigSchema, b as createEnvelope, as as CodexAppServerClient, at as getLatestDaemonLog } from './types-q7wtjfxb.mjs';
+import { o as readDaemonState, l as logger, c as configuration, q as clearDaemonState, t as getProjectPath, p as projectPath, u as initializeSandbox, v as wrapCommand, g as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, k as delay, x as AsyncLock, S as STREAM_DELTA_MAX_CHARS, y as ensurePrivateDirectory, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, z as hardenPrivateFile, j as packageJson, B as commandOnPath, e as readSettings, C as readCredentials, D as credentialRelayProblem, E as deriveLocalCliUpdateSummary, f as encodeBase64, F as readSettingsOutcome, G as updateSettings, H as encodeBase64Url, J as decodeBase64, K as writeCredentialsLegacy, L as writeCredentialsDataKey, N as readCredentialsForConfiguredRelay, O as encrypt, r as readPersistedSessions, P as isClaudeSessionId, w as writePrivateFileSync, Q as getLocalHappyAgentCredentialPath, T as readLocalHappyAgentCredentials, U as decryptWithDataKey, V as decryptLegacy, W as parseExactVersion, X as compareExactVersions, Y as extractCompleteLines, Z as decideBackfill, _ as parseTerminalHookPayload, $ as tmuxArgs, a0 as scrubTmuxClientEnv, a1 as decideMirrorBinding, a2 as MIRROR_BACKFILL_LINES_DEFAULT, a3 as persistSession, a4 as mirrorLineKey, a5 as mirrorLocalId, a6 as detectCLIAvailability, a7 as detectResumeSupport, a8 as acquireDaemonLock, a9 as summarizeSpawnSessionForLog, aa as deletePersistedSessions, ab as shellescape, ac as decrypt, ad as writeDaemonState, A as ApiClient, ae as writeSettings, af as fetchCliUpdateState, ag as resolveCliUpdateCheckInterval, ah as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, ai as releaseDaemonLock, i as isValidSessionId, aj as listVhTerminals, ak as isValidTerminalId, al as readVhTerminal, am as sendToVhTerminal, an as TITLE_PROMPT_PREFIX, ao as BOARD_ANALYZER_PROMPT_PREFIX, d as connectionState, ap as startOfflineReconnection, aq as clearCredentials, ar as clearMachineId, m as ensurePrivateDirectorySync, as as SandboxConfigSchema, b as createEnvelope, at as CodexAppServerClient, au as getLatestDaemonLog } from './types-BqW7nEN_.mjs';
 import spawn$1, { spawn } from 'cross-spawn';
-import path, { join, resolve, basename, delimiter, isAbsolute, normalize, sep, dirname } from 'node:path';
+import path, { join, resolve, basename, isAbsolute, dirname, sep, delimiter, normalize } from 'node:path';
 import { createInterface } from 'node:readline';
 import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, unlinkSync, renameSync, writeFileSync, accessSync, constants, rmSync as rmSync$1, chmodSync as chmodSync$1 } from 'node:fs';
 import { t as trimIdent, A as AGENT_GUIDANCE, P as PREVIEW_TOOL_NAME, R as REPORT_PROGRESS_TOOL_NAME, a as PREVIEW_TOOL_TITLE, b as PREVIEW_TOOL_DESCRIPTION, c as REPORT_PROGRESS_TOOL_TITLE, d as REPORT_PROGRESS_TOOL_DESCRIPTION } from './agentGuidance-C2_pkgRI.mjs';
-import { readFile, writeFile, rename, unlink, mkdir, stat, open as open$1, appendFile } from 'node:fs/promises';
+import { readFile, writeFile, rename, unlink, mkdir, symlink, rm, readlink, lstat, stat, open as open$1, appendFile } from 'node:fs/promises';
 import fs, { watch, access } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
@@ -7298,24 +7298,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 = 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: spawn$3,
+  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, readlink, unlink, rm, readFile, symlink }, platform: process.platform };
+function ownedCliLink(link, target, packageDir) {
+  const resolved = resolve(dirname(link), target);
+  return resolved.startsWith(join(packageDir, "bin") + sep);
+}
+async function installCliSafely(version, deps = defaults) {
+  const parsed = 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 || !isAbsolute(root) || !isAbsolute(prefix) || basename(root) !== "node_modules" || resolve(prefix) === "/" || root.includes("\n") || prefix.includes("\n")) {
+    throw new Error("Cannot verify global npm paths; use manual install");
+  }
+  if (resolve(root) !== resolve(prefix, "lib/node_modules")) throw new Error("Unexpected npm root/prefix relationship");
+  const packageDir = 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(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 = 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(resolve(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 = 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 ?? homedir();
@@ -8592,45 +8865,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 = spawn$3("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;
@@ -9718,67 +9953,30 @@ async function startDaemon() {
         host: initialMachineMetadata.host
       })).then(() => logger.debug(`[DAEMON RUN] claimed the machine record for host ${initialMachineMetadata.host}`)).catch((error) => 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 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") {
-        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);
-      };
-      logger.warn(`[DAEMON RUN] auto-updating CLI to ${target} (machine idle)`);
-      report("installing");
-      try {
-        const code = await runNpmInstall(autoUpdateInstallArgs(target));
-        if (code === 0) {
-          logger.warn(`[DAEMON RUN] auto-update installed ${target}; handover follows once it verifies`);
-          report("installed");
+    let lastUpdateLog = "";
+    const updateController = createUpdateController({
+      policy: () => fetchCliUpdateState(configuration.serverUrl, packageJson.version),
+      enabled: async () => ((await readSettings()).cliAutoUpdate ?? "idle") !== "off",
+      idle: () => pidToTrackedSession.size === 0 && !apiMachine.hasLiveTerminals(),
+      install: installCliSafely,
+      publish: (state) => {
+        cliUpdateStateRef = state;
+        fileState = { ...fileState, cliUpdate: state };
+        writeDaemonState(fileState);
+        apiMachine.setCliUpdateState(state);
+        const logKey = JSON.stringify([state.autoUpdate?.state, state.autoUpdate?.version, state.autoUpdate?.detail]);
+        if (logKey !== lastUpdateLog) {
+          lastUpdateLog = logKey;
+          logger.warn(`[DAEMON RUN] CLI update: ${state.autoUpdate?.state} target=${state.autoUpdate?.version ?? "none"} detail=${state.autoUpdate?.detail ?? "none"}`);
         } else {
-          autoUpdateFailedVersion = target;
-          logger.warn(`[DAEMON RUN] auto-update of ${target} failed with exit ${code}`);
-          report("failed", `npm exited ${code}`);
+          logger.debug("[DAEMON RUN] CLI update policy refreshed");
         }
-      } catch (error) {
-        autoUpdateFailedVersion = target;
-        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 fetchCliUpdateState(configuration.serverUrl, packageJson.version);
-        if (!cliUpdate) return;
-        fileState = { ...fileState, cliUpdate };
-        writeDaemonState(fileState);
-        cliUpdateStateRef = cliUpdate;
-        apiMachine.setCliUpdateState(cliUpdate);
-        logger.debug(`[DAEMON RUN] CLI update policy checked: ${cliUpdate.status} (recommended=${cliUpdate.recommendedVersion ?? "none"}, minimum=${cliUpdate.minimumVersion ?? "none"})`);
-        await maybeAutoUpdate(cliUpdate);
-      } catch (error) {
-        logger.debug("[DAEMON RUN] CLI update policy check failed:", error);
-      } finally {
-        cliUpdateCheckRunning = false;
       }
-    };
+    });
+    apiMachine.setCliUpdateRetryHandler(updateController.retry);
+    const refreshCliUpdate = () => updateController.refresh().catch((error) => {
+      logger.debug("[DAEMON RUN] CLI update policy check failed:", error);
+    });
     void refreshCliUpdate();
     const cliUpdateIntervalMs = resolveCliUpdateCheckInterval(process.env.HAPPY_CLI_UPDATE_CHECK_INTERVAL);
     if (process.env.HAPPY_CLI_UPDATE_CHECK_INTERVAL && cliUpdateIntervalMs === DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS && process.env.HAPPY_CLI_UPDATE_CHECK_INTERVAL.trim() !== String(DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS)) {
@@ -9786,77 +9984,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) {
-        logger.debug(`[DAEMON RUN] Health check started at ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
-      }
-      for (const [pid, _] of pidToTrackedSession.entries()) {
-        try {
-          process.kill(pid, 0);
-        } catch (error) {
-          logger.debug(`[DAEMON RUN] Finalizing stale session with PID ${pid} (process no longer exists)`);
-          onChildExited(pid);
+    const restartOnStaleVersionAndHeartbeat = setInterval(serialTask(async () => {
+      try {
+        if (process.env.DEBUG) {
+          logger.debug(`[DAEMON RUN] Health check started at ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
         }
-      }
-      let bundleReplaced = false;
-      if (initialBundleMtimeMs > 0) {
-        try {
-          const currentMtimeMs = statSync$1(bundlePath).mtimeMs;
-          bundleReplaced = currentMtimeMs !== initialBundleMtimeMs;
-        } catch {
+        for (const [pid, _] of pidToTrackedSession.entries()) {
+          try {
+            process.kill(pid, 0);
+          } catch (error) {
+            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;
-            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 = statSync$1(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;
+                logger.warn(`[DAEMON RUN] holding handover: ${preflight.reason}`);
+              }
+              updateController.holdHandover(preflight.reason);
+              return;
+            }
+            if (updateController.isRunning() || pidToTrackedSession.size > 0 || apiMachine.hasLiveTerminals()) return;
+            lastHandoverHold = null;
+            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 releaseDaemonLock(daemonLockHandle);
+            await stopCaffeinate();
+            try {
+              spawnHappyCLI(["daemon", "start"], {
+                detached: true,
+                stdio: "ignore"
+              });
+            } catch (error) {
+              logger.debug("[DAEMON RUN] Failed to spawn new daemon, this is quite likely to happen during integration tests as we are cleaning out dist/ directory", error);
+            }
+            process.exit(0);
+          }
+        });
+        const daemonState = await readDaemonState();
+        if (daemonState && daemonState.pid !== process.pid) {
+          logger.debug("[DAEMON RUN] Somehow a different daemon was started without killing us. We should kill ourselves.");
+          requestShutdown("exception", "A different daemon was started without killing us. We should kill ourselves.");
         }
-        lastHandoverHold = null;
-        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 releaseDaemonLock(daemonLockHandle);
-        await stopCaffeinate();
         try {
-          spawnHappyCLI(["daemon", "start"], {
-            detached: true,
-            stdio: "ignore"
-          });
+          fileState = withDaemonHeartbeat(fileState, (/* @__PURE__ */ new Date()).toLocaleString());
+          writeDaemonState(fileState);
+          if (process.env.DEBUG) {
+            logger.debug(`[DAEMON RUN] Health check completed at ${fileState.lastHeartbeat}`);
+          }
         } catch (error) {
-          logger.debug("[DAEMON RUN] Failed to spawn new daemon, this is quite likely to happen during integration tests as we are cleaning out dist/ directory", error);
-        }
-        process.exit(0);
-      }
-      const daemonState = await readDaemonState();
-      if (daemonState && daemonState.pid !== process.pid) {
-        logger.debug("[DAEMON RUN] Somehow a different daemon was started without killing us. We should kill ourselves.");
-        requestShutdown("exception", "A different daemon was started without killing us. We should kill ourselves.");
-      }
-      try {
-        fileState = withDaemonHeartbeat(fileState, (/* @__PURE__ */ new Date()).toLocaleString());
-        writeDaemonState(fileState);
-        if (process.env.DEBUG) {
-          logger.debug(`[DAEMON RUN] Health check completed at ${fileState.lastHeartbeat}`);
+          logger.debug("[DAEMON RUN] Failed to write heartbeat", error);
         }
       } catch (error) {
-        logger.debug("[DAEMON RUN] Failed to write heartbeat", error);
+        logger.debug("[DAEMON RUN] Heartbeat failed:", error);
       }
-      heartbeatRunning = false;
-    }, heartbeatIntervalMs);
+    }), heartbeatIntervalMs);
     const cleanupAndShutdown = async (source, errorMessage) => {
       logger.debug(`[DAEMON RUN] Starting proper cleanup (source: ${source}, errorMessage: ${errorMessage})...`);
       if (restartOnStaleVersionAndHeartbeat) {
@@ -11296,7 +11496,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 import('./index-CaIsj1q7.mjs');
+    const { query } = await import('./index-vyYHKKk6.mjs');
     return runSideQuestion(query, input);
   });
   const slots = /* @__PURE__ */ new Map();
@@ -16247,7 +16447,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 import('./installTerminalHooks-DFmKhCto.mjs');
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-DqUPkh0l.mjs');
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -16264,7 +16464,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "spawn") {
     try {
-      const { handleSpawnCommand } = await import('./spawn-BRdfNDsu.mjs');
+      const { handleSpawnCommand } = await import('./spawn-D2egvPgO.mjs');
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -16276,7 +16476,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "sessions") {
     try {
-      const { handleSessionsCommand } = await import('./sessions-BuMgxuxd.mjs');
+      const { handleSessionsCommand } = await import('./sessions-DemgtCkr.mjs');
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -16288,7 +16488,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "send") {
     try {
-      const { handleSendCommand } = await import('./send-DRZppEr2.mjs');
+      const { handleSendCommand } = await import('./send-CT22-8Tp.mjs');
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -16394,9 +16594,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 import('./config-BTEW041n.mjs');
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./types-q7wtjfxb.mjs').then(function (n) { return n.au; });
-        const { ApiClient: ApiClient2 } = await import('./types-q7wtjfxb.mjs').then(function (n) { return n.av; });
+        const { saveGoogleCloudProjectToConfig } = await import('./config-alG86PDN.mjs');
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./types-BqW7nEN_.mjs').then(function (n) { return n.av; });
+        const { ApiClient: ApiClient2 } = await import('./types-BqW7nEN_.mjs').then(function (n) { return n.aw; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -16427,7 +16627,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 import('./config-BTEW041n.mjs');
+        const { readGeminiLocalConfig } = await import('./config-alG86PDN.mjs');
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -16467,7 +16667,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await import('./runGemini-BsfadDSa.mjs');
+      const { runGemini } = await import('./runGemini-BQa2eF3i.mjs');
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -16497,7 +16697,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       }
     };
     try {
-      const { runAcp, resolveAcpAgentConfig } = await import('./index-BeHr5uMY.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-Cg3Vfc00.mjs');
       const parsed = parsePiRunnerArgs(args.slice(1));
       const resolved = resolveAcpAgentConfig(["pi", ...parsed.passthrough]);
       const { credentials } = await authAndSetupMachineIfNeeded();
@@ -16524,7 +16724,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 import('./index-BeHr5uMY.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-Cg3Vfc00.mjs');
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -16564,7 +16764,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "openclaw") {
     try {
-      const { runOpenClaw } = await import('./runOpenClaw-xGtbJ7f8.mjs');
+      const { runOpenClaw } = await import('./runOpenClaw-362eg04u.mjs');
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -16615,7 +16815,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 import('./mcp-DnKBKXYa.mjs');
+      const { handleMcpCommand } = await import('./mcp-DZIdcsJp.mjs');
       await handleMcpCommand();
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}