very-happy-cli 0.2.115 → 0.2.117

package/dist/{index-tPXwlc_t.cjs → index-DcESl4cI.cjs}

@@ -3,7 +3,7 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var persistence = require('./types-CpnzfHHS.cjs');
+var persistence = require('./types-DD3AK6Nb.cjs');
 var spawn = require('cross-spawn');
 var path = require('node:path');
 var node_readline = require('node:readline');
@@ -16,7 +16,7 @@ var React = require('react');
 var claudeAgentSdk = require('@anthropic-ai/claude-agent-sdk');
 var axios = require('axios');
 require('node:events');
-require('socket.io-client');
+var socket_ioClient = require('socket.io-client');
 var tweetnacl = require('tweetnacl');
 var os$1 = require('os');
 var child_process = require('child_process');
@@ -150,7 +150,9 @@ async function daemonPost(path, body) {
       signal: AbortSignal.timeout(timeout)
     });
     if (!response.ok) {
-      const errorMessage = `Request failed: ${path}, HTTP ${response.status}`;
+      const failure = await response.json().catch(() => null);
+      const reason = typeof failure?.error === "string" && failure.error ? failure.error : `HTTP ${response.status}`;
+      const errorMessage = `Request failed: ${path}, ${reason}`;
       persistence.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
       return {
         error: errorMessage
@@ -217,6 +219,13 @@ async function pushClipboardViaDaemon(text) {
   }
   return result;
 }
+async function setTerminalTitleViaDaemon(terminalId, title, ifAbsent = false) {
+  const result = await daemonPost("/terminal-title", { terminalId, title, ifAbsent });
+  if (result?.error) {
+    return { ok: false, error: result.error };
+  }
+  return { ok: result?.status === "ok", error: result?.status === "ok" ? void 0 : "unexpected daemon response" };
+}
 async function checkIfDaemonRunningAndCleanupStaleState() {
   const state = await persistence.readDaemonState();
   if (!state) {
@@ -4673,8 +4682,8 @@ function claudeModeHash(mode) {
 }
 
 const SPAWN_ORIGIN_TAG_MAX = 24;
-function spawnOriginTags(env = process.env) {
-  if (env.HAPPY_SESSION_VARIANT === "assistant") return void 0;
+function spawnOriginTags(env = process.env, flavor = void 0) {
+  if (env.HAPPY_SESSION_VARIANT === "assistant" && flavor === "claude") return void 0;
   const origin = (env.HAPPY_SPAWNED_BY ?? "").trim();
   if (!origin) return void 0;
   if (origin.length > SPAWN_ORIGIN_TAG_MAX) return void 0;
@@ -4688,7 +4697,7 @@ function createSessionMetadata(opts) {
   const state = {
     controlledByUser: false
   };
-  const originTags = spawnOriginTags();
+  const originTags = spawnOriginTags(process.env, opts.flavor);
   const metadata = {
     path: process.cwd(),
     host: os.hostname(),
@@ -4907,7 +4916,7 @@ function daemonReadiness(authenticated, running, hasState) {
     message: "\u26A0\uFE0F  Daemon is not running \u2014 run `very-happy daemon start`"
   };
 }
-function collectRuntimeReadiness(run = node_child_process.spawnSync, currentNodeVersion = process.version) {
+function collectRuntimeReadiness(run = node_child_process.spawnSync, currentNodeVersion = process.version, onPath = persistence.commandOnPath) {
   const tmux = probe("tmux", run);
   return {
     node: {
@@ -4918,7 +4927,8 @@ function collectRuntimeReadiness(run = node_child_process.spawnSync, currentNode
       ...tmux,
       supportsSessionEnv: tmux.available && tmuxSupportsSessionEnv(tmux.version)
     },
-    agents: ["claude", "codex", "gemini", "opencode", "openclaw"].map((command) => probe(command, run))
+    agents: ["claude", "codex", "gemini", "opencode", "openclaw", "pi"].map((command) => probe(command, run)),
+    piAdapter: { available: onPath("pi-acp") }
   };
 }
 
@@ -5167,6 +5177,11 @@ ${typeLabels[type] || type}:`));
   } else {
     console.log(chalk.green(`\u2713 External agent command${availableAgents.length === 1 ? "" : "s"}: ${availableAgents.map(toolProbeLabel).join(", ")}`));
   }
+  const piProbe = readiness.agents.find((agent) => agent.command === "pi");
+  if (piProbe?.available && !readiness.piAdapter.available) {
+    console.log(chalk.yellow("\u25CB pi found, but the pi-acp adapter is not on PATH \u2014 `very-happy pi` and spawning pi from the Web need it"));
+    console.log(chalk.gray("  Install it for the daemon user: npm install -g pi-acp@0.0.33"));
+  }
   console.log(chalk.bold("\n\u{1F510} Authentication"));
   let authenticated = false;
   try {
@@ -5217,6 +5232,11 @@ ${typeLabels[type] || type}:`));
   console.log(chalk.green("\n\u2705 Doctor diagnosis complete!\n"));
 }
 
+const SPAWN_AGENTS = ["claude", "codex", "gemini", "openclaw", "pi"];
+function isSpawnAgent(value) {
+  return typeof value === "string" && SPAWN_AGENTS.includes(value);
+}
+
 const DEFAULT_LOG_PRUNE_POLICY = {
   maxAgeMs: 14 * 24 * 60 * 6e4,
   maxTotalBytes: 200 * 1024 * 1024,
@@ -5618,6 +5638,10 @@ function spawnHappyCLI(args, options = {}) {
   });
 }
 
+function assistantSpawnMode(options) {
+  if (options.variant !== "assistant") return "none";
+  return options.agent === void 0 || options.agent === "claude" ? "claude-singleton" : "env-only";
+}
 function isAssistantTracked(tracked) {
   return tracked.variant === "assistant" || tracked.happySessionMetadataFromLocalWebhook?.variant === "assistant";
 }
@@ -5842,7 +5866,8 @@ function startDaemonControlServer({
   onSessionStateEvent,
   onClaudeAuthFailed,
   pushClipboard,
-  onTerminalHook
+  onTerminalHook,
+  setTerminalTitle
 }) {
   return new Promise((resolve) => {
     const app = fastify({
@@ -5962,7 +5987,7 @@ function startDaemonControlServer({
           // ignores it and supplies its own home daemon-side.
           directory: z.z.string().default(""),
           sessionId: z.z.string().optional(),
-          agent: z.z.enum(["claude", "codex", "gemini", "openclaw"]).optional(),
+          agent: z.z.enum(SPAWN_AGENTS).optional(),
           environmentVariables: z.z.record(z.z.string(), z.z.string()).optional(),
           variant: z.z.enum(["assistant"]).optional(),
           // B-051: assistant only — stop the live assistant, purge its
@@ -6067,6 +6092,30 @@ function startDaemonControlServer({
       persistence.logger.debug(`[CONTROL SERVER] Clipboard push request (${text.length} chars)`);
       return pushClipboard(text);
     });
+    typed.post("/terminal-title", {
+      schema: {
+        body: z.z.object({
+          terminalId: z.z.string().regex(/^[a-zA-Z0-9_-]{1,64}$/),
+          title: z.z.string().min(1).max(200),
+          ifAbsent: z.z.boolean().optional()
+        }),
+        response: {
+          200: z.z.object({ status: z.z.literal("ok") }),
+          409: z.z.object({ error: z.z.string() }),
+          503: z.z.object({ error: z.z.string() })
+        }
+      }
+    }, async (request, reply) => {
+      const { terminalId, title, ifAbsent } = request.body;
+      const landed = setTerminalTitle ? setTerminalTitle(terminalId, title, !!ifAbsent) : "starting";
+      if (landed === "starting") {
+        return reply.code(503).send({ error: "daemon is still starting up" });
+      }
+      if (!landed) {
+        return reply.code(409).send({ error: "Failed to set terminal title (tmux unavailable or terminal gone)" });
+      }
+      return { status: "ok" };
+    });
     typed.post("/stop", {
       schema: {
         response: {
@@ -6872,6 +6921,76 @@ function expandEnvironmentVariables(envVars, sourceEnv = process.env) {
   return expanded;
 }
 
+const SESSION_MODE_DIR = "session-modes";
+const ACP_PERMISSION_MODES = ["default", "acceptEdits", "plan", "bypassPermissions"];
+function normalizeAcpPermissionMode(value) {
+  if (typeof value !== "string") return null;
+  if (value === "yolo") return "bypassPermissions";
+  return ACP_PERMISSION_MODES.includes(value) ? value : null;
+}
+function sessionModeFilePath(happySessionId, dir = path.join(persistence.configuration.happyHomeDir, SESSION_MODE_DIR)) {
+  return path.join(dir, `${happySessionId}.json`);
+}
+function sessionModeFilePayload(permissionMode, now = Date.now()) {
+  return { permissionMode, updatedAt: now };
+}
+function writeSessionModeFile(happySessionId, permissionMode, opts = {}) {
+  const path$1 = sessionModeFilePath(happySessionId, opts.dir);
+  node_fs.mkdirSync(path.join(path$1, ".."), { recursive: true, mode: 448 });
+  const payload = sessionModeFilePayload(permissionMode, opts.now);
+  const tmp = `${path$1}.${process.pid}.tmp`;
+  persistence.writePrivateFileSync(tmp, JSON.stringify(payload));
+  node_fs.renameSync(tmp, path$1);
+  return payload;
+}
+function removeSessionModeFile(happySessionId, dir) {
+  const path = sessionModeFilePath(happySessionId, dir);
+  if (node_fs.existsSync(path)) node_fs.unlinkSync(path);
+}
+
+const IGNORED_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["--happy-starting-mode"]);
+const PI_ADAPTER_INSTALL_HINT = "very-happy pi needs the pi-acp adapter on PATH: npm install -g pi-acp@0.0.33";
+function piAdapterMissingHint(detail) {
+  return detail && /ENOENT/.test(detail) ? PI_ADAPTER_INSTALL_HINT : null;
+}
+function parsePiRunnerArgs(args) {
+  const parsed = { verbose: false, passthrough: [] };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      parsed.passthrough.push(...args.slice(i + 1));
+      break;
+    }
+    if (arg === "--started-by") {
+      const value = args[++i];
+      if (value === "daemon" || value === "terminal") parsed.startedBy = value;
+      continue;
+    }
+    if (arg === "--verbose") {
+      parsed.verbose = true;
+      continue;
+    }
+    if (arg === "--permission-mode") {
+      const mode = normalizeAcpPermissionMode(args[++i]);
+      if (mode) parsed.permissionMode = mode;
+      continue;
+    }
+    if (IGNORED_FLAGS_WITH_VALUE.has(arg)) {
+      i++;
+      continue;
+    }
+    throw new Error(`Unknown option for very-happy pi: ${arg} (use -- to pass args to pi-acp)`);
+  }
+  return parsed;
+}
+
+function spawnAgentUnavailableError(agent, availability) {
+  if (agent === "pi" && !availability.pi) {
+    return { type: "error", errorMessage: PI_ADAPTER_INSTALL_HINT };
+  }
+  return null;
+}
+
 const ResumableMetadataSchema = z.z.object({
   path: z.z.string().min(1),
   flavor: z.z.string().optional(),
@@ -7119,6 +7238,24 @@ function decideHandover(run) {
   return { action: "handover" };
 }
 
+function decideAutoUpdate(context) {
+  if (!context.enabled) return { action: "skip", reason: "auto-update disabled" };
+  const target = context.recommendedVersion;
+  if (!target) return { action: "skip", reason: "no recommended version published" };
+  const ordering = persistence.compareExactVersions(context.currentVersion, target);
+  if (ordering === null) return { action: "skip", reason: "version numbers not comparable" };
+  if (ordering === 0) return { action: "skip", reason: "already current" };
+  if (ordering > 0) return { action: "skip", reason: `already ahead of the recommended ${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 autoUpdateInstallArgs(version) {
+  return ["i", "-g", "--allow-scripts=very-happy-cli,node-pty", `very-happy-cli@${version}`];
+}
+
 const CLAUDE_KEYCHAIN_SERVICE_PREFIX = "Claude Code";
 function keychainIdentity(env = process.env, deps = {}) {
   const home = deps.home ?? os.homedir();
@@ -7182,7 +7319,7 @@ function parseJsonObject(text) {
     return null;
   }
 }
-function resolveSdkClaudeBinary(platform = process.platform, arch = process.arch, resolver = (s) => node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-tPXwlc_t.cjs', document.baseURI).href))).resolve(s)) {
+function resolveSdkClaudeBinary(platform = process.platform, arch = process.arch, resolver = (s) => node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DcESl4cI.cjs', document.baseURI).href))).resolve(s)) {
   const platformArch = `${platform}-${arch}`;
   const candidates = [
     `@anthropic-ai/claude-agent-sdk-${platformArch}/claude`,
@@ -8337,6 +8474,7 @@ function sanitizeImportTitle(value) {
   return collapsed.length > 200 ? `${collapsed.slice(0, 199)}\u2026` : collapsed;
 }
 const hostSuffix = process.env.HAPPY_VARIANT === "dev" ? "-dev" : "";
+const startupCliAvailability = persistence.detectCLIAvailability();
 const initialMachineMetadata = {
   host: os$1.hostname() + hostSuffix,
   platform: os$1.platform(),
@@ -8344,7 +8482,7 @@ const initialMachineMetadata = {
   homeDir: os$1.homedir(),
   happyHomeDir: persistence.configuration.happyHomeDir,
   happyLibDir: persistence.projectPath(),
-  cliAvailability: persistence.detectCLIAvailability(),
+  cliAvailability: startupCliAvailability,
   resumeSupport: { ...persistence.detectResumeSupport(), rpcAvailable: true }
 };
 async function preflightNewBundle(bundlePath) {
@@ -8399,6 +8537,40 @@ function withHandoverHold(state, reason) {
   return reason ? { ...state, handoverHold: { reason, at: Date.now() } } : { ...state, handoverHold: null };
 }
 const HANDOVER_PREFLIGHT_TIMEOUT_MS = 3e4;
+function runNpmInstall(args) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (code) => {
+      if (!settled) {
+        settled = true;
+        resolve(code);
+      }
+    };
+    let child;
+    try {
+      child = node_child_process.spawn("npm", args, { stdio: "ignore", env: process.env });
+    } catch {
+      done(null);
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      done(null);
+    }, AUTO_UPDATE_INSTALL_TIMEOUT_MS);
+    child.on("error", () => {
+      clearTimeout(timer);
+      done(null);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      done(code);
+    });
+  });
+}
+const AUTO_UPDATE_INSTALL_TIMEOUT_MS = 10 * 6e4;
 async function startDaemon() {
   let claudeAuthServiceRef = null;
   let cliUpdateStateRef = null;
@@ -8568,18 +8740,26 @@ async function startDaemon() {
     };
     const assistantSpawnGate = createSpawnGate();
     const spawnSession = (options) => {
-      if (options.variant !== "assistant") {
+      if (assistantSpawnMode(options) !== "claude-singleton") {
         return spawnSessionImpl(options);
       }
       return options.forceNew ? assistantSpawnGate.replace(() => spawnSessionImpl(options)) : assistantSpawnGate.join(() => spawnSessionImpl(options));
     };
+    const currentCliAvailability = () => apiMachineRef?.getCLIAvailability() ?? startupCliAvailability;
     const spawnSessionImpl = async (options) => {
       persistence.logger.debugLargeJson("[DAEMON RUN] Spawning session", persistence.summarizeSpawnSessionForLog(options));
       const spawnPermissionMode = sanitizeSpawnPermissionMode(options.permissionMode);
       if (options.permissionMode !== void 0 && spawnPermissionMode === null) {
         persistence.logger.warn("[DAEMON RUN] Ignoring invalid permissionMode in spawn request");
       }
-      if (options.variant === "assistant") {
+      const unavailable = spawnAgentUnavailableError(options.agent, currentCliAvailability());
+      if (unavailable) {
+        persistence.logger.warn(`[DAEMON RUN] Refusing spawn of agent '${options.agent}': ${unavailable.errorMessage}`);
+        return unavailable;
+      }
+      const assistantMode = assistantSpawnMode(options);
+      const trackedVariant = assistantMode === "claude-singleton" ? options.variant : void 0;
+      if (assistantMode === "claude-singleton") {
         options = { ...options, directory: assistantHome() };
         if (options.forceNew) {
           for (const tracked of [...pidToTrackedSession.values()]) {
@@ -8782,7 +8962,13 @@ async function startDaemon() {
           persistence.logger.debug(`[DAEMON RUN] Attempting to spawn session in tmux: ${sessionDesc}`);
           const tmux = getTmuxUtilities(tmuxSessionName);
           const cliPath = path$1.join(persistence.projectPath(), "dist", "index.mjs");
-          const agent = options.agent === "gemini" ? "gemini" : options.agent === "codex" ? "codex" : options.agent === "openclaw" ? "openclaw" : "claude";
+          const agent = options.agent ?? "claude";
+          if (!isSpawnAgent(agent)) {
+            return {
+              type: "error",
+              errorMessage: `Unsupported agent type: '${options.agent}'. Please update your CLI to the latest version.`
+            };
+          }
           const resumeId = agent === "claude" ? options.resumeClaudeSessionId : agent === "codex" ? options.resumeCodexThreadId : void 0;
           const resumeFragment = resumeId ? ` --resume ${persistence.shellescape(resumeId)}` : "";
           const permissionModeFragment = spawnPermissionMode ? ` --permission-mode ${persistence.shellescape(spawnPermissionMode)}` : "";
@@ -8810,7 +8996,7 @@ async function startDaemon() {
               pid: tmuxResult.pid,
               // Real PID from tmux -P flag
               tmuxSessionId: tmuxResult.sessionId,
-              variant: options.variant,
+              variant: trackedVariant,
               spawnedBy: options.spawnedBy,
               directoryCreated,
               message: directoryCreated ? `The path '${directory}' did not exist. We created a new folder and spawned a new session in tmux session '${tmuxSessionName}'. Use 'tmux attach -t ${tmuxSessionName}' to view the session.` : `Spawned new session in tmux session '${tmuxSessionName}'. Use 'tmux attach -t ${tmuxSessionName}' to view the session.`
@@ -8857,6 +9043,9 @@ async function startDaemon() {
             case "openclaw":
               agentCommand = "openclaw";
               break;
+            case "pi":
+              agentCommand = "pi";
+              break;
             default:
               return {
                 type: "error",
@@ -8888,7 +9077,7 @@ async function startDaemon() {
             },
             directoryCreated,
             message: directoryCreated ? `The path '${directory}' did not exist. We created a new folder and spawned a new session there.` : void 0,
-            variant: options.variant,
+            variant: trackedVariant,
             spawnedBy: options.spawnedBy
           });
         }
@@ -9369,6 +9558,10 @@ async function startDaemon() {
       },
       onTerminalHook: (body) => {
         mirrorManagerRef?.handleHookPayload(body);
+      },
+      setTerminalTitle: (terminalId, title, ifAbsent) => {
+        if (!apiMachineRef) return "starting";
+        return apiMachineRef.setTerminalTitle(terminalId, title, ifAbsent);
       }
     });
     const daemonClaudeCredentials = resolveClaudeCredentialReadiness();
@@ -9465,6 +9658,48 @@ async function startDaemon() {
         host: initialMachineMetadata.host
       })).then(() => persistence.logger.debug(`[DAEMON RUN] claimed the machine record for host ${initialMachineMetadata.host}`)).catch((error) => persistence.logger.debug("[DAEMON RUN] could not refresh the recorded host:", error));
     }
+    let autoUpdateFailedVersion = null;
+    let autoUpdateRunning = false;
+    const maybeAutoUpdate = async (cliUpdate) => {
+      if (autoUpdateRunning) return;
+      const settings = await persistence.readSettings();
+      const decision = decideAutoUpdate({
+        enabled: (settings.cliAutoUpdate ?? "idle") !== "off",
+        currentVersion: cliUpdate.currentVersion,
+        recommendedVersion: cliUpdate.recommendedVersion,
+        idle: pidToTrackedSession.size === 0 && !apiMachine.hasLiveTerminals(),
+        failedVersion: autoUpdateFailedVersion
+      });
+      if (decision.action === "skip") {
+        persistence.logger.debug(`[DAEMON RUN] auto-update skipped: ${decision.reason}`);
+        return;
+      }
+      autoUpdateRunning = true;
+      const target = decision.version;
+      const report = (state, detail) => {
+        cliUpdateStateRef = { ...cliUpdate, autoUpdate: { state, version: target, detail, at: Date.now() } };
+        void apiMachine.setCliUpdateState(cliUpdateStateRef);
+      };
+      persistence.logger.warn(`[DAEMON RUN] auto-updating CLI to ${target} (machine idle)`);
+      report("installing");
+      try {
+        const code = await runNpmInstall(autoUpdateInstallArgs(target));
+        if (code === 0) {
+          persistence.logger.warn(`[DAEMON RUN] auto-update installed ${target}; handover follows once it verifies`);
+          report("installed");
+        } else {
+          autoUpdateFailedVersion = target;
+          persistence.logger.warn(`[DAEMON RUN] auto-update of ${target} failed with exit ${code}`);
+          report("failed", `npm exited ${code}`);
+        }
+      } catch (error) {
+        autoUpdateFailedVersion = target;
+        persistence.logger.warn(`[DAEMON RUN] auto-update of ${target} could not run:`, error);
+        report("failed", String(error).slice(0, 200));
+      } finally {
+        autoUpdateRunning = false;
+      }
+    };
     let cliUpdateCheckRunning = false;
     const refreshCliUpdate = async () => {
       if (cliUpdateCheckRunning) return;
@@ -9477,6 +9712,7 @@ async function startDaemon() {
         cliUpdateStateRef = cliUpdate;
         apiMachine.setCliUpdateState(cliUpdate);
         persistence.logger.debug(`[DAEMON RUN] CLI update policy checked: ${cliUpdate.status} (recommended=${cliUpdate.recommendedVersion ?? "none"}, minimum=${cliUpdate.minimumVersion ?? "none"})`);
+        await maybeAutoUpdate(cliUpdate);
       } catch (error) {
         persistence.logger.debug("[DAEMON RUN] CLI update policy check failed:", error);
       } finally {
@@ -9689,6 +9925,194 @@ function formatTranscript(bodies) {
   return lines.join("\n");
 }
 
+const USER_SOCKET_CONNECT_TIMEOUT_MS = 15e3;
+async function openUserScopedSocket(token, options = {}) {
+  const socket = socket_ioClient.io(persistence.configuration.serverUrl, {
+    auth: {
+      token,
+      clientType: "user-scoped",
+      happyClient: `cli-session-ops/${persistence.configuration.currentCliVersion}`
+    },
+    path: "/v1/updates",
+    transports: ["websocket"],
+    reconnection: false,
+    autoConnect: false
+  });
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      socket.close();
+      reject(new Error(`Timed out connecting to ${persistence.configuration.serverUrl}`));
+    }, options.connectTimeoutMs ?? USER_SOCKET_CONNECT_TIMEOUT_MS);
+    socket.once("connect", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+    socket.once("connect_error", (error) => {
+      clearTimeout(timer);
+      socket.close();
+      reject(new Error(`Could not connect to ${persistence.configuration.serverUrl}: ${error.message}`));
+    });
+    socket.connect();
+  });
+  return {
+    async rpcCall(payload, timeoutMs) {
+      const ack = await socket.timeout(timeoutMs).emitWithAck("rpc-call", payload);
+      return ack;
+    },
+    close() {
+      socket.close();
+    }
+  };
+}
+
+const PERMISSION_OPS_CLIENT = "session-ops";
+const PERMISSION_RPC_TIMEOUT_MS = 3e4;
+const SETTLE_TIMEOUT_MS = 5e3;
+const SETTLE_POLL_MS = 500;
+function buildPermissionRpcPayload(requestId, verdict) {
+  if (verdict.kind === "approve") {
+    return {
+      id: requestId,
+      approved: true,
+      decision: verdict.forSession ? "approved_for_session" : "approved"
+    };
+  }
+  return {
+    id: requestId,
+    approved: false,
+    decision: "denied",
+    ...verdict.reason ? { reason: verdict.reason } : {}
+  };
+}
+function interpretPermissionAck(ack, decryptResult) {
+  if (!ack.ok) {
+    const message = ack.error ?? "RPC call failed";
+    if (message === "RPC method not available") {
+      return { status: "offline", message: "no running wrapper has registered the permission RPC for this session" };
+    }
+    if (message === "RPC target disconnected") {
+      return { status: "offline", message: "the wrapper disconnected while the permission RPC was in flight" };
+    }
+    if (/timed? ?out/i.test(message)) {
+      return { status: "timeout", message };
+    }
+    return { status: "rejected", message };
+  }
+  let body = null;
+  if (typeof ack.result === "string" && ack.result.length > 0) {
+    try {
+      body = decryptResult(ack.result);
+    } catch {
+      body = null;
+    }
+  }
+  if (body && typeof body === "object" && typeof body.error === "string") {
+    return { status: "handler-error", message: body.error };
+  }
+  return { status: "acknowledged" };
+}
+function pendingRequestsOf(agentState, now) {
+  const requests = agentState?.requests;
+  if (!requests || typeof requests !== "object") return [];
+  return Object.entries(requests).map(([id, request]) => ({
+    id,
+    tool: typeof request?.tool === "string" ? request.tool : "unknown",
+    ...request?.kind ? { kind: request.kind } : {},
+    ...typeof request?.createdAt === "number" ? { createdAt: request.createdAt, waitingMs: Math.max(0, now - request.createdAt) } : {}
+  })).sort((a, b) => (a.createdAt ?? Number.MAX_SAFE_INTEGER) - (b.createdAt ?? Number.MAX_SAFE_INTEGER));
+}
+const RPC_DEADLINE_GRACE_MS = 2e3;
+function withDeadline(promise, ms, message) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`${message} (timed out)`)), ms);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+async function resolvePermissionRequest(sessionId, requestId, verdict, deps = {}) {
+  const now = deps.now ?? Date.now;
+  const persisted = (deps.readPersisted ?? persistence.readPersistedSessions)()[sessionId];
+  if (!persisted) {
+    throw new Error(
+      `No local key for session ${sessionId} \u2014 approve/deny needs the session key from ~/.happy/sessions.json (the RPC payload is encrypted with it), so only sessions this machine's daemon spawned within 14 days can be answered from here.`
+    );
+  }
+  const token = await (deps.bearerToken ?? bearerToken$1)();
+  const fetchState = deps.fetchAgentState ?? fetchDecryptedAgentState;
+  const before = pendingRequestsOf(await fetchState(sessionId, persisted, token), now());
+  if (!before.some((request) => request.id === requestId)) {
+    const hint = before.length > 0 ? `Pending request ids: ${before.map((request) => `${request.id} (${request.tool})`).join(", ")}` : "The session has no pending requests.";
+    throw new Error(`Request ${requestId} is not pending on session ${sessionId}. ${hint}`);
+  }
+  const payload = buildPermissionRpcPayload(requestId, verdict);
+  const key = persistence.decodeBase64(persisted.encryptionKey);
+  const params = persistence.encodeBase64(persistence.encrypt(key, persisted.encryptionVariant, payload));
+  const transport = await (deps.openTransport ?? openUserScopedSocket)(token);
+  const rpcTimeoutMs = deps.rpcTimeoutMs ?? PERMISSION_RPC_TIMEOUT_MS;
+  let ack;
+  try {
+    ack = await withDeadline(
+      transport.rpcCall({ method: `${sessionId}:permission`, params }, rpcTimeoutMs),
+      rpcTimeoutMs + RPC_DEADLINE_GRACE_MS,
+      `permission RPC did not settle within ${rpcTimeoutMs}ms`
+    );
+  } catch (error) {
+    ack = { ok: false, error: error instanceof Error ? error.message : "RPC call failed" };
+  } finally {
+    transport.close();
+  }
+  const outcome = interpretPermissionAck(ack, (encrypted) => persistence.decrypt(key, persisted.encryptionVariant, persistence.decodeBase64(encrypted)));
+  if (outcome.status !== "acknowledged") {
+    return { sessionId, requestId, payload, outcome };
+  }
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const deadline = now() + (deps.settleTimeoutMs ?? SETTLE_TIMEOUT_MS);
+  let settled = false;
+  for (; ; ) {
+    const pending = pendingRequestsOf(await fetchState(sessionId, persisted, token), now());
+    if (!pending.some((request) => request.id === requestId)) {
+      settled = true;
+      break;
+    }
+    if (now() >= deadline) break;
+    await sleep(SETTLE_POLL_MS);
+  }
+  return { sessionId, requestId, payload, outcome, settled };
+}
+async function bearerToken$1() {
+  const credentials = await persistence.readCredentialsForConfiguredRelay();
+  if (!credentials) throw new Error("CLI is not authenticated (no ~/.happy/access.key)");
+  return credentials.token;
+}
+async function fetchDecryptedAgentState(sessionId, persisted, token) {
+  const response = await axios.get(
+    `${persistence.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`,
+    {
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "X-Happy-Client": `${PERMISSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
+      },
+      timeout: 15e3,
+      // 404 is a real answer ("not yours / gone"), not a transport fault.
+      validateStatus: (status) => status >= 200 && status < 300 || status === 404
+    }
+  );
+  if (response.status === 404) {
+    throw new Error(`Session ${sessionId} was not found on this account (it may have been deleted, or the local key belongs to a session on another relay).`);
+  }
+  const raw = response.data?.session?.agentState;
+  if (typeof raw !== "string" || raw.length === 0) return null;
+  return persistence.decrypt(persistence.decodeBase64(persisted.encryptionKey), persisted.encryptionVariant, persistence.decodeBase64(raw));
+}
+
 const SESSION_OPS_CLIENT = "session-ops";
 const DEFAULT_RECENT_LIMIT = 15;
 const MAX_READ_LIMIT = 100;
@@ -9700,10 +10124,7 @@ function mergeSessionSummaries(live, persisted, options = {}) {
     const id = typeof child.happySessionId === "string" ? child.happySessionId : void 0;
     if (!id || seen.has(id)) continue;
     seen.add(id);
-    summaries.push(toSummary(id, persisted[id], {
-      live: true,
-      pid: typeof child.pid === "number" ? child.pid : void 0
-    }));
+    summaries.push(toSummary(id, persisted[id], livenessOf(child)));
   }
   const rest = Object.entries(persisted).filter(([id]) => !seen.has(id)).filter(([, entry]) => entry.metadata?.flavor !== "terminal-mirror").sort((a, b) => b[1].savedAt - a[1].savedAt).slice(0, recentLimit);
   for (const [id, entry] of rest) {
@@ -9713,6 +10134,13 @@ function mergeSessionSummaries(live, persisted, options = {}) {
   const wanted = options.tag;
   return summaries.filter((summary) => summary.tags?.includes(wanted) === true);
 }
+function livenessOf(child) {
+  return { live: true, pid: typeof child.pid === "number" ? child.pid : void 0 };
+}
+function sessionLiveness(live, sessionId) {
+  const child = live.find((entry) => entry.happySessionId === sessionId);
+  return child ? livenessOf(child) : { live: false };
+}
 function toSummary(id, persisted, extra) {
   const meta = persisted?.metadata;
   return {
@@ -9732,6 +10160,79 @@ async function listSessions(options = {}) {
   const live = await listDaemonSessions();
   return mergeSessionSummaries(live, persistence.readPersistedSessions(), options);
 }
+function summarizeAccountSession(row, persisted, liveIds, now) {
+  const base = {
+    id: row.id,
+    live: liveIds.has(row.id),
+    url: sessionWebUrl(row.id),
+    decryptable: false,
+    active: row.active === true,
+    archived: typeof row.archivedAt === "number",
+    ...typeof row.activeAt === "number" ? { activeAt: row.activeAt } : {},
+    ...typeof row.updatedAt === "number" ? { updatedAt: row.updatedAt } : {},
+    attention: false
+  };
+  if (!persisted) return base;
+  const key = persistence.decodeBase64(persisted.encryptionKey);
+  let metadata = null;
+  let agentState = null;
+  try {
+    metadata = row.metadata ? persistence.decrypt(key, persisted.encryptionVariant, persistence.decodeBase64(row.metadata)) : null;
+    agentState = row.agentState ? persistence.decrypt(key, persisted.encryptionVariant, persistence.decodeBase64(row.agentState)) : null;
+  } catch {
+    return base;
+  }
+  if (!metadata) return base;
+  const meta = metadata;
+  const pending = pendingRequestsOf(agentState, now);
+  return {
+    ...base,
+    decryptable: true,
+    ...meta.summary?.text ? { title: meta.summary.text } : {},
+    ...meta.path ? { cwd: meta.path } : {},
+    ...meta.flavor ? { flavor: meta.flavor } : {},
+    ...meta.tags?.length ? { tags: [...meta.tags] } : {},
+    ...meta.variant ? { variant: meta.variant } : {},
+    ...meta.machineId ? { machineId: meta.machineId } : {},
+    ...persisted.savedAt !== void 0 ? { savedAt: persisted.savedAt } : {},
+    pending,
+    attention: pending.length > 0
+  };
+}
+function orderAccountSessions(summaries, options = {}) {
+  const oldestWait = (summary) => Math.max(0, ...(summary.pending ?? []).map((request) => request.waitingMs ?? 0));
+  const rank = (summary) => summary.attention ? 0 : summary.live ? 1 : 2;
+  let rows = summaries.filter((summary) => summary.flavor !== "terminal-mirror").slice().sort((a, b) => {
+    const byRank = rank(a) - rank(b);
+    if (byRank !== 0) return byRank;
+    if (a.attention && b.attention) return oldestWait(b) - oldestWait(a);
+    return (b.updatedAt ?? 0) - (a.updatedAt ?? 0);
+  });
+  if (options.tag) {
+    const wanted = options.tag;
+    rows = rows.filter((summary) => summary.tags?.includes(wanted) === true);
+  }
+  const recentLimit = Math.max(0, options.recentLimit ?? DEFAULT_RECENT_LIMIT);
+  let idleKept = 0;
+  return rows.filter((summary) => rank(summary) < 2 || idleKept++ < recentLimit);
+}
+async function listAccountSessions(options = {}) {
+  const token = await bearerToken();
+  const response = await axios.get(`${persistence.configuration.serverUrl}/v1/sessions`, {
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "X-Happy-Client": `${SESSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
+    },
+    timeout: 15e3
+  });
+  const rows = Array.isArray(response.data?.sessions) ? response.data.sessions : [];
+  const persisted = persistence.readPersistedSessions();
+  const live = await listDaemonSessions();
+  const liveIds = new Set(live.map((child) => child.happySessionId).filter((id) => typeof id === "string"));
+  const now = Date.now();
+  const summaries = rows.filter((row) => typeof row?.id === "string").map((row) => summarizeAccountSession(row, persisted[row.id], liveIds, now)).filter((summary) => options.includeArchived || !summary.archived);
+  return orderAccountSessions(summaries, options);
+}
 async function bearerToken() {
   const credentials = await persistence.readCredentialsForConfiguredRelay();
   if (!credentials) throw new Error("CLI is not authenticated (no ~/.happy/access.key)");
@@ -9760,6 +10261,7 @@ async function readSessionTranscript(sessionId, limit) {
   const messages = Array.isArray(response.data?.messages) ? response.data.messages : [];
   messages.reverse();
   const key = persistence.decodeBase64(persisted.encryptionKey);
+  const live = await listDaemonSessions();
   const bodies = messages.map((message) => {
     if (message.content?.t !== "encrypted") return null;
     try {
@@ -9769,7 +10271,7 @@ async function readSessionTranscript(sessionId, limit) {
     }
   });
   return {
-    summary: toSummary(sessionId, persisted, { live: false }),
+    summary: toSummary(sessionId, persisted, sessionLiveness(live, sessionId)),
     messageCount: messages.length,
     transcript: formatTranscript(bodies)
   };
@@ -9865,13 +10367,16 @@ function normalizeSpawnDirectory(input, homeDir) {
   return { ok: true, directory: path.normalize(expanded) };
 }
 
-const ASSISTANT_TOOL_NAMES = [
+const ASSISTANT_SESSION_TOOL_NAMES = [
   "sessions_list",
   "session_read",
   "session_send",
   "session_spawn",
   "session_kill",
-  "session_archive",
+  "session_archive"
+];
+const ASSISTANT_TOOL_NAMES = [
+  ...ASSISTANT_SESSION_TOOL_NAMES,
   "terminals_list",
   "terminal_read",
   "terminal_send",
@@ -9908,6 +10413,10 @@ function describeSummary(summary) {
   return parts.join(" ");
 }
 function registerAssistantTools(mcp) {
+  registerAssistantSessionTools(mcp);
+  registerAssistantMachineTools(mcp);
+}
+function registerAssistantSessionTools(mcp) {
   mcp.registerTool("sessions_list", {
     description: "List Claude Code sessions on this machine: sessions currently tracked by the local daemon (running) plus recently seen ones. Returns id, title, working directory, agent flavor and web URL for each.",
     title: "List Sessions",
@@ -10024,6 +10533,8 @@ ${body}`);
       return fail(`Failed to archive session: ${error instanceof Error ? error.message : String(error)}`);
     }
   });
+}
+function registerAssistantMachineTools(mcp) {
   mcp.registerTool("terminals_list", {
     description: "List the web terminals (tmux sessions) on this machine with their id, title and working directory.",
     title: "List Terminals",
@@ -10693,7 +11204,7 @@ function registerSideQuestionHandler(rpc, deps) {
   const retainMs = deps.retainMs ?? SIDE_QUESTION_RETAIN_MS;
   const maxRunMs = deps.maxRunMs ?? SIDE_QUESTION_MAX_RUN_MS;
   const run = deps.run ?? (async (input) => {
-    const { query } = await Promise.resolve().then(function () { return require('./index-B3UkbonP.cjs'); });
+    const { query } = await Promise.resolve().then(function () { return require('./index-DqmVH6R5.cjs'); });
     return runSideQuestion(query, input);
   });
   const slots = /* @__PURE__ */ new Map();
@@ -10795,7 +11306,7 @@ const MAX_TITLE_CHARS = 60;
 const GENERATION_TIMEOUT_MS = 3e4;
 function resolveClaudeBinary() {
   try {
-    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-tPXwlc_t.cjs', document.baseURI).href)));
+    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DcESl4cI.cjs', document.baseURI).href)));
     const utilsPath = path.resolve(path.join(persistence.projectPath(), "scripts", "claude_version_utils.cjs"));
     const { getClaudeCliPath } = require$1(utilsPath);
     const path$1 = getClaudeCliPath();
@@ -11233,7 +11744,7 @@ async function runClaude(credentials, options = {}) {
   const forkedFromMessageId = process.env.HAPPY_FORKED_FROM_MESSAGE_ID;
   const importedFromClaudeSessionId = process.env.HAPPY_IMPORTED_FROM_CLAUDE_SESSION_ID;
   const importTitle = process.env.HAPPY_IMPORT_TITLE;
-  const originTags = spawnOriginTags();
+  const originTags = spawnOriginTags(process.env, "claude");
   let metadata = {
     path: workingDirectory,
     host: os.hostname(),
@@ -12997,9 +13508,9 @@ function resolveLocalSignupBootstrap(configuredMode, configuredInviteCodes, gene
   };
 }
 
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-tPXwlc_t.cjs', document.baseURI).href)));
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DcESl4cI.cjs', document.baseURI).href)));
 const __dirname$1 = path.dirname(__filename$1);
-const require_ = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-tPXwlc_t.cjs', document.baseURI).href)));
+const require_ = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DcESl4cI.cjs', document.baseURI).href)));
 const PRISMA_QUERY_ENGINE_FILES = {
   "arm64-darwin": "libquery_engine-darwin-arm64.dylib.node",
   "x64-darwin": "libquery_engine-darwin.dylib.node",
@@ -15623,7 +16134,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     process.exit(0);
   } else if (subcommand === "install-terminal-hooks") {
     try {
-      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await Promise.resolve().then(function () { return require('./installTerminalHooks-CWfCF68p.cjs'); });
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await Promise.resolve().then(function () { return require('./installTerminalHooks-zfsWSotO.cjs'); });
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -15640,7 +16151,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "spawn") {
     try {
-      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-CfYddkS_.cjs'); });
+      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-tSvo3stN.cjs'); });
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -15652,7 +16163,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "sessions") {
     try {
-      const { handleSessionsCommand } = await Promise.resolve().then(function () { return require('./sessions-CGdcF05T.cjs'); });
+      const { handleSessionsCommand } = await Promise.resolve().then(function () { return require('./sessions-YWt9YEN8.cjs'); });
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -15664,7 +16175,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "send") {
     try {
-      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-CnVtXOj0.cjs'); });
+      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-BZLhRZb-.cjs'); });
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -15770,9 +16281,9 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     if (geminiSubcommand === "project" && args[2] === "set" && args[3]) {
       const projectId = args[3];
       try {
-        const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return require('./config-BNAsx9Wg.cjs'); });
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./types-CpnzfHHS.cjs'); }).then(function (n) { return n.persistence; });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-CpnzfHHS.cjs'); }).then(function (n) { return n.api; });
+        const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return require('./config-O9quMfxg.cjs'); });
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./types-DD3AK6Nb.cjs'); }).then(function (n) { return n.persistence; });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-DD3AK6Nb.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -15803,7 +16314,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
     if (geminiSubcommand === "project" && args[2] === "get") {
       try {
-        const { readGeminiLocalConfig } = await Promise.resolve().then(function () { return require('./config-BNAsx9Wg.cjs'); });
+        const { readGeminiLocalConfig } = await Promise.resolve().then(function () { return require('./config-O9quMfxg.cjs'); });
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -15843,7 +16354,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-UN5IznJp.cjs'); });
+      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-DYf3ntib.cjs'); });
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -15863,9 +16374,44 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(1);
     }
     return;
+  } else if (subcommand === "pi") {
+    let hintPrinted = false;
+    const printHint = (detail) => {
+      const hint = piAdapterMissingHint(detail);
+      if (hint && !hintPrinted) {
+        hintPrinted = true;
+        console.error(chalk.gray(hint));
+      }
+    };
+    try {
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-W-O4xR_O.cjs'); });
+      const parsed = parsePiRunnerArgs(args.slice(1));
+      const resolved = resolveAcpAgentConfig(["pi", ...parsed.passthrough]);
+      const { credentials } = await authAndSetupMachineIfNeeded();
+      await ensureDaemonRunning();
+      await runAcp({
+        credentials,
+        startedBy: parsed.startedBy,
+        verbose: parsed.verbose,
+        permissionMode: parsed.permissionMode,
+        agentName: resolved.agentName,
+        command: resolved.command,
+        args: resolved.args,
+        onBackendError: printHint
+      });
+      if (hintPrinted) process.exit(1);
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      printHint(error instanceof Error ? error.message : void 0);
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
   } else if (subcommand === "acp") {
     try {
-      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-ClR0jhjm.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-W-O4xR_O.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -15905,7 +16451,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "openclaw") {
     try {
-      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-9hhfGllZ.cjs'); });
+      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-CNKjAw-H.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -15956,7 +16502,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "mcp" && args.length === 1) {
     try {
-      const { handleMcpCommand } = await Promise.resolve().then(function () { return require('./mcp-CqjiDRnG.cjs'); });
+      const { handleMcpCommand } = await Promise.resolve().then(function () { return require('./mcp-nYqC4FYm.cjs'); });
       await handleMcpCommand();
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}
@@ -16171,10 +16717,12 @@ ${chalk.bold("Usage:")}
                             print its web URL (for automation; see spawn --help)
   very-happy send              Send a message into an existing session
                             (for automation; see send --help)
-  very-happy sessions          List, read, stop or archive sessions on this
-                            machine (for automation; see sessions --help)
+  very-happy sessions          List, read, stop, archive, approve or deny
+                            sessions and their permission requests (for
+                            automation; see sessions --help)
   very-happy codex             Start Codex mode
   very-happy gemini            Start Gemini mode (ACP)
+  very-happy pi                Start pi mode (ACP via the pi-acp adapter)
   very-happy acp               Start a generic ACP-compatible agent
   very-happy openclaw          Connect through a configured OpenClaw gateway
   very-happy install-terminal-hooks
@@ -16200,6 +16748,7 @@ ${chalk.bold("Examples:")}
   very-happy --js-runtime bun   Use bun instead of node to spawn Claude Code
   very-happy --claude-env ANTHROPIC_BASE_URL=http://127.0.0.1:3456
                            Use a custom API endpoint (e.g., claude-code-router)
+  very-happy pi                 Start pi (needs pi-acp on PATH)
   very-happy acp gemini         Start Gemini via generic ACP runner
   very-happy acp opencode   Start OpenCode through its built-in ACP adapter
   very-happy acp -- your-agent --acp
@@ -16326,24 +16875,33 @@ exports.GOOGLE_API_KEY_ENV = GOOGLE_API_KEY_ENV;
 exports.MAX_READ_LIMIT = MAX_READ_LIMIT;
 exports.MessageBuffer = MessageBuffer;
 exports.MessageQueue2 = MessageQueue2;
+exports.SPAWN_AGENTS = SPAWN_AGENTS;
+exports.TitleGenerator = TitleGenerator;
 exports.archiveSession = archiveSession;
 exports.checkIfDaemonRunningAndCleanupStaleState = checkIfDaemonRunningAndCleanupStaleState;
 exports.createSessionMetadata = createSessionMetadata;
 exports.hashObject = hashObject;
 exports.initialMachineMetadata = initialMachineMetadata;
 exports.isValidSpawnOrigin = isValidSpawnOrigin;
+exports.listAccountSessions = listAccountSessions;
 exports.listSessions = listSessions;
+exports.normalizeAcpPermissionMode = normalizeAcpPermissionMode;
 exports.notifyDaemonSessionStarted = notifyDaemonSessionStarted;
 exports.pushClipboardViaDaemon = pushClipboardViaDaemon;
 exports.query = query;
 exports.readSessionTranscript = readSessionTranscript;
+exports.registerAssistantSessionTools = registerAssistantSessionTools;
 exports.registerKillSessionHandler = registerKillSessionHandler;
+exports.removeSessionModeFile = removeSessionModeFile;
+exports.resolvePermissionRequest = resolvePermissionRequest;
 exports.sanitizeSpawnPermissionMode = sanitizeSpawnPermissionMode;
 exports.sendUserMessage = sendUserMessage;
 exports.sessionWebUrl = sessionWebUrl;
+exports.setTerminalTitleViaDaemon = setTerminalTitleViaDaemon;
 exports.setupOfflineReconnection = setupOfflineReconnection;
 exports.spawnDaemonSession = spawnDaemonSession;
 exports.startHappyServer = startHappyServer;
 exports.stopSession = stopSession;
 exports.tmuxSupportsSessionEnv = tmuxSupportsSessionEnv;
 exports.waitForSessionKey = waitForSessionKey;
+exports.writeSessionModeFile = writeSessionModeFile;