very-happy-cli 0.2.115 → 0.2.117

package/dist/{index-BHNEb4bc.mjs → index-BYZKuQoy.mjs}

@@ -1,11 +1,11 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
 import os, { homedir, userInfo, tmpdir } from 'node:os';
 import { randomUUID, randomBytes, createHash as createHash$1, timingSafeEqual } from 'node:crypto';
-import { o as readDaemonState, l as logger, c as configuration, q as clearDaemonState, s as getProjectPath, p as projectPath, t as initializeSandbox, u as wrapCommand, d as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, g as delay, v as AsyncLock, S as STREAM_DELTA_MAX_CHARS, x as ensurePrivateDirectory, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, y as hardenPrivateFile, f as packageJson, j as readSettings, z as readCredentials, B as credentialRelayProblem, C as deriveLocalCliUpdateSummary, k as encodeBase64, D as updateSettings, E as encodeBase64Url, F as decodeBase64, G as writeCredentialsLegacy, H as writeCredentialsDataKey, J as readCredentialsForConfiguredRelay, K as encrypt, r as readPersistedSessions, L as isClaudeSessionId, N as getLocalHappyAgentCredentialPath, O as readLocalHappyAgentCredentials, P as decryptWithDataKey, Q as decryptLegacy, T as extractCompleteLines, U as decideBackfill, V as parseTerminalHookPayload, W as tmuxArgs, X as scrubTmuxClientEnv, Y as decideMirrorBinding, Z as MIRROR_BACKFILL_LINES_DEFAULT, _ as persistSession, $ as mirrorLineKey, a0 as mirrorLocalId, w as writePrivateFileSync, a1 as detectResumeSupport, a2 as detectCLIAvailability, a3 as acquireDaemonLock, a4 as summarizeSpawnSessionForLog, a5 as deletePersistedSessions, a6 as shellescape, a7 as decrypt, a8 as writeDaemonState, A as ApiClient, a9 as writeSettings, aa as fetchCliUpdateState, ab as resolveCliUpdateCheckInterval, ac as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, ad as releaseDaemonLock, i as isValidSessionId, ae as listVhTerminals, af as isValidTerminalId, ag as readVhTerminal, ah as sendToVhTerminal, ai as TITLE_PROMPT_PREFIX, aj as BOARD_ANALYZER_PROMPT_PREFIX, h as connectionState, ak as startOfflineReconnection, al as clearCredentials, am as clearMachineId, m as ensurePrivateDirectorySync, an as SandboxConfigSchema, b as createEnvelope, ao as CodexAppServerClient, ap as getLatestDaemonLog } from './types-B3qx8Ga1.mjs';
+import { o as readDaemonState, l as logger, c as configuration, q as clearDaemonState, s as getProjectPath, p as projectPath, t as initializeSandbox, u as wrapCommand, d as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, g as delay, v as AsyncLock, S as STREAM_DELTA_MAX_CHARS, x as ensurePrivateDirectory, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, y as hardenPrivateFile, f as packageJson, z as commandOnPath, j as readSettings, B as readCredentials, C as credentialRelayProblem, D as deriveLocalCliUpdateSummary, k as encodeBase64, E as updateSettings, F as encodeBase64Url, G as decodeBase64, H as writeCredentialsLegacy, J as writeCredentialsDataKey, K as readCredentialsForConfiguredRelay, L as encrypt, r as readPersistedSessions, N as isClaudeSessionId, w as writePrivateFileSync, O as getLocalHappyAgentCredentialPath, P as readLocalHappyAgentCredentials, Q as decryptWithDataKey, T as decryptLegacy, U as compareExactVersions, V as extractCompleteLines, W as decideBackfill, X as parseTerminalHookPayload, Y as tmuxArgs, Z as scrubTmuxClientEnv, _ as decideMirrorBinding, $ as MIRROR_BACKFILL_LINES_DEFAULT, a0 as persistSession, a1 as mirrorLineKey, a2 as mirrorLocalId, a3 as detectCLIAvailability, a4 as detectResumeSupport, a5 as acquireDaemonLock, a6 as summarizeSpawnSessionForLog, a7 as deletePersistedSessions, a8 as shellescape, a9 as decrypt, aa as writeDaemonState, A as ApiClient, ab as writeSettings, ac as fetchCliUpdateState, ad as resolveCliUpdateCheckInterval, ae as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, af as releaseDaemonLock, i as isValidSessionId, ag as listVhTerminals, ah as isValidTerminalId, ai as readVhTerminal, aj as sendToVhTerminal, ak as TITLE_PROMPT_PREFIX, al as BOARD_ANALYZER_PROMPT_PREFIX, h as connectionState, am as startOfflineReconnection, an as clearCredentials, ao as clearMachineId, m as ensurePrivateDirectorySync, ap as SandboxConfigSchema, b as createEnvelope, aq as CodexAppServerClient, ar as getLatestDaemonLog } from './types-jSfU_0o1.mjs';
 import spawn$1, { spawn } from 'cross-spawn';
 import path, { join, resolve, basename, delimiter, isAbsolute, normalize, sep, dirname } from 'node:path';
 import { createInterface } from 'node:readline';
-import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, unlinkSync, writeFileSync, accessSync, constants, renameSync, rmSync as rmSync$1, chmodSync as chmodSync$1 } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, unlinkSync, renameSync, writeFileSync, accessSync, constants, rmSync as rmSync$1, chmodSync as chmodSync$1 } from 'node:fs';
 import { t as trimIdent, A as AGENT_GUIDANCE, P as PREVIEW_TOOL_NAME, R as REPORT_PROGRESS_TOOL_NAME, a as PREVIEW_TOOL_TITLE, b as PREVIEW_TOOL_DESCRIPTION, c as REPORT_PROGRESS_TOOL_TITLE, d as REPORT_PROGRESS_TOOL_DESCRIPTION } from './agentGuidance-C2_pkgRI.mjs';
 import { readFile, writeFile, rename, unlink, mkdir, stat, open as open$1, appendFile } from 'node:fs/promises';
 import fs, { watch, access } from 'fs/promises';
@@ -14,7 +14,7 @@ import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { query as query$1, AbortError } from '@anthropic-ai/claude-agent-sdk';
 import axios, { AxiosError } from 'axios';
 import 'node:events';
-import 'socket.io-client';
+import { io } from 'socket.io-client';
 import tweetnacl from 'tweetnacl';
 import os$1, { homedir as homedir$1 } from 'os';
 import { spawn as spawn$2, execSync as execSync$1, exec } from 'child_process';
@@ -128,7 +128,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}`;
       logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
       return {
         error: errorMessage
@@ -195,6 +197,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 readDaemonState();
   if (!state) {
@@ -4651,8 +4660,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;
@@ -4666,7 +4675,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(),
@@ -4885,7 +4894,7 @@ function daemonReadiness(authenticated, running, hasState) {
     message: "\u26A0\uFE0F  Daemon is not running \u2014 run `very-happy daemon start`"
   };
 }
-function collectRuntimeReadiness(run = spawnSync, currentNodeVersion = process.version) {
+function collectRuntimeReadiness(run = spawnSync, currentNodeVersion = process.version, onPath = commandOnPath) {
   const tmux = probe("tmux", run);
   return {
     node: {
@@ -4896,7 +4905,8 @@ function collectRuntimeReadiness(run = spawnSync, currentNodeVersion = process.v
       ...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") }
   };
 }
 
@@ -5145,6 +5155,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 {
@@ -5195,6 +5210,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,
@@ -5596,6 +5616,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";
 }
@@ -5820,7 +5844,8 @@ function startDaemonControlServer({
   onSessionStateEvent,
   onClaudeAuthFailed,
   pushClipboard,
-  onTerminalHook
+  onTerminalHook,
+  setTerminalTitle
 }) {
   return new Promise((resolve) => {
     const app = fastify({
@@ -5940,7 +5965,7 @@ function startDaemonControlServer({
           // ignores it and supplies its own home daemon-side.
           directory: z.string().default(""),
           sessionId: z.string().optional(),
-          agent: z.enum(["claude", "codex", "gemini", "openclaw"]).optional(),
+          agent: z.enum(SPAWN_AGENTS).optional(),
           environmentVariables: z.record(z.string(), z.string()).optional(),
           variant: z.enum(["assistant"]).optional(),
           // B-051: assistant only — stop the live assistant, purge its
@@ -6045,6 +6070,30 @@ function startDaemonControlServer({
       logger.debug(`[CONTROL SERVER] Clipboard push request (${text.length} chars)`);
       return pushClipboard(text);
     });
+    typed.post("/terminal-title", {
+      schema: {
+        body: z.object({
+          terminalId: z.string().regex(/^[a-zA-Z0-9_-]{1,64}$/),
+          title: z.string().min(1).max(200),
+          ifAbsent: z.boolean().optional()
+        }),
+        response: {
+          200: z.object({ status: z.literal("ok") }),
+          409: z.object({ error: z.string() }),
+          503: z.object({ error: 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: {
@@ -6850,6 +6899,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 = join(configuration.happyHomeDir, SESSION_MODE_DIR)) {
+  return join(dir, `${happySessionId}.json`);
+}
+function sessionModeFilePayload(permissionMode, now = Date.now()) {
+  return { permissionMode, updatedAt: now };
+}
+function writeSessionModeFile(happySessionId, permissionMode, opts = {}) {
+  const path = sessionModeFilePath(happySessionId, opts.dir);
+  mkdirSync(join(path, ".."), { recursive: true, mode: 448 });
+  const payload = sessionModeFilePayload(permissionMode, opts.now);
+  const tmp = `${path}.${process.pid}.tmp`;
+  writePrivateFileSync(tmp, JSON.stringify(payload));
+  renameSync(tmp, path);
+  return payload;
+}
+function removeSessionModeFile(happySessionId, dir) {
+  const path = sessionModeFilePath(happySessionId, dir);
+  if (existsSync(path)) 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.object({
   path: z.string().min(1),
   flavor: z.string().optional(),
@@ -7097,6 +7216,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 = 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 ?? homedir();
@@ -8315,6 +8452,7 @@ function sanitizeImportTitle(value) {
   return collapsed.length > 200 ? `${collapsed.slice(0, 199)}\u2026` : collapsed;
 }
 const hostSuffix = process.env.HAPPY_VARIANT === "dev" ? "-dev" : "";
+const startupCliAvailability = detectCLIAvailability();
 const initialMachineMetadata = {
   host: os$1.hostname() + hostSuffix,
   platform: os$1.platform(),
@@ -8322,7 +8460,7 @@ const initialMachineMetadata = {
   homeDir: os$1.homedir(),
   happyHomeDir: configuration.happyHomeDir,
   happyLibDir: projectPath(),
-  cliAvailability: detectCLIAvailability(),
+  cliAvailability: startupCliAvailability,
   resumeSupport: { ...detectResumeSupport(), rpcAvailable: true }
 };
 async function preflightNewBundle(bundlePath) {
@@ -8377,6 +8515,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 = spawn$3("npm", args, { stdio: "ignore", env: process.env });
+    } catch {
+      done(null);
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      done(null);
+    }, AUTO_UPDATE_INSTALL_TIMEOUT_MS);
+    child.on("error", () => {
+      clearTimeout(timer);
+      done(null);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      done(code);
+    });
+  });
+}
+const AUTO_UPDATE_INSTALL_TIMEOUT_MS = 10 * 6e4;
 async function startDaemon() {
   let claudeAuthServiceRef = null;
   let cliUpdateStateRef = null;
@@ -8546,18 +8718,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) => {
       logger.debugLargeJson("[DAEMON RUN] Spawning session", summarizeSpawnSessionForLog(options));
       const spawnPermissionMode = sanitizeSpawnPermissionMode(options.permissionMode);
       if (options.permissionMode !== void 0 && spawnPermissionMode === null) {
         logger.warn("[DAEMON RUN] Ignoring invalid permissionMode in spawn request");
       }
-      if (options.variant === "assistant") {
+      const unavailable = spawnAgentUnavailableError(options.agent, currentCliAvailability());
+      if (unavailable) {
+        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()]) {
@@ -8760,7 +8940,13 @@ async function startDaemon() {
           logger.debug(`[DAEMON RUN] Attempting to spawn session in tmux: ${sessionDesc}`);
           const tmux = getTmuxUtilities(tmuxSessionName);
           const cliPath = join$1(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 ${shellescape(resumeId)}` : "";
           const permissionModeFragment = spawnPermissionMode ? ` --permission-mode ${shellescape(spawnPermissionMode)}` : "";
@@ -8788,7 +8974,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.`
@@ -8835,6 +9021,9 @@ async function startDaemon() {
             case "openclaw":
               agentCommand = "openclaw";
               break;
+            case "pi":
+              agentCommand = "pi";
+              break;
             default:
               return {
                 type: "error",
@@ -8866,7 +9055,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
           });
         }
@@ -9347,6 +9536,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();
@@ -9443,6 +9636,48 @@ async function startDaemon() {
         host: initialMachineMetadata.host
       })).then(() => logger.debug(`[DAEMON RUN] claimed the machine record for host ${initialMachineMetadata.host}`)).catch((error) => logger.debug("[DAEMON RUN] could not refresh the recorded host:", error));
     }
+    let autoUpdateFailedVersion = null;
+    let autoUpdateRunning = false;
+    const maybeAutoUpdate = async (cliUpdate) => {
+      if (autoUpdateRunning) return;
+      const settings = await readSettings();
+      const decision = decideAutoUpdate({
+        enabled: (settings.cliAutoUpdate ?? "idle") !== "off",
+        currentVersion: cliUpdate.currentVersion,
+        recommendedVersion: cliUpdate.recommendedVersion,
+        idle: pidToTrackedSession.size === 0 && !apiMachine.hasLiveTerminals(),
+        failedVersion: autoUpdateFailedVersion
+      });
+      if (decision.action === "skip") {
+        logger.debug(`[DAEMON RUN] auto-update skipped: ${decision.reason}`);
+        return;
+      }
+      autoUpdateRunning = true;
+      const target = decision.version;
+      const report = (state, detail) => {
+        cliUpdateStateRef = { ...cliUpdate, autoUpdate: { state, version: target, detail, at: Date.now() } };
+        void apiMachine.setCliUpdateState(cliUpdateStateRef);
+      };
+      logger.warn(`[DAEMON RUN] auto-updating CLI to ${target} (machine idle)`);
+      report("installing");
+      try {
+        const code = await runNpmInstall(autoUpdateInstallArgs(target));
+        if (code === 0) {
+          logger.warn(`[DAEMON RUN] auto-update installed ${target}; handover follows once it verifies`);
+          report("installed");
+        } else {
+          autoUpdateFailedVersion = target;
+          logger.warn(`[DAEMON RUN] auto-update of ${target} failed with exit ${code}`);
+          report("failed", `npm exited ${code}`);
+        }
+      } catch (error) {
+        autoUpdateFailedVersion = target;
+        logger.warn(`[DAEMON RUN] auto-update of ${target} could not run:`, error);
+        report("failed", String(error).slice(0, 200));
+      } finally {
+        autoUpdateRunning = false;
+      }
+    };
     let cliUpdateCheckRunning = false;
     const refreshCliUpdate = async () => {
       if (cliUpdateCheckRunning) return;
@@ -9455,6 +9690,7 @@ async function startDaemon() {
         cliUpdateStateRef = cliUpdate;
         apiMachine.setCliUpdateState(cliUpdate);
         logger.debug(`[DAEMON RUN] CLI update policy checked: ${cliUpdate.status} (recommended=${cliUpdate.recommendedVersion ?? "none"}, minimum=${cliUpdate.minimumVersion ?? "none"})`);
+        await maybeAutoUpdate(cliUpdate);
       } catch (error) {
         logger.debug("[DAEMON RUN] CLI update policy check failed:", error);
       } finally {
@@ -9667,6 +9903,194 @@ function formatTranscript(bodies) {
   return lines.join("\n");
 }
 
+const USER_SOCKET_CONNECT_TIMEOUT_MS = 15e3;
+async function openUserScopedSocket(token, options = {}) {
+  const socket = io(configuration.serverUrl, {
+    auth: {
+      token,
+      clientType: "user-scoped",
+      happyClient: `cli-session-ops/${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 ${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 ${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 ?? 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 = decodeBase64(persisted.encryptionKey);
+  const params = encodeBase64(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) => decrypt(key, persisted.encryptionVariant, 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 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(
+    `${configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`,
+    {
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "X-Happy-Client": `${PERMISSION_OPS_CLIENT}/${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 decrypt(decodeBase64(persisted.encryptionKey), persisted.encryptionVariant, decodeBase64(raw));
+}
+
 const SESSION_OPS_CLIENT = "session-ops";
 const DEFAULT_RECENT_LIMIT = 15;
 const MAX_READ_LIMIT = 100;
@@ -9678,10 +10102,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) {
@@ -9691,6 +10112,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 {
@@ -9710,6 +10138,79 @@ async function listSessions(options = {}) {
   const live = await listDaemonSessions();
   return mergeSessionSummaries(live, 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 = decodeBase64(persisted.encryptionKey);
+  let metadata = null;
+  let agentState = null;
+  try {
+    metadata = row.metadata ? decrypt(key, persisted.encryptionVariant, decodeBase64(row.metadata)) : null;
+    agentState = row.agentState ? decrypt(key, persisted.encryptionVariant, 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(`${configuration.serverUrl}/v1/sessions`, {
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.currentCliVersion}`
+    },
+    timeout: 15e3
+  });
+  const rows = Array.isArray(response.data?.sessions) ? response.data.sessions : [];
+  const persisted = 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 readCredentialsForConfiguredRelay();
   if (!credentials) throw new Error("CLI is not authenticated (no ~/.happy/access.key)");
@@ -9738,6 +10239,7 @@ async function readSessionTranscript(sessionId, limit) {
   const messages = Array.isArray(response.data?.messages) ? response.data.messages : [];
   messages.reverse();
   const key = decodeBase64(persisted.encryptionKey);
+  const live = await listDaemonSessions();
   const bodies = messages.map((message) => {
     if (message.content?.t !== "encrypted") return null;
     try {
@@ -9747,7 +10249,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)
   };
@@ -9843,13 +10345,16 @@ function normalizeSpawnDirectory(input, homeDir) {
   return { ok: true, directory: 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",
@@ -9886,6 +10391,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",
@@ -10002,6 +10511,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",
@@ -10671,7 +11182,7 @@ function registerSideQuestionHandler(rpc, deps) {
   const retainMs = deps.retainMs ?? SIDE_QUESTION_RETAIN_MS;
   const maxRunMs = deps.maxRunMs ?? SIDE_QUESTION_MAX_RUN_MS;
   const run = deps.run ?? (async (input) => {
-    const { query } = await import('./index-B2KfhNku.mjs');
+    const { query } = await import('./index-B0o3H6_x.mjs');
     return runSideQuestion(query, input);
   });
   const slots = /* @__PURE__ */ new Map();
@@ -11211,7 +11722,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(),
@@ -15601,7 +16112,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     process.exit(0);
   } else if (subcommand === "install-terminal-hooks") {
     try {
-      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-DD6QuHfT.mjs');
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-DeYqyjCB.mjs');
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -15618,7 +16129,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "spawn") {
     try {
-      const { handleSpawnCommand } = await import('./spawn-qb344Y5E.mjs');
+      const { handleSpawnCommand } = await import('./spawn-CsrHZd3y.mjs');
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -15630,7 +16141,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "sessions") {
     try {
-      const { handleSessionsCommand } = await import('./sessions-CmabJzYS.mjs');
+      const { handleSessionsCommand } = await import('./sessions-DYPB3Peg.mjs');
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -15642,7 +16153,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "send") {
     try {
-      const { handleSendCommand } = await import('./send-C6G2jsQp.mjs');
+      const { handleSendCommand } = await import('./send-CYznZGrp.mjs');
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -15748,9 +16259,9 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     if (geminiSubcommand === "project" && args[2] === "set" && args[3]) {
       const projectId = args[3];
       try {
-        const { saveGoogleCloudProjectToConfig } = await import('./config-CMgRBQMS.mjs');
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./types-B3qx8Ga1.mjs').then(function (n) { return n.aq; });
-        const { ApiClient: ApiClient2 } = await import('./types-B3qx8Ga1.mjs').then(function (n) { return n.ar; });
+        const { saveGoogleCloudProjectToConfig } = await import('./config-CnA3JIUn.mjs');
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./types-jSfU_0o1.mjs').then(function (n) { return n.as; });
+        const { ApiClient: ApiClient2 } = await import('./types-jSfU_0o1.mjs').then(function (n) { return n.at; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -15781,7 +16292,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
     if (geminiSubcommand === "project" && args[2] === "get") {
       try {
-        const { readGeminiLocalConfig } = await import('./config-CMgRBQMS.mjs');
+        const { readGeminiLocalConfig } = await import('./config-CnA3JIUn.mjs');
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -15821,7 +16332,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await import('./runGemini-DdJqpywr.mjs');
+      const { runGemini } = await import('./runGemini-CEURRmM4.mjs');
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -15841,9 +16352,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 import('./index-DiRN0Rv8.mjs');
+      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 import('./index-CpGR7rIw.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-DiRN0Rv8.mjs');
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -15883,7 +16429,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "openclaw") {
     try {
-      const { runOpenClaw } = await import('./runOpenClaw-CM5UrVBy.mjs');
+      const { runOpenClaw } = await import('./runOpenClaw-BozfKWng.mjs');
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -15934,7 +16480,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "mcp" && args.length === 1) {
     try {
-      const { handleMcpCommand } = await import('./mcp-CiNrjYox.mjs');
+      const { handleMcpCommand } = await import('./mcp-D_5aOK0I.mjs');
       await handleMcpCommand();
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}
@@ -16149,10 +16695,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
@@ -16178,6 +16726,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
@@ -16292,4 +16841,4 @@ ${chalk.bold("Examples:")}
   }
 }
 
-export { ALLOWED_SPAWN_PERMISSION_MODES as A, BasePermissionHandler as B, MessageBuffer as C, DEFAULT_RECENT_LIMIT as D, CHANGE_TITLE_INSTRUCTION as E, GEMINI_MODEL_ENV as G, MAX_READ_LIMIT as M, sessionWebUrl as a, sanitizeSpawnPermissionMode as b, checkIfDaemonRunningAndCleanupStaleState as c, sendUserMessage as d, stopSession as e, archiveSession as f, DEFAULT_GEMINI_MODEL as g, initialMachineMetadata as h, isValidSpawnOrigin as i, createSessionMetadata as j, setupOfflineReconnection as k, listSessions as l, MessageQueue2 as m, notifyDaemonSessionStarted as n, hashObject as o, pushClipboardViaDaemon as p, query as q, readSessionTranscript as r, spawnDaemonSession as s, tmuxSupportsSessionEnv as t, startHappyServer as u, registerKillSessionHandler as v, waitForSessionKey as w, GEMINI_API_KEY_ENV as x, GOOGLE_API_KEY_ENV as y, BaseReasoningProcessor as z };
+export { ALLOWED_SPAWN_PERMISSION_MODES as A, registerKillSessionHandler as B, BasePermissionHandler as C, DEFAULT_RECENT_LIMIT as D, writeSessionModeFile as E, normalizeAcpPermissionMode as F, GEMINI_MODEL_ENV as G, removeSessionModeFile as H, GEMINI_API_KEY_ENV as I, GOOGLE_API_KEY_ENV as J, BaseReasoningProcessor as K, MessageBuffer as L, MAX_READ_LIMIT as M, CHANGE_TITLE_INSTRUCTION as N, SPAWN_AGENTS as S, TitleGenerator as T, sessionWebUrl as a, sanitizeSpawnPermissionMode as b, checkIfDaemonRunningAndCleanupStaleState as c, sendUserMessage as d, listSessions as e, stopSession as f, resolvePermissionRequest as g, archiveSession as h, isValidSpawnOrigin as i, DEFAULT_GEMINI_MODEL as j, setTerminalTitleViaDaemon as k, listAccountSessions as l, registerAssistantSessionTools as m, initialMachineMetadata as n, createSessionMetadata as o, pushClipboardViaDaemon as p, query as q, readSessionTranscript as r, spawnDaemonSession as s, tmuxSupportsSessionEnv as t, setupOfflineReconnection as u, notifyDaemonSessionStarted as v, waitForSessionKey as w, MessageQueue2 as x, hashObject as y, startHappyServer as z };