happy-imou-cloud 2.0.0 → 2.0.2

package/dist/{index-C7Y0R-MI.mjs → index-B97L7qLD.mjs}

@@ -1,6 +1,6 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
-import { l as logger, e as encodeBase64, c as configuration, h as buildAuthenticatedHeaders, i as encodeBase64Url, f as delay, j as buildClientHeaders, k as decodeBase64, H as HAPPY_CLOUD_DAEMON_PORT, p as packageJson, A as ApiClient, m as getLatestDaemonLog } from './api-BGXYX0yH.mjs';
-import { readCredentials, readSettings, updateSettings, writeCredentialsLegacy, writeCredentialsDataKey, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-BA_unuca.mjs';
+import { l as logger, e as encodeBase64, c as configuration, h as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, j as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, k as encodeBase64Url, f as delay, m as buildClientHeaders, n as decodeBase64, H as HAPPY_CLOUD_DAEMON_PORT, p as packageJson, A as ApiClient, o as getLatestDaemonLog } from './api-MYhAGPLn.mjs';
+import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-Dkm7rm8k.mjs';
 import { z } from 'zod';
 import fs from 'fs/promises';
 import os, { homedir } from 'os';
@@ -12,7 +12,7 @@ import qrcode from 'qrcode-terminal';
 import { writeFile, unlink } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import os$1, { tmpdir, homedir as homedir$1 } from 'node:os';
-import path, { join, resolve as resolve$1, isAbsolute } from 'node:path';
+import { join, resolve as resolve$1, isAbsolute, delimiter } from 'node:path';
 import open from 'open';
 import React, { useState } from 'react';
 import { useInput, Box, Text, render } from 'ink';
@@ -23,7 +23,7 @@ import { readFileSync as readFileSync$1, existsSync as existsSync$1, writeFileSy
 import { execFileSync, spawn as spawn$2 } from 'node:child_process';
 import psList from 'ps-list';
 import spawn$1 from 'cross-spawn';
-import fs$1, { existsSync, readFileSync, readdirSync, statSync, rmSync, mkdirSync as mkdirSync$1 } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, statSync, rmSync, mkdirSync as mkdirSync$1 } from 'node:fs';
 import fastify from 'fastify';
 import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
 import { createInterface } from 'node:readline';
@@ -219,6 +219,64 @@ const AuthSelector = ({ onSelect, onCancel }) => {
   })), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "Use arrows or 1-2 to select, Enter to confirm")));
 };
 
+async function ensureSigningCredentials(credentials, opts = {}) {
+  if (credentials.signing) {
+    return credentials;
+  }
+  try {
+    const response = await axios.post(`${configuration.serverUrl}/v1/auth/refresh`, {}, {
+      headers: buildAuthenticatedHeaders({
+        credentials,
+        method: "POST",
+        url: `${configuration.serverUrl}/v1/auth/refresh`,
+        body: {},
+        headers: {
+          "Content-Type": "application/json"
+        },
+        signRequest: false
+      })
+    });
+    if (!response.data?.success || !response.data?.token || !response.data?.signing) {
+      logger.debug("[AUTH] Signing bootstrap returned incomplete payload", response.data);
+      throw new SigningBootstrapRequiredError(SIGNING_BOOTSTRAP_REQUIRED_MESSAGE);
+    }
+    const upgradedCredentials = {
+      ...credentials,
+      token: response.data.token,
+      signing: response.data.signing
+    };
+    if (upgradedCredentials.encryption.type === "legacy") {
+      await writeCredentialsLegacy({
+        secret: upgradedCredentials.encryption.secret,
+        token: upgradedCredentials.token,
+        signing: upgradedCredentials.signing
+      });
+    } else {
+      await writeCredentialsDataKey({
+        publicKey: upgradedCredentials.encryption.publicKey,
+        machineKey: upgradedCredentials.encryption.machineKey,
+        token: upgradedCredentials.token,
+        signing: upgradedCredentials.signing
+      });
+    }
+    logger.debug("[AUTH] Signing credentials bootstrapped successfully");
+    return upgradedCredentials;
+  } catch (error) {
+    if (axios.isAxiosError(error) && error.response?.status === 401) {
+      logger.debug("[AUTH] Signing bootstrap rejected with 401");
+      throw new SigningBootstrapRequiredError(SIGNING_BOOTSTRAP_REQUIRED_MESSAGE);
+    }
+    if (error instanceof SigningBootstrapRequiredError) {
+      throw error;
+    }
+    logger.debug("[AUTH] Failed to bootstrap signing credentials", error);
+    if (opts.failFast) {
+      throw new SigningBootstrapRequiredError(SIGNING_BOOTSTRAP_REQUIRED_MESSAGE);
+    }
+    return credentials;
+  }
+}
+
 function isNonInteractive() {
   return !process.stdin.isTTY || !process.stdout.isTTY;
 }
@@ -520,7 +578,7 @@ async function authAndSetupMachineIfNeeded() {
   } else {
     logger.debug("[AUTH] Using existing credentials");
   }
-  credentials = await ensureSigningCredentials(credentials);
+  credentials = await ensureSigningCredentials(credentials, { failFast: newAuth });
   const currentSettings = await readSettings();
   const settings = newAuth || !currentSettings.machineId ? await updateSettings(async (s) => ({
     ...s,
@@ -529,53 +587,6 @@ async function authAndSetupMachineIfNeeded() {
   logger.debug(`[AUTH] Machine ID: ${settings.machineId}`);
   return { credentials, machineId: settings.machineId };
 }
-async function ensureSigningCredentials(credentials) {
-  if (credentials.signing) {
-    return credentials;
-  }
-  try {
-    const response = await axios.post(`${configuration.serverUrl}/v1/auth/refresh`, {}, {
-      headers: buildAuthenticatedHeaders({
-        credentials,
-        method: "POST",
-        url: `${configuration.serverUrl}/v1/auth/refresh`,
-        body: {},
-        headers: {
-          "Content-Type": "application/json"
-        },
-        signRequest: false
-      })
-    });
-    if (!response.data?.success || !response.data?.token || !response.data?.signing) {
-      logger.debug("[AUTH] Signing bootstrap returned incomplete payload");
-      return credentials;
-    }
-    const upgradedCredentials = {
-      ...credentials,
-      token: response.data.token,
-      signing: response.data.signing
-    };
-    if (upgradedCredentials.encryption.type === "legacy") {
-      await writeCredentialsLegacy({
-        secret: upgradedCredentials.encryption.secret,
-        token: upgradedCredentials.token,
-        signing: upgradedCredentials.signing
-      });
-    } else {
-      await writeCredentialsDataKey({
-        publicKey: upgradedCredentials.encryption.publicKey,
-        machineKey: upgradedCredentials.encryption.machineKey,
-        token: upgradedCredentials.token,
-        signing: upgradedCredentials.signing
-      });
-    }
-    logger.debug("[AUTH] Signing credentials bootstrapped successfully");
-    return upgradedCredentials;
-  } catch (error) {
-    logger.debug("[AUTH] Failed to bootstrap signing credentials", error);
-    return credentials;
-  }
-}
 
 let caffeinateProcess = null;
 function startCaffeinate() {
@@ -958,6 +969,32 @@ async function checkIfDaemonRunningAndCleanupStaleState() {
     return false;
   }
 }
+async function isDaemonControlServerResponsive(timeoutMs = 1e3) {
+  const state = await readDaemonState();
+  if (!state?.httpPort) {
+    logger.debug("[DAEMON CONTROL] No daemon state or control port found for readiness check");
+    return false;
+  }
+  try {
+    process.kill(state.pid, 0);
+  } catch {
+    logger.debug("[DAEMON CONTROL] Daemon PID not running during readiness check, cleaning up state");
+    await cleanupDaemonState();
+    return false;
+  }
+  try {
+    const response = await fetch(`http://127.0.0.1:${state.httpPort}/list`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    return response.ok;
+  } catch (error) {
+    logger.debug("[DAEMON CONTROL] Daemon control server not ready yet", error);
+    return false;
+  }
+}
 async function isDaemonRunningCurrentlyInstalledHappyVersion() {
   logger.debug("[DAEMON CONTROL] Checking if daemon is running same version");
   const runningDaemon = await checkIfDaemonRunningAndCleanupStaleState();
@@ -975,7 +1012,10 @@ async function isDaemonRunningCurrentlyInstalledHappyVersion() {
     const packageJson = JSON.parse(readFileSync$1(packageJsonPath, "utf-8"));
     const currentCliVersion = packageJson.version;
     logger.debug(`[DAEMON CONTROL] Current CLI version: ${currentCliVersion}, Daemon started with version: ${state.startedWithCliVersion}`);
-    return currentCliVersion === state.startedWithCliVersion;
+    if (currentCliVersion !== state.startedWithCliVersion) {
+      return false;
+    }
+    return await isDaemonControlServerResponsive();
   } catch (error) {
     logger.debug("[DAEMON CONTROL] Error checking daemon version", error);
     return false;
@@ -1192,7 +1232,7 @@ ${typeLabels[type] || type}:`));
     }
     if (filter === "all" && allProcesses.length > 1) {
       console.log(chalk.bold("\n\u{1F4A1} Process Management"));
-      console.log(chalk.gray("To clean up runaway processes: happy doctor clean"));
+      console.log(chalk.gray("To clean up runaway processes: hicloud doctor clean"));
     }
   } catch (error) {
     console.log(chalk.red("\u274C Error checking daemon status"));
@@ -1374,7 +1414,8 @@ function startDaemonControlServer({
       schema: {
         body: z.object({
           directory: z.string(),
-          sessionId: z.string().optional()
+          sessionId: z.string().optional(),
+          agent: z.enum(["claude", "codex", "gemini"]).optional()
         }),
         response: {
           200: z.object({
@@ -1395,9 +1436,9 @@ function startDaemonControlServer({
         }
       }
     }, async (request, reply) => {
-      const { directory, sessionId } = request.body;
-      logger.debug(`[CONTROL SERVER] Spawn session request: dir=${directory}, sessionId=${sessionId || "new"}`);
-      const result = await spawnSession({ directory, sessionId });
+      const { directory, sessionId, agent } = request.body;
+      logger.debug(`[CONTROL SERVER] Spawn session request: dir=${directory}, sessionId=${sessionId || "new"}, agent=${agent || "claude"}`);
+      const result = await spawnSession({ directory, sessionId, agent });
       switch (result.type) {
         case "success":
           if (!result.sessionId) {
@@ -2912,13 +2953,13 @@ async function handleAuthCommand(args) {
 }
 function showAuthHelp() {
   console.log(`
-${chalk.bold("happy-cloud auth")} - Authentication management
+${chalk.bold("hicloud auth")} - Authentication management
 
 ${chalk.bold("Usage:")}
-  happy-cloud auth login [--force]    Authenticate with Happy
-  happy-cloud auth logout [--yes]     Remove authentication and machine data
-  happy-cloud auth status             Show authentication status
-  happy-cloud auth help               Show this help message
+  hicloud auth login [--force]    Authenticate with Happy
+  hicloud auth logout [--yes]     Remove authentication and machine data
+  hicloud auth status             Show authentication status
+  hicloud auth help               Show this help message
 
 ${chalk.bold("Options:")}
   --force    Clear credentials, machine ID, and stop daemon before re-auth
@@ -2958,7 +2999,7 @@ async function handleAuthLogin(args) {
       console.log(chalk.green("\u2713 Already authenticated"));
       console.log(chalk.gray(`  Machine ID: ${settings.machineId}`));
       console.log(chalk.gray(`  Host: ${os$1.hostname()}`));
-      console.log(chalk.gray(`  Use 'happy-cloud auth login --force' to re-authenticate`));
+      console.log(chalk.gray(`  Use 'hicloud auth login --force' to re-authenticate`));
       return;
     } else if (existingCreds && !settings?.machineId) {
       console.log(chalk.yellow("\u26A0\uFE0F  Credentials exist but machine ID is missing"));
@@ -2989,7 +3030,7 @@ async function handleAuthLogout(args = []) {
   let confirmed = skipConfirm;
   if (!confirmed) {
     if (isNonInteractive) {
-      throw new Error('Non-interactive terminal detected. Use "happy-cloud auth logout --yes" to confirm.');
+      throw new Error('Non-interactive terminal detected. Use "hicloud auth logout --yes" to confirm.');
     }
     const rl = createInterface({
       input: process.stdin,
@@ -3012,7 +3053,7 @@ async function handleAuthLogout(args = []) {
         rmSync(happyDir, { recursive: true, force: true });
       }
       console.log(chalk.green("\u2713 Successfully logged out"));
-      console.log(chalk.gray('  Run "happy-cloud auth login" to authenticate again'));
+      console.log(chalk.gray('  Run "hicloud auth login" to authenticate again'));
     } catch (error) {
       throw new Error(`Failed to logout: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
@@ -3026,20 +3067,20 @@ async function handleAuthStatus() {
   console.log(chalk.bold("\nAuthentication Status\n"));
   if (!credentials) {
     console.log(chalk.red("\u2717 Not authenticated"));
-    console.log(chalk.gray('  Run "happy-cloud auth login" to authenticate'));
+    console.log(chalk.gray('  Run "hicloud auth login" to authenticate'));
     return;
   }
   console.log(chalk.green("\u2713 Authenticated"));
   const tokenPreview = credentials.token.substring(0, 30) + "...";
   console.log(chalk.gray(`  Token: ${tokenPreview}`));
-  console.log(chalk.gray(`  Request signing: ${credentials.signing ? "ready" : "legacy credentials (will auto-upgrade on use)"}`));
+  console.log(chalk.gray(`  Request signing: ${describeSigningStatus(credentials)}`));
   if (settings?.machineId) {
     console.log(chalk.green("\u2713 Machine registered"));
     console.log(chalk.gray(`  Machine ID: ${settings.machineId}`));
     console.log(chalk.gray(`  Host: ${os$1.hostname()}`));
   } else {
     console.log(chalk.yellow("\u26A0\uFE0F  Machine not registered"));
-    console.log(chalk.gray('  Run "happy-cloud auth login --force" to fix this'));
+    console.log(chalk.gray('  Run "hicloud auth login --force" to fix this'));
   }
   console.log(chalk.gray(`
   Data directory: ${configuration.happyCloudHomeDir}`));
@@ -3054,6 +3095,12 @@ async function handleAuthStatus() {
     console.log(chalk.gray("\u2717 Daemon not running"));
   }
 }
+function describeSigningStatus(credentials) {
+  if (credentials.signing) {
+    return "ready";
+  }
+  return "not initialized (server write requests may still fail until signing bootstrap succeeds)";
+}
 
 const CLIENT_ID$2 = "app_EMoamEEZ73f0CkXaXp7hrann";
 const AUTH_BASE_URL = "https://auth.openai.com";
@@ -3570,14 +3617,14 @@ async function handleConnectCommand(args) {
 }
 function showConnectHelp() {
   console.log(`
-${chalk.bold("happy-cloud connect")} - Connect AI vendor API keys to Happy cloud
+${chalk.bold("hicloud connect")} - Connect AI vendor API keys to Happy cloud
 
 ${chalk.bold("Usage:")}
-  happy-cloud connect codex        Store your Codex API key in Happy cloud
-  happy-cloud connect claude       Store your Anthropic API key in Happy cloud
-  happy-cloud connect gemini       Store your Gemini API key in Happy cloud
-  happy-cloud connect status       Show connection status for all vendors
-  happy-cloud connect help         Show this help message
+  hicloud connect codex        Store your Codex API key in Happy cloud
+  hicloud connect claude       Store your Anthropic API key in Happy cloud
+  hicloud connect gemini       Store your Gemini API key in Happy cloud
+  hicloud connect status       Show connection status for all vendors
+  hicloud connect help         Show this help message
 
 ${chalk.bold("Description:")}
   The connect command allows you to securely store your AI vendor API keys
@@ -3585,13 +3632,13 @@ ${chalk.bold("Description:")}
   without exposing your API keys locally.
 
 ${chalk.bold("Examples:")}
-  happy-cloud connect codex
-  happy-cloud connect claude
-  happy-cloud connect gemini
-  happy-cloud connect status
+  hicloud connect codex
+  hicloud connect claude
+  hicloud connect gemini
+  hicloud connect status
 
 ${chalk.bold("Notes:")}
-  \u2022 You must be authenticated with Happy first (run 'happy-cloud auth login')
+  \u2022 You must be authenticated with Happy first (run 'hicloud auth login')
   \u2022 API keys are encrypted and stored securely in Happy cloud
   \u2022 You can manage your stored keys at https://happycloudcode.imou.com
 `);
@@ -3603,7 +3650,7 @@ async function handleConnectVendor(vendor, displayName) {
   const credentials = await readCredentials();
   if (!credentials) {
     console.log(chalk.yellow("\u26A0\uFE0F  Not authenticated with Happy"));
-    console.log(chalk.gray('  Please run "happy-cloud auth login" first'));
+    console.log(chalk.gray('  Please run "hicloud auth login" first'));
     process.exit(1);
   }
   const api = await ApiClient.create(credentials);
@@ -3635,7 +3682,7 @@ async function handleConnectStatus() {
   const credentials = await readCredentials();
   if (!credentials) {
     console.log(chalk.yellow("\u26A0\uFE0F  Not authenticated with Happy"));
-    console.log(chalk.gray('  Please run "happy-cloud auth login" first'));
+    console.log(chalk.gray('  Please run "hicloud auth login" first'));
     process.exit(1);
   }
   const api = await ApiClient.create(credentials);
@@ -3670,8 +3717,8 @@ async function handleConnectStatus() {
     }
   }
   console.log("");
-  console.log(chalk.gray("To connect a vendor, run: happy-cloud connect <vendor>"));
-  console.log(chalk.gray("Example: happy-cloud connect gemini"));
+  console.log(chalk.gray("To connect a vendor, run: hicloud connect <vendor>"));
+  console.log(chalk.gray("Example: hicloud connect gemini"));
   console.log("");
 }
 function updateLocalGeminiCredentials(tokens) {
@@ -3696,19 +3743,17 @@ function updateLocalGeminiCredentials(tokens) {
   }
 }
 
-function getProjectPath(workingDirectory) {
-  let resolved = resolve$1(workingDirectory);
-  if (process.platform === "win32" && isAbsolute(resolved)) {
-    resolved = resolved.replace(/^[A-Z]:/i, "");
-  }
-  const projectId = resolved.replace(/[\\\/\.: _]/g, "-");
-  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(homedir$1(), ".claude");
+function getProjectPath(workingDirectory, claudeConfigDirOverride) {
+  const projectId = resolve$1(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+  const claudeConfigDirRaw = process.env.CLAUDE_CONFIG_DIR ?? "";
+  const claudeConfigDirTrimmed = claudeConfigDirRaw.trim();
+  const claudeConfigDir = claudeConfigDirTrimmed ? claudeConfigDirTrimmed : join(homedir$1(), ".claude");
   return join(claudeConfigDir, "projects", projectId);
 }
 
-function claudeCheckSession(sessionId, path) {
+function claudeCheckSession(sessionId, path, transcriptPath) {
   const projectDir = getProjectPath(path);
-  const sessionFile = join(projectDir, `${sessionId}.jsonl`);
+  const sessionFile = transcriptPath ?? join(projectDir, `${sessionId}.jsonl`);
   const sessionExists = existsSync(sessionFile);
   if (!sessionExists) {
     logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
@@ -4056,6 +4101,77 @@ class AgentRegistry {
 }
 const agentRegistry = new AgentRegistry();
 
+const PREFERRED_MESSAGE_FIELDS = ["stderr", "error", "message", "detail", "stdout", "text", "reason"];
+function safeSerializeDisplayValue(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    const serialized = JSON.stringify(value, (_key, currentValue) => {
+      if (typeof currentValue === "bigint") {
+        return currentValue.toString();
+      }
+      if (currentValue instanceof Error) {
+        return {
+          name: currentValue.name,
+          message: currentValue.message,
+          stack: currentValue.stack
+        };
+      }
+      if (typeof currentValue === "object" && currentValue !== null) {
+        if (seen.has(currentValue)) {
+          return "[Circular]";
+        }
+        seen.add(currentValue);
+      }
+      return currentValue;
+    });
+    return serialized ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function formatDisplayMessage(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Error) {
+    return value.message || String(value);
+  }
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+    return value.toString("utf8");
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const record = value;
+    for (const field of PREFERRED_MESSAGE_FIELDS) {
+      if (!(field in record)) {
+        continue;
+      }
+      const formattedField = formatDisplayMessage(record[field], seen).trim();
+      if (formattedField.length > 0) {
+        return formattedField;
+      }
+    }
+    return safeSerializeDisplayValue(value);
+  }
+  return String(value);
+}
+function truncateDisplayMessage(value, maxLength) {
+  const formatted = formatDisplayMessage(value);
+  if (formatted.length <= maxLength) {
+    return formatted;
+  }
+  return `${formatted.substring(0, maxLength)}...`;
+}
+
 const DEFAULT_TIMEOUTS = {
   /** Default initialization timeout: 60 seconds */
   init: 6e4,
@@ -4350,7 +4466,7 @@ class CodexTransport extends DefaultTransport {
     return 800;
   }
 }
-const codexTransport = new CodexTransport();
+new CodexTransport();
 
 class ClaudeTransport extends DefaultTransport {
   constructor() {
@@ -4684,6 +4800,70 @@ const RETRY_CONFIG = {
   /** Maximum delay between retries in ms */
   maxDelayMs: 5e3
 };
+function getSessionUpdates(params) {
+  const notification = params;
+  const updates = Array.isArray(notification.updates) ? notification.updates.filter((update) => Boolean(update && typeof update === "object")) : [];
+  if (updates.length > 0) {
+    return updates;
+  }
+  if (notification.update && typeof notification.update === "object") {
+    return [notification.update];
+  }
+  return [];
+}
+function asNonNegativeFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function extractUsageTokens(record) {
+  const used = asNonNegativeFiniteNumber(record.used);
+  const size = asNonNegativeFiniteNumber(record.size);
+  if (used != null || size != null) {
+    const tokens2 = {
+      total: used ?? 0
+    };
+    if (used != null) tokens2.used = used;
+    if (size != null) tokens2.size = size;
+    return tokens2;
+  }
+  const input = asNonNegativeFiniteNumber(record.input_tokens) ?? asNonNegativeFiniteNumber(record.inputTokens) ?? asNonNegativeFiniteNumber(record.prompt_tokens) ?? asNonNegativeFiniteNumber(record.promptTokens);
+  const output = asNonNegativeFiniteNumber(record.output_tokens) ?? asNonNegativeFiniteNumber(record.outputTokens) ?? asNonNegativeFiniteNumber(record.completion_tokens) ?? asNonNegativeFiniteNumber(record.completionTokens);
+  const cacheRead = asNonNegativeFiniteNumber(record.cache_read_input_tokens) ?? asNonNegativeFiniteNumber(record.cacheReadInputTokens) ?? asNonNegativeFiniteNumber(record.cache_read_tokens) ?? asNonNegativeFiniteNumber(record.cacheReadTokens) ?? asNonNegativeFiniteNumber(record.cached_read_tokens) ?? asNonNegativeFiniteNumber(record.cachedReadTokens);
+  const cacheCreation = asNonNegativeFiniteNumber(record.cache_creation_input_tokens) ?? asNonNegativeFiniteNumber(record.cacheCreationInputTokens) ?? asNonNegativeFiniteNumber(record.cache_creation_tokens) ?? asNonNegativeFiniteNumber(record.cacheCreationTokens) ?? asNonNegativeFiniteNumber(record.cached_write_tokens) ?? asNonNegativeFiniteNumber(record.cachedWriteTokens);
+  const thought = asNonNegativeFiniteNumber(record.thought_tokens) ?? asNonNegativeFiniteNumber(record.thoughtTokens);
+  const totalFromPayload = asNonNegativeFiniteNumber(record.total_tokens) ?? asNonNegativeFiniteNumber(record.totalTokens);
+  const anyPresent = totalFromPayload != null || input != null || output != null || cacheRead != null || cacheCreation != null || thought != null;
+  if (!anyPresent) {
+    return null;
+  }
+  const total = totalFromPayload ?? (input ?? 0) + (output ?? 0) + (cacheRead ?? 0) + (cacheCreation ?? 0) + (thought ?? 0);
+  const tokens = { total };
+  if (input != null) tokens.input = input;
+  if (output != null) tokens.output = output;
+  if (cacheRead != null) tokens.cache_read = cacheRead;
+  if (cacheCreation != null) tokens.cache_creation = cacheCreation;
+  if (thought != null) tokens.thought = thought;
+  return tokens;
+}
+function isApprovalOption(option) {
+  if (option.optionId === "proceed_once" || option.optionId === "proceed_always" || option.optionId === "cancel") {
+    return true;
+  }
+  const searchable = `${option.name ?? ""} ${option.label ?? ""}`.toLowerCase();
+  return searchable.includes("once") || searchable.includes("always") || searchable.includes("cancel");
+}
+function isSelectionPermissionRequest(params) {
+  if (Array.isArray(params.codex_command) && params.codex_command.length > 0) {
+    return false;
+  }
+  if (params.requestedSchema?.properties?.optionId) {
+    return true;
+  }
+  const options = Array.isArray(params.options) ? params.options : [];
+  if (options.length === 0) {
+    return false;
+  }
+  return !options.every((option) => isApprovalOption(option));
+}
 function nodeToWebStreams(stdin, stdout) {
   const writable = new WritableStream({
     write(chunk) {
@@ -4747,7 +4927,7 @@ async function withRetry(operation, options) {
     try {
       return await operation();
     } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
+      lastError = normalizeAcpError(error);
       if (attempt < options.maxAttempts) {
         const delayMs = Math.min(
           options.baseDelayMs * Math.pow(2, attempt - 1),
@@ -4761,6 +4941,49 @@ async function withRetry(operation, options) {
   }
   throw lastError;
 }
+function formatAcpErrorMessage(error) {
+  if (error instanceof Error && error.message && error.message !== "[object Object]") {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null) {
+    const record = error;
+    const message = formatDisplayMessage(error).trim();
+    const code = record.code;
+    const status = record.status;
+    const prefix = [
+      code !== void 0 && code !== null ? `[code=${String(code)}]` : "",
+      status !== void 0 && status !== null ? `[status=${String(status)}]` : ""
+    ].filter(Boolean).join(" ");
+    if (message.length > 0) {
+      return prefix ? `${prefix} ${message}` : message;
+    }
+  }
+  const fallback = formatDisplayMessage(error).trim();
+  return fallback || "Unknown ACP error";
+}
+function normalizeAcpError(error) {
+  if (error instanceof Error && error.message && error.message !== "[object Object]") {
+    return error;
+  }
+  const normalized = new Error(formatAcpErrorMessage(error));
+  normalized.name = error instanceof Error ? error.name : "Error";
+  if (error && typeof error === "object") {
+    const { message: _message, ...rest } = error;
+    Object.assign(normalized, rest);
+  }
+  return normalized;
+}
+function enrichAcpError(error, stderrExcerpt) {
+  const normalized = normalizeAcpError(error);
+  if (!stderrExcerpt.trim()) {
+    return normalized;
+  }
+  const existingStderr = normalized.stderr;
+  if (typeof existingStderr !== "string" || existingStderr.trim().length === 0) {
+    Object.assign(normalized, { stderr: stderrExcerpt });
+  }
+  return normalized;
+}
 class AcpBackend {
   constructor(options) {
     this.options = options;
@@ -4788,6 +5011,21 @@ class AcpBackend {
   idleTimeout = null;
   /** Transport handler for agent-specific behavior */
   transport;
+  /** Keep a short rolling stderr buffer so startup failures can surface the real cause. */
+  recentStderrLines = [];
+  recordRecentStderr(text) {
+    const normalized = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    if (normalized.length === 0) {
+      return;
+    }
+    this.recentStderrLines.push(...normalized);
+    if (this.recentStderrLines.length > 12) {
+      this.recentStderrLines = this.recentStderrLines.slice(-12);
+    }
+  }
+  getRecentStderrExcerpt() {
+    return this.recentStderrLines.slice(-6).join("\n");
+  }
   onMessage(handler) {
     this.listeners.push(handler);
   }
@@ -4815,6 +5053,7 @@ class AcpBackend {
     this.emit({ type: "status", status: "starting" });
     try {
       logger.debug(`[AcpBackend] Starting session: ${sessionId}`);
+      this.recentStderrLines = [];
       const args = this.options.args || [];
       if (process.platform === "win32") {
         const fullCommand = [this.options.command, ...args].join(" ");
@@ -4841,6 +5080,7 @@ class AcpBackend {
       this.process.stderr.on("data", (data) => {
         const text = data.toString();
         if (!text.trim()) return;
+        this.recordRecentStderr(text);
         const hasActiveInvestigation = this.transport.isInvestigationTool ? Array.from(this.activeToolCalls).some((id) => this.transport.isInvestigationTool(id)) : false;
         const context = {
           activeToolCalls: this.activeToolCalls,
@@ -4951,6 +5191,7 @@ class AcpBackend {
           }
           this.toolCallCountSincePrompt++;
           const options = extendedParams.options || [];
+          const isSelectionRequest = isSelectionPermissionRequest(extendedParams);
           logger.debug(`[AcpBackend] Permission request: tool=${toolName}, toolCallId=${toolCallId}, input=`, JSON.stringify(input));
           logger.debug(`[AcpBackend] Permission request params structure:`, JSON.stringify({
             hasToolCall: !!toolCall,
@@ -4959,6 +5200,42 @@ class AcpBackend {
             paramsKind: extendedParams.kind,
             paramsKeys: Object.keys(params)
           }, null, 2));
+          if (isSelectionRequest) {
+            const selectionOptions = options.reduce((acc, option) => {
+              if (!option.optionId) {
+                return acc;
+              }
+              const displayOption = option;
+              acc.push({
+                optionId: option.optionId,
+                label: displayOption.label || option.name || option.optionId,
+                description: displayOption.description || option.name || option.optionId
+              });
+              return acc;
+            }, []);
+            if (selectionOptions.length === 0) {
+              logger.debug("[AcpBackend] Selection request has no valid options, cancelling");
+              return { outcome: { outcome: "selected", optionId: "cancel" } };
+            }
+            if (!this.options.selectionHandler) {
+              logger.debug("[AcpBackend] No selection handler configured, cancelling selection request");
+              return { outcome: { outcome: "selected", optionId: "cancel" } };
+            }
+            try {
+              const selectionMessage = typeof extendedParams.message === "string" && extendedParams.message.trim().length > 0 ? extendedParams.message : formatDisplayMessage(input).trim() || toolName;
+              const requestId = extendedParams.codex_event_id || extendedParams.codex_elicitation || toolCallId;
+              const response = await this.options.selectionHandler.handleSelection({
+                id: requestId,
+                message: selectionMessage,
+                options: selectionOptions,
+                defaultOptionId: extendedParams.requestedSchema?.properties?.optionId?.default
+              });
+              return { outcome: { outcome: "selected", optionId: response.optionId } };
+            } catch (error) {
+              logger.debug("[AcpBackend] Error in selection handler:", error);
+              return { outcome: { outcome: "selected", optionId: "cancel" } };
+            }
+          }
           this.emit({
             type: "permission-request",
             id: permissionId,
@@ -5132,18 +5409,19 @@ class AcpBackend {
       if (initialPrompt) {
         this.sendPrompt(sessionId, initialPrompt).catch((error) => {
           logger.debug("[AcpBackend] Error sending initial prompt:", error);
-          this.emit({ type: "status", status: "error", detail: String(error) });
+          this.emit({ type: "status", status: "error", detail: formatAcpErrorMessage(error) });
         });
       }
       return { sessionId };
     } catch (error) {
-      logger.debug("[AcpBackend] Error starting session:", error);
+      const enrichedError = enrichAcpError(error, this.getRecentStderrExcerpt());
+      logger.debug("[AcpBackend] Error starting session:", enrichedError);
       this.emit({
         type: "status",
         status: "error",
-        detail: error instanceof Error ? error.message : String(error)
+        detail: formatAcpErrorMessage(enrichedError)
       });
-      throw error;
+      throw enrichedError;
     }
   }
   /**
@@ -5174,51 +5452,73 @@ class AcpBackend {
       }
     };
   }
+  emitUsageTelemetry(payload, source) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+      return false;
+    }
+    const tokens = extractUsageTokens(payload);
+    if (!tokens) {
+      return false;
+    }
+    this.emit({
+      type: "token-count",
+      key: source,
+      tokens,
+      source
+    });
+    return true;
+  }
   handleSessionUpdate(params) {
-    const notification = params;
-    const update = notification.update;
-    if (!update) {
+    const updates = getSessionUpdates(params);
+    if (updates.length === 0) {
       logger.debug("[AcpBackend] Received session update without update field:", params);
       return;
     }
-    const sessionUpdateType = update.sessionUpdate;
-    if (sessionUpdateType !== "agent_message_chunk") {
-      logger.debug(`[AcpBackend] Received session update: ${sessionUpdateType}`, JSON.stringify({
-        sessionUpdate: sessionUpdateType,
-        toolCallId: update.toolCallId,
-        status: update.status,
-        kind: update.kind,
-        hasContent: !!update.content,
-        hasLocations: !!update.locations
-      }, null, 2));
-    }
-    const ctx = this.createHandlerContext();
-    if (sessionUpdateType === "agent_message_chunk") {
-      handleAgentMessageChunk(update, ctx);
-      return;
-    }
-    if (sessionUpdateType === "tool_call_update") {
-      const result = handleToolCallUpdate(update, ctx);
-      if (result.toolCallCountSincePrompt !== void 0) {
-        this.toolCallCountSincePrompt = result.toolCallCountSincePrompt;
+    for (const update of updates) {
+      const sessionUpdateType = update.sessionUpdate;
+      if (sessionUpdateType !== "agent_message_chunk") {
+        logger.debug(`[AcpBackend] Received session update: ${sessionUpdateType}`, JSON.stringify({
+          sessionUpdate: sessionUpdateType,
+          toolCallId: update.toolCallId,
+          status: update.status,
+          kind: update.kind,
+          hasContent: !!update.content,
+          hasLocations: !!update.locations
+        }, null, 2));
+      }
+      const ctx = this.createHandlerContext();
+      if (sessionUpdateType === "agent_message_chunk") {
+        handleAgentMessageChunk(update, ctx);
+        continue;
+      }
+      if (sessionUpdateType === "tool_call_update") {
+        const result = handleToolCallUpdate(update, ctx);
+        if (result.toolCallCountSincePrompt !== void 0) {
+          this.toolCallCountSincePrompt = result.toolCallCountSincePrompt;
+        }
+        continue;
+      }
+      if (sessionUpdateType === "agent_thought_chunk") {
+        handleAgentThoughtChunk(update, ctx);
+        continue;
+      }
+      if (sessionUpdateType === "tool_call") {
+        handleToolCall(update, ctx);
+        continue;
+      }
+      if (sessionUpdateType === "usage_update") {
+        this.emitUsageTelemetry(update, "acp-usage-update");
+        continue;
+      }
+      const handledLegacy = handleLegacyMessageChunk(update, ctx).handled;
+      const handledPlan = handlePlanUpdate(update, ctx).handled;
+      const handledThinking = handleThinkingUpdate(update, ctx).handled;
+      const handledUsage = this.emitUsageTelemetry(update.usage, "acp-session-usage");
+      const updateTypeStr = sessionUpdateType;
+      const handledTypes = ["agent_message_chunk", "tool_call_update", "agent_thought_chunk", "tool_call", "usage_update"];
+      if (updateTypeStr && !handledTypes.includes(updateTypeStr) && !handledLegacy && !handledPlan && !handledThinking && !handledUsage) {
+        logger.debug(`[AcpBackend] Unhandled session update type: ${updateTypeStr}`, JSON.stringify(update, null, 2));
       }
-      return;
-    }
-    if (sessionUpdateType === "agent_thought_chunk") {
-      handleAgentThoughtChunk(update, ctx);
-      return;
-    }
-    if (sessionUpdateType === "tool_call") {
-      handleToolCall(update, ctx);
-      return;
-    }
-    handleLegacyMessageChunk(update, ctx);
-    handlePlanUpdate(update, ctx);
-    handleThinkingUpdate(update, ctx);
-    const updateTypeStr = sessionUpdateType;
-    const handledTypes = ["agent_message_chunk", "tool_call_update", "agent_thought_chunk", "tool_call"];
-    if (updateTypeStr && !handledTypes.includes(updateTypeStr) && !update.messageChunk && !update.plan && !update.thinking) {
-      logger.debug(`[AcpBackend] Unhandled session update type: ${updateTypeStr}`, JSON.stringify(update, null, 2));
     }
   }
   // Promise resolver for waitForIdle - set when waiting for response to complete
@@ -5255,17 +5555,9 @@ class AcpBackend {
       if (error instanceof Error) {
         errorDetail = error.message;
       } else if (typeof error === "object" && error !== null) {
-        const errObj = error;
-        const fallbackMessage = (typeof errObj.message === "string" ? errObj.message : void 0) || String(error);
-        if (errObj.code !== void 0) {
-          errorDetail = JSON.stringify({ code: errObj.code, message: fallbackMessage });
-        } else if (typeof errObj.message === "string") {
-          errorDetail = errObj.message;
-        } else {
-          errorDetail = String(error);
-        }
+        errorDetail = formatAcpErrorMessage(error);
       } else {
-        errorDetail = String(error);
+        errorDetail = formatAcpErrorMessage(error);
       }
       this.emit({
         type: "status",
@@ -5616,59 +5908,213 @@ function registerGeminiAgent() {
   logger.debug("[Gemini] Registered with agent registry");
 }
 
-function firstExistingPath(candidates) {
-  for (const candidate of candidates) {
-    try {
-      if (fs$1.existsSync(candidate)) {
+function readFirstEnv(...names) {
+  for (const name of names) {
+    const raw = process.env[name];
+    if (typeof raw === "string" && raw.trim()) {
+      return raw.trim();
+    }
+  }
+  return "";
+}
+function normalizeCommandPath(command) {
+  if (isAbsolute(command)) {
+    return command;
+  }
+  const resolved = resolve$1(process.cwd(), command);
+  return existsSync(resolved) ? resolved : command;
+}
+function resolveCommandOnPath(command) {
+  const pathValue = typeof process.env.PATH === "string" ? process.env.PATH : "";
+  if (!pathValue) {
+    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(delimiter)) {
+    const trimmedDir = dir.trim();
+    if (!trimmedDir) {
+      continue;
+    }
+    const directCandidate = join(trimmedDir, command);
+    if (existsSync(directCandidate)) {
+      return directCandidate;
+    }
+    if (process.platform !== "win32") {
+      continue;
+    }
+    const hasExtension = /\.[^\\/]+$/.test(command);
+    if (hasExtension) {
+      continue;
+    }
+    for (const extension of extensions) {
+      const candidate = join(trimmedDir, `${command}${extension.toLowerCase()}`);
+      if (existsSync(candidate)) {
         return candidate;
       }
-    } catch {
     }
   }
   return null;
 }
-function resolveCodexExecutable() {
-  if (process.platform === "win32") {
-    const appData = process.env.APPDATA || path.join(os$1.homedir(), "AppData", "Roaming");
-    const npmGlobalBin = path.join(appData, "npm");
-    const resolved = firstExistingPath([
-      path.join(npmGlobalBin, "codex.cmd"),
-      path.join(npmGlobalBin, "codex.ps1"),
-      path.join(npmGlobalBin, "codex")
-    ]);
-    if (resolved) {
-      return resolved;
-    }
+function readCodexAcpNpxMode() {
+  const raw = readFirstEnv("HAPPY_CODEX_ACP_NPX_MODE", "HAPPIER_CODEX_ACP_NPX_MODE").toLowerCase();
+  if (raw === "auto" || raw === "never" || raw === "force") {
+    return raw;
   }
-  return "codex";
+  return "auto";
+}
+function isBinOnPath(baseName) {
+  return resolveCommandOnPath(baseName) !== null;
 }
-function shouldUseShellForCodex(executable) {
-  return process.platform === "win32" && /\.(cmd|bat|ps1)$/i.test(executable);
+function readCodexAcpConfigOverrides() {
+  const raw = readFirstEnv("HAPPY_CODEX_ACP_CONFIG_OVERRIDES", "HAPPIER_CODEX_ACP_CONFIG_OVERRIDES");
+  return raw.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+function buildCodexAcpConfigArgs(options) {
+  const args = [...options.baseArgs ?? []];
+  const overrides = [...readCodexAcpConfigOverrides()];
+  if (options.model) {
+    overrides.push(`model=${JSON.stringify(options.model)}`);
+  }
+  if (options.approvalPolicy) {
+    overrides.push(`approval_policy=${JSON.stringify(options.approvalPolicy)}`);
+  }
+  if (options.sandbox) {
+    overrides.push(`sandbox_mode=${JSON.stringify(options.sandbox)}`);
+  }
+  for (const override of overrides) {
+    args.push("-c", override);
+  }
+  return args;
+}
+function resolveNpxCommand() {
+  return resolveCommandOnPath(process.platform === "win32" ? "npx.cmd" : "npx") ?? resolveCommandOnPath("npx") ?? (process.platform === "win32" ? "npx.cmd" : "npx");
+}
+function resolveCodexAcpSpawn(options = {}) {
+  if (options.args) {
+    const command = normalizeCommandPath(options.command || readFirstEnv("HAPPY_CODEX_ACP_BIN", "HAPPY_CODEX_ACP_COMMAND", "HAPPIER_CODEX_ACP_BIN") || "codex-acp");
+    return {
+      command,
+      args: [...options.args]
+    };
+  }
+  const directArgs = buildCodexAcpConfigArgs(options);
+  if (options.command) {
+    return {
+      command: normalizeCommandPath(options.command),
+      args: directArgs
+    };
+  }
+  const envOverride = readFirstEnv("HAPPY_CODEX_ACP_BIN", "HAPPY_CODEX_ACP_COMMAND", "HAPPIER_CODEX_ACP_BIN");
+  if (envOverride) {
+    return {
+      command: normalizeCommandPath(envOverride),
+      args: directArgs
+    };
+  }
+  const npxMode = readCodexAcpNpxMode();
+  const codexAcpOnPath = resolveCommandOnPath(process.platform === "win32" ? "codex-acp.cmd" : "codex-acp") ?? resolveCommandOnPath("codex-acp");
+  if (npxMode !== "force" && codexAcpOnPath) {
+    return {
+      command: codexAcpOnPath,
+      args: directArgs
+    };
+  }
+  if (npxMode === "never") {
+    return {
+      command: process.platform === "win32" ? "codex-acp.cmd" : "codex-acp",
+      args: directArgs
+    };
+  }
+  return {
+    command: resolveNpxCommand(),
+    args: ["--prefer-offline", "-y", "@zed-industries/codex-acp", ...directArgs]
+  };
+}
+function validateCodexAcpSpawn(options = {}) {
+  let spawn;
+  try {
+    spawn = resolveCodexAcpSpawn(options);
+  } catch (error) {
+    return {
+      ok: false,
+      errorMessage: error instanceof Error ? error.message : "Codex ACP is enabled, but the command could not be resolved."
+    };
+  }
+  const normalizedCommand = spawn.command.trim();
+  const commandLower = normalizedCommand.toLowerCase();
+  const npxMode = readCodexAcpNpxMode();
+  if (isAbsolute(normalizedCommand)) {
+    if (!existsSync(normalizedCommand)) {
+      return {
+        ok: false,
+        errorMessage: `Codex ACP is enabled, but the resolved command does not exist: ${normalizedCommand}`
+      };
+    }
+    return { ok: true, spawn };
+  }
+  if (commandLower.endsWith("npx") || commandLower.endsWith("npx.cmd")) {
+    if (isBinOnPath("npx") || isBinOnPath("npx.cmd")) {
+      return { ok: true, spawn };
+    }
+    return {
+      ok: false,
+      errorMessage: "Codex ACP is enabled, but codex-acp is not installed and npx is not available. Install codex-acp, install Node.js/npm so npx is available, or set HAPPY_CODEX_ACP_BIN to a working codex-acp executable."
+    };
+  }
+  if (commandLower === "codex-acp" || commandLower === "codex-acp.cmd") {
+    if (isBinOnPath("codex-acp") || isBinOnPath("codex-acp.cmd")) {
+      return { ok: true, spawn };
+    }
+    return {
+      ok: false,
+      errorMessage: npxMode === "never" ? "Codex ACP is enabled, but codex-acp is not installed and npx fallback is disabled. Install codex-acp, add it to PATH, or set HAPPY_CODEX_ACP_BIN to the executable." : "Codex ACP is enabled, but codex-acp could not be resolved on PATH. Install codex-acp, add it to PATH, or set HAPPY_CODEX_ACP_BIN to the executable."
+    };
+  }
+  return { ok: true, spawn };
 }
 
-function defaultCodexArgs() {
-  return ["mcp-server"];
+class CodexAcpTransport extends CodexTransport {
+  constructor(initTimeoutMs) {
+    super();
+    this.initTimeoutMs = initTimeoutMs;
+  }
+  getInitTimeout() {
+    return this.initTimeoutMs;
+  }
+}
+function resolveCodexTransport(command) {
+  if (/npx(?:\.cmd)?$/i.test(command)) {
+    return new CodexAcpTransport(18e4);
+  }
+  return new CodexAcpTransport(6e4);
 }
 function createCodexBackend(options) {
-  const command = options.command ?? process.env.HAPPY_CODEX_ACP_COMMAND ?? resolveCodexExecutable();
-  const args = options.args ?? defaultCodexArgs();
+  const spawn = resolveCodexAcpSpawn({
+    command: options.command,
+    args: options.args,
+    baseArgs: options.baseArgs,
+    model: options.model,
+    sandbox: options.sandbox,
+    approvalPolicy: options.approvalPolicy
+  });
   const backendOptions = {
     agentName: "codex",
     cwd: options.cwd,
-    command,
-    args,
+    command: spawn.command,
+    args: spawn.args,
     env: {
       ...options.env,
       NODE_ENV: "production"
     },
     mcpServers: options.mcpServers,
     permissionHandler: options.permissionHandler,
-    transportHandler: codexTransport
+    selectionHandler: options.selectionHandler,
+    transportHandler: resolveCodexTransport(spawn.command)
   };
   return {
     backend: new AcpBackend(backendOptions),
-    command,
-    args
+    command: spawn.command,
+    args: spawn.args
   };
 }
 function registerCodexAgent() {
@@ -5854,17 +6300,26 @@ async function ensureUnifiedDaemonStarted() {
     env: process.env
   });
   daemonProcess.unref();
-  await new Promise((resolve) => setTimeout(resolve, 200));
+  for (let i = 0; i < 100; i++) {
+    if (await isDaemonRunningCurrentlyInstalledHappyVersion()) {
+      return;
+    }
+    if (await isDaemonControlServerResponsive(500)) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error("Failed to start Happy background service.");
 }
 async function executeUnifiedProvider(opts) {
   const credentials = await ensureUnifiedRuntimePrerequisites(opts.credentials);
   if (opts.provider === "claude") {
-    const { runClaude } = await import('./runClaude-uNC5Eym4.mjs');
+    const { runClaude } = await import('./runClaude-Cii3R2Fv.mjs');
     await runClaude(credentials, opts.claudeOptions ?? {});
     return;
   }
   if (opts.provider === "codex") {
-    const { runCodex } = await import('./runCodex-B-05E-YZ.mjs');
+    const { runCodex } = await import('./runCodex-C--ZwAhl.mjs');
     await runCodex({
       credentials,
       startedBy: opts.startedBy,
@@ -5874,7 +6329,7 @@ async function executeUnifiedProvider(opts) {
     return;
   }
   if (opts.provider === "gemini") {
-    const { runGemini } = await import('./runGemini-_biXvQAH.mjs');
+    const { runGemini } = await import('./runGemini-CQp7Nuzn.mjs');
     await runGemini({
       credentials,
       startedBy: opts.startedBy
@@ -5887,6 +6342,10 @@ async function executeUnifiedProvider(opts) {
   });
 }
 
+function shouldRunMainClaudeFlow(opts) {
+  return !opts.showHelp && !opts.showVersion;
+}
+
 (async () => {
   const args = process.argv.slice(2);
   const isRemoteMode = args.includes("--happy-starting-mode") && args.includes("remote");
@@ -5895,7 +6354,7 @@ async function executeUnifiedProvider(opts) {
     Object.defineProperty(process.stderr, "isTTY", { value: false });
   }
   if (!args.includes("--version")) {
-    logger.debug("Starting happy-cloud CLI with args: ", process.argv);
+    logger.debug("Starting hicloud CLI with args: ", process.argv);
   }
   const subcommand = args[0];
   if (!args.includes("--version")) ;
@@ -5912,7 +6371,7 @@ async function executeUnifiedProvider(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await import('./command-CnLtKtP-.mjs');
+      const { renderRuntimeProviders } = await import('./command-nmK6O-ab.mjs');
       console.log(renderRuntimeProviders());
       return;
     }
@@ -5938,8 +6397,8 @@ async function executeUnifiedProvider(opts) {
       }
       return;
     }
-    console.log("Usage: happy-cloud runtime providers");
-    console.log("       happy-cloud runtime launch <claude|codex|gemini|cursor> [prompt]");
+    console.log("Usage: hicloud runtime providers");
+    console.log("       hicloud runtime launch <claude|codex|gemini|cursor> [prompt]");
     return;
   } else if (subcommand === "auth") {
     try {
@@ -6090,8 +6549,8 @@ async function executeUnifiedProvider(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await import('./persistence-BA_unuca.mjs');
-        const { ApiClient: ApiClient2 } = await import('./api-BGXYX0yH.mjs').then(function (n) { return n.n; });
+        const { readCredentials: readCredentials2 } = await import('./persistence-Dkm7rm8k.mjs');
+        const { ApiClient: ApiClient2 } = await import('./api-MYhAGPLn.mjs').then(function (n) { return n.q; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();
@@ -6137,7 +6596,7 @@ async function executeUnifiedProvider(opts) {
           console.log("No Google Cloud Project configured.");
           console.log("");
           console.log('If you see "Authentication required" error, you may need to set a project:');
-          console.log("  happy-cloud gemini project set <your-project-id>");
+          console.log("  hicloud gemini project set <your-project-id>");
           console.log("");
           console.log("This is required for Google Workspace accounts.");
           console.log("Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca");
@@ -6149,7 +6608,7 @@ async function executeUnifiedProvider(opts) {
       }
     }
     if (geminiSubcommand === "project" && !args[2]) {
-      console.log("Usage: happy-cloud gemini project <command>");
+      console.log("Usage: hicloud gemini project <command>");
       console.log("");
       console.log("Commands:");
       console.log("  set <project-id>   Set Google Cloud Project ID");
@@ -6181,7 +6640,7 @@ async function executeUnifiedProvider(opts) {
     }
     return;
   } else if (subcommand === "logout") {
-    console.log(chalk.yellow('Note: "happy-cloud logout" is deprecated. Use "happy-cloud auth logout" instead.\n'));
+    console.log(chalk.yellow('Note: "hicloud logout" is deprecated. Use "hicloud auth logout" instead.\n'));
     try {
       await handleAuthCommand(["logout"]);
     } catch (error) {
@@ -6240,7 +6699,7 @@ async function executeUnifiedProvider(opts) {
       child.unref();
       let started = false;
       for (let i = 0; i < 100; i++) {
-        if (await checkIfDaemonRunningAndCleanupStaleState()) {
+        if (await checkIfDaemonRunningAndCleanupStaleState() && await isDaemonControlServerResponsive(500)) {
           started = true;
           break;
         }
@@ -6297,20 +6756,20 @@ async function executeUnifiedProvider(opts) {
       }
     } else {
       console.log(`
-${chalk.bold("happy-cloud daemon")} - Daemon management
+${chalk.bold("hicloud daemon")} - Daemon management
 
 ${chalk.bold("Usage:")}
-  happy-cloud daemon start              Start the daemon (detached)
-  happy-cloud daemon stop               Stop the daemon (sessions stay alive)
-  happy-cloud daemon status             Show daemon status
-  happy-cloud daemon list               List active sessions
+  hicloud daemon start              Start the daemon (detached)
+  hicloud daemon stop               Stop the daemon (sessions stay alive)
+  hicloud daemon status             Show daemon status
+  hicloud daemon list               List active sessions
 
   If you want to kill all happy related processes run
-  ${chalk.cyan("happy-cloud doctor clean")}
+  ${chalk.cyan("hicloud doctor clean")}
 
 ${chalk.bold("Note:")} The daemon runs in the background and manages Claude sessions.
 
-${chalk.bold("To clean up runaway processes:")} Use ${chalk.cyan("happy-cloud doctor clean")}
+${chalk.bold("To clean up runaway processes:")} Use ${chalk.cyan("hicloud doctor clean")}
 `);
     }
     return;
@@ -6385,33 +6844,33 @@ ${chalk.bold("To clean up runaway processes:")} Use ${chalk.cyan("happy-cloud do
 ${chalk.bold(BRAND_CONFIG.name)} - AI \u7F16\u7A0B\u52A9\u624B
 
 ${chalk.bold("Usage:")}
-  happy-cloud [options]         Start Claude with mobile control
-  happy-cloud auth              Manage authentication
-  happy-cloud codex             Start Codex mode
-  happy-cloud gemini            Start Gemini mode (ACP)
-  happy-cloud cursor            Start Cursor mode (experimental ACP)
-  happy-cloud connect           Connect AI vendor API keys
-  happy-cloud notify            Send push notification
-  happy-cloud daemon            Manage background service that allows
+  hicloud [options]         Start Claude with mobile control
+  hicloud auth              Manage authentication
+  hicloud codex             Start Codex mode
+  hicloud gemini            Start Gemini mode (ACP)
+  hicloud cursor            Start Cursor mode (experimental ACP)
+  hicloud connect           Connect AI vendor API keys
+  hicloud notify            Send push notification
+  hicloud daemon            Manage background service that allows
                             to spawn new sessions away from your computer
-  happy-cloud doctor            System diagnostics & troubleshooting
+  hicloud doctor            System diagnostics & troubleshooting
 
 ${chalk.bold("Examples:")}
-  happy-cloud                    Start session
-  happy-cloud --yolo             Start with bypassing permissions
-                            happy-cloud sugar for --dangerously-skip-permissions
-  happy-cloud --chrome           Enable Chrome browser access for this session
-  happy-cloud --no-chrome        Disable Chrome even if default is on
-  happy-cloud --js-runtime bun   Use bun instead of node to spawn Claude Code
-  happy-cloud --claude-env ANTHROPIC_BASE_URL=http://127.0.0.1:3456
+  hicloud                    Start session
+  hicloud --yolo             Start with bypassing permissions
+                            hicloud sugar for --dangerously-skip-permissions
+  hicloud --chrome           Enable Chrome browser access for this session
+  hicloud --no-chrome        Disable Chrome even if default is on
+  hicloud --js-runtime bun   Use bun instead of node to spawn Claude Code
+  hicloud --claude-env ANTHROPIC_BASE_URL=http://127.0.0.1:3456
                            Use a custom API endpoint (e.g., claude-code-router)
-  happy-cloud auth login --force Authenticate
-  happy-cloud doctor             Run diagnostics
+  hicloud auth login --force Authenticate
+  hicloud doctor             Run diagnostics
 
 ${chalk.bold(`${BRAND_CONFIG.name} supports ALL Claude options!`)}
-  Use any claude flag with happy-cloud as you would with claude. Our favorite:
+  Use any claude flag with hicloud as you would with claude. Our favorite:
 
-  happy-cloud --resume
+  hicloud --resume
 
 ${chalk.gray("\u2500".repeat(60))}
 ${chalk.bold.cyan("Claude Code Options (from `claude --help`):")}
@@ -6426,8 +6885,9 @@ ${chalk.bold.cyan("Claude Code Options (from `claude --help`):")}
     }
     if (showVersion) {
       console.log(getVersionString());
+      return;
     }
-    if (!showHelp && !showVersion) {
+    if (shouldRunMainClaudeFlow({ showHelp, showVersion })) {
       printBanner();
     }
     try {
@@ -6463,31 +6923,31 @@ async function handleNotifyCommand(args) {
   }
   if (showHelp) {
     console.log(`
-${chalk.bold("happy-cloud notify")} - Send notification
+${chalk.bold("hicloud notify")} - Send notification
 
 ${chalk.bold("Usage:")}
-  happy-cloud notify -p <message> [-t <title>]    Send notification with custom message and optional title
-  happy-cloud notify -h, --help                   Show this help
+  hicloud notify -p <message> [-t <title>]    Send notification with custom message and optional title
+  hicloud notify -h, --help                   Show this help
 
 ${chalk.bold("Options:")}
   -p <message>    Notification message (required)
   -t <title>      Notification title (optional, defaults to "Happy")
 
 ${chalk.bold("Examples:")}
-  happy-cloud notify -p "Deployment complete!"
-  happy-cloud notify -p "System update complete" -t "Server Status"
-  happy-cloud notify -t "Alert" -p "Database connection restored"
+  hicloud notify -p "Deployment complete!"
+  hicloud notify -p "System update complete" -t "Server Status"
+  hicloud notify -t "Alert" -p "Database connection restored"
 `);
     return;
   }
   if (!message) {
     console.error(chalk.red('Error: Message is required. Use -p "your message" to specify the notification text.'));
-    console.log(chalk.gray('Run "happy-cloud notify --help" for usage information.'));
+    console.log(chalk.gray('Run "hicloud notify --help" for usage information.'));
     process.exit(1);
   }
   let credentials = await readCredentials();
   if (!credentials) {
-    console.error(chalk.red('Error: Not authenticated. Please run "happy-cloud auth login" first.'));
+    console.error(chalk.red('Error: Not authenticated. Please run "hicloud auth login" first.'));
     process.exit(1);
   }
   console.log(chalk.blue("\u{1F4F1} Sending push notification..."));
@@ -6513,4 +6973,4 @@ ${chalk.bold("Examples:")}
   }
 }
 
-export { ExitCodeError as E, GEMINI_MODEL_ENV as G, createGeminiBackend as a, stopCaffeinate as b, createDefaultRuntimeShell as c, resolveCodexExecutable as d, shouldUseShellForCodex as e, getProjectPath as f, getInitialGeminiModel as g, claudeLocal as h, initialMachineMetadata as i, isBun as j, claudeCheckSession as k, getEnvironmentInfo as l, startCaffeinate as m, notifyDaemonSessionStarted as n, projectPath as p, readGeminiLocalConfig as r, saveGeminiModelToConfig as s, trimIdent as t };
+export { ExitCodeError as E, GEMINI_MODEL_ENV as G, createGeminiBackend as a, stopCaffeinate as b, createDefaultRuntimeShell as c, createCodexBackend as d, getProjectPath as e, formatDisplayMessage as f, getInitialGeminiModel as g, claudeLocal as h, initialMachineMetadata as i, isBun as j, trimIdent as k, claudeCheckSession as l, getEnvironmentInfo as m, notifyDaemonSessionStarted as n, startCaffeinate as o, projectPath as p, readGeminiLocalConfig as r, saveGeminiModelToConfig as s, truncateDisplayMessage as t, validateCodexAcpSpawn as v };