very-happy-cli 0.2.123 → 0.2.125

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

@@ -1,12 +1,13 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
 import os, { homedir, userInfo, tmpdir } from 'node:os';
 import { randomUUID, randomBytes, createHash as createHash$1, timingSafeEqual } from 'node:crypto';
-import { o as readDaemonState, l as logger, c as configuration, q as clearDaemonState, t as getProjectPath, p as projectPath, u as initializeSandbox, v as wrapCommand, g as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, k as delay, x as AsyncLock, S as STREAM_DELTA_MAX_CHARS, y as ensurePrivateDirectory, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, z as hardenPrivateFile, j as packageJson, B as commandOnPath, e as readSettings, C as readCredentials, D as credentialRelayProblem, E as deriveLocalCliUpdateSummary, f as encodeBase64, F as readSettingsOutcome, G as updateSettings, H as encodeBase64Url, J as decodeBase64, K as writeCredentialsLegacy, L as writeCredentialsDataKey, N as readCredentialsForConfiguredRelay, O as encrypt, r as readPersistedSessions, P as isClaudeSessionId, w as writePrivateFileSync, Q as getLocalHappyAgentCredentialPath, T as readLocalHappyAgentCredentials, U as decryptWithDataKey, V as decryptLegacy, W as parseExactVersion, X as compareExactVersions, Y as extractCompleteLines, Z as decideBackfill, _ as parseTerminalHookPayload, $ as tmuxArgs, a0 as scrubTmuxClientEnv, a1 as decideMirrorBinding, a2 as MIRROR_BACKFILL_LINES_DEFAULT, a3 as persistSession, a4 as mirrorLineKey, a5 as mirrorLocalId, a6 as detectCLIAvailability, a7 as detectResumeSupport, a8 as acquireDaemonLock, a9 as summarizeSpawnSessionForLog, aa as deletePersistedSessions, ab as shellescape, ac as decrypt, ad as writeDaemonState, A as ApiClient, ae as writeSettings, af as fetchCliUpdateState, ag as resolveCliUpdateCheckInterval, ah as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, ai as releaseDaemonLock, i as isValidSessionId, aj as listVhTerminals, ak as isValidTerminalId, al as readVhTerminal, am as sendToVhTerminal, an as TITLE_PROMPT_PREFIX, ao as BOARD_ANALYZER_PROMPT_PREFIX, d as connectionState, ap as startOfflineReconnection, aq as clearCredentials, ar as clearMachineId, m as ensurePrivateDirectorySync, as as SandboxConfigSchema, b as createEnvelope, at as CodexAppServerClient, au as getLatestDaemonLog } from './types-BqW7nEN_.mjs';
+import { g as getProjectPath, p as projectPath, h as initializeSandbox, w as wrapCommand, b as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, d as delay, j as AsyncLock, S as STREAM_DELTA_MAX_CHARS, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, k as commandOnPath, l as deriveLocalCliUpdateSummary, m as isClaudeSessionId, n as getLocalHappyAgentCredentialPath, r as readLocalHappyAgentCredentials, o as parseExactVersion, q as compareExactVersions, t as extractCompleteLines, u as decideBackfill, v as parseTerminalHookPayload, x as tmuxArgs, y as scrubTmuxClientEnv, z as decideMirrorBinding, B as MIRROR_BACKFILL_LINES_DEFAULT, C as mirrorLineKey, D as mirrorLocalId, E as detectCLIAvailability, F as detectResumeSupport, G as summarizeSpawnSessionForLog, H as shellescape, A as ApiClient, J as fetchCliUpdateState, K as resolveCliUpdateCheckInterval, L as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, i as isValidSessionId, N as listVhTerminals, O as isValidTerminalId, P as readVhTerminal, Q as sendToVhTerminal, T as TITLE_PROMPT_PREFIX, U as BOARD_ANALYZER_PROMPT_PREFIX, f as connectionState, V as startOfflineReconnection, c as createEnvelope, W as CodexAppServerClient } from './types-DLDkfrTC.mjs';
+import { z as readDaemonState, l as logger, c as configuration, A as clearDaemonState, B as ensurePrivateDirectory, D as hardenPrivateFile, p as packageJson, f as readSettings, E as readCredentials, s as credentialRelayProblem, g as encodeBase64, F as readSettingsOutcome, G as updateSettings, H as encodeBase64Url, m as decodeBase64, I as writeCredentialsLegacy, J as writeCredentialsDataKey, i as readCredentialsForConfiguredRelay, j as encrypt, r as readPersistedSessions, w as writePrivateFileSync, K as decryptWithDataKey, L as decryptLegacy, M as persistSession, k as decrypt, e as ensurePrivateDirectorySync, N as acquireDaemonLock, O as deletePersistedSessions, P as writeDaemonState, Q as writeSettings, R as releaseDaemonLock, C as CLIPBOARD_TOOL_NAME, a as CLIPBOARD_TOOL_TITLE, b as CLIPBOARD_TOOL_DESCRIPTION, d as CLIPBOARD_MAX_BYTES, S as clearCredentials, T as clearMachineId, U as SandboxConfigSchema, V as getLatestDaemonLog } from './limits-FjbPJPsF.mjs';
 import spawn$1, { spawn } from 'cross-spawn';
 import path, { join, resolve, basename, isAbsolute, dirname, sep, delimiter, normalize } from 'node:path';
 import { createInterface } from 'node:readline';
-import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, unlinkSync, renameSync, writeFileSync, accessSync, constants, rmSync as rmSync$1, chmodSync as chmodSync$1 } from 'node:fs';
-import { t as trimIdent, A as AGENT_GUIDANCE, P as PREVIEW_TOOL_NAME, R as REPORT_PROGRESS_TOOL_NAME, a as PREVIEW_TOOL_TITLE, b as PREVIEW_TOOL_DESCRIPTION, c as REPORT_PROGRESS_TOOL_TITLE, d as REPORT_PROGRESS_TOOL_DESCRIPTION } from './agentGuidance-C2_pkgRI.mjs';
+import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, unlinkSync, renameSync, writeFileSync, accessSync, constants, openSync, fsyncSync, closeSync, 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, T as TEAM_TOOL_NAMES, r as registerTeamsTools, a as PREVIEW_TOOL_TITLE, b as PREVIEW_TOOL_DESCRIPTION, d as REPORT_PROGRESS_TOOL_TITLE, e as REPORT_PROGRESS_TOOL_DESCRIPTION } from './agentGuidance-QpYwykb9.mjs';
 import { readFile, writeFile, rename, unlink, mkdir, symlink, rm, readlink, lstat, stat, open as open$1, appendFile } from 'node:fs/promises';
 import fs, { watch, access } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
@@ -17,7 +18,7 @@ import 'node:events';
 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';
+import { spawn as spawn$2, execSync as execSync$1, exec as exec$1 } from 'child_process';
 import { createId } from '@paralleldrive/cuid2';
 import { execSync, spawnSync, spawn as spawn$3, execFile, execFileSync } from 'node:child_process';
 import { existsSync as existsSync$1, statSync as statSync$1, mkdtempSync, rmSync, writeFileSync as writeFileSync$1, chmodSync, unlinkSync as unlinkSync$1 } from 'fs';
@@ -32,12 +33,12 @@ import fastify from 'fastify';
 import { z } from 'zod';
 import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
 import { createRequire } from 'node:module';
+import { promisify } from 'node:util';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { createServer } from 'node:http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { C as CLIPBOARD_TOOL_NAME, a as CLIPBOARD_TOOL_TITLE, b as CLIPBOARD_TOOL_DESCRIPTION, c as CLIPBOARD_MAX_BYTES } from './limits-CwFb5S2b.mjs';
 import { createServer as createServer$1 } from 'http';
-import { promisify } from 'util';
+import { promisify as promisify$1 } from 'util';
 import inquirer from 'inquirer';
 import { fileURLToPath } from 'node:url';
 import { createInterface as createInterface$1 } from 'node:readline/promises';
@@ -5818,7 +5819,7 @@ async function waitForSessionKey(sessionId, timeoutMs) {
     await delay(200);
   }
 }
-async function sendUserMessage(sessionId, persisted, text, client) {
+async function sendUserMessage(sessionId, persisted, text, client, options = {}) {
   const credentials = await readCredentialsForConfiguredRelay();
   if (!credentials) {
     throw new Error("Not authenticated. Run `very-happy auth login` first.");
@@ -5830,7 +5831,7 @@ async function sendUserMessage(sessionId, persisted, text, client) {
       text
     },
     meta: {
-      sentFrom: "cli"
+      sentFrom: options.sentFrom ?? "cli"
     }
   };
   const encrypted = encodeBase64(encrypt(
@@ -5840,7 +5841,7 @@ async function sendUserMessage(sessionId, persisted, text, client) {
   ));
   await axios.post(
     `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(sessionId)}/messages`,
-    { messages: [{ content: encrypted, localId: randomUUID() }] },
+    { messages: [{ content: encrypted, localId: options.localId ?? randomUUID() }] },
     {
       headers: {
         "Authorization": `Bearer ${credentials.token}`,
@@ -8799,1791 +8800,2104 @@ async function claimSessionOrExit(happySessionId, options) {
   process.on("exit", () => releaseSessionLock(happySessionId));
 }
 
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function sanitizeImportTitle(value) {
-  if (typeof value !== "string") return null;
-  const collapsed = value.replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
-  if (collapsed.length === 0) return null;
-  return collapsed.length > 200 ? `${collapsed.slice(0, 199)}\u2026` : collapsed;
+const MAX_LINE_CHARS = 500;
+const MAX_ARGS_CHARS = 160;
+function truncateText(text, max = MAX_LINE_CHARS) {
+  const chars = Array.from(text);
+  if (chars.length <= max) return text;
+  return chars.slice(0, max).join("") + ` \u2026[+${chars.length - max} chars]`;
 }
-const hostSuffix = process.env.HAPPY_VARIANT === "dev" ? "-dev" : "";
-const startupCliAvailability = detectCLIAvailability();
-const initialMachineMetadata = {
-  host: os$1.hostname() + hostSuffix,
-  platform: os$1.platform(),
-  happyCliVersion: packageJson.version,
-  homeDir: os$1.homedir(),
-  happyHomeDir: configuration.happyHomeDir,
-  happyLibDir: projectPath(),
-  cliAvailability: startupCliAvailability,
-  resumeSupport: { ...detectResumeSupport(), rpcAvailable: true }
-};
-async function preflightNewBundle(bundlePath) {
-  const home = mkdtempSync(join$1(tmpdir(), "vh-preflight-"));
+function squash(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function safeJson(value, max) {
   try {
-    return await new Promise((resolve) => {
-      let stdout = "";
-      let settled = false;
-      const done = (run) => {
-        if (settled) return;
-        settled = true;
-        resolve(decideHandover(run));
-      };
-      let child;
-      try {
-        child = spawn$3(process.execPath, ["--no-warnings", "--no-deprecation", bundlePath, "--version"], {
-          env: { ...process.env, HAPPY_HOME_DIR: home },
-          stdio: ["ignore", "pipe", "ignore"]
-        });
-      } catch (error) {
-        done({ exitCode: null, stdout: "", timedOut: false, spawnError: String(error) });
-        return;
+    return truncateText(JSON.stringify(value) ?? "", max);
+  } catch {
+    return "[unserializable]";
+  }
+}
+function formatMessageBody(body) {
+  if (!body || typeof body !== "object") return null;
+  const b = body;
+  if (b.role === "user" && b.content?.type === "text" && typeof b.content.text === "string") {
+    const text = squash(b.content.text);
+    return text.length > 0 ? `user: ${truncateText(text)}` : null;
+  }
+  if (b.role === "session" && b.content && typeof b.content === "object") {
+    const env = b.content;
+    const ev = env.ev;
+    if (!ev || typeof ev.t !== "string") return null;
+    switch (ev.t) {
+      case "text": {
+        if (ev.thinking) return null;
+        const text = squash(String(ev.text ?? ""));
+        if (text.length === 0) return null;
+        const role = env.role === "user" ? "user" : "assistant";
+        return `${role}: ${truncateText(text)}`;
+      }
+      case "tool-call-start": {
+        const name = String(ev.name ?? "tool");
+        const title = squash(String(ev.title ?? ""));
+        const args = ev.args ? safeJson(ev.args, MAX_ARGS_CHARS) : "";
+        const detail = title || args;
+        return `[tool] ${name}${detail ? `: ${truncateText(detail, MAX_ARGS_CHARS)}` : ""}`;
+      }
+      case "service": {
+        const text = squash(String(ev.text ?? ""));
+        return text.length > 0 ? `[service] ${truncateText(text, MAX_ARGS_CHARS)}` : null;
+      }
+      case "turn-end": {
+        if (ev.status && ev.status !== "completed") return `[turn ${ev.status}]`;
+        return null;
+      }
+      default:
+        return null;
+    }
+  }
+  if (b.role === "agent" && b.content?.type === "acp" && b.content.data && typeof b.content.data === "object") {
+    const d = b.content.data;
+    switch (d.type) {
+      case "message": {
+        const text = squash(String(d.message ?? ""));
+        return text.length > 0 ? `assistant: ${truncateText(text)}` : null;
+      }
+      case "tool-call":
+        return `[tool] ${String(d.name ?? "tool")}: ${safeJson(d.input, MAX_ARGS_CHARS)}`;
+      case "permission-request":
+        return `[permission] ${String(d.toolName ?? "")}: ${truncateText(squash(String(d.description ?? "")), MAX_ARGS_CHARS)}`;
+      default:
+        return null;
+    }
+  }
+  if (b.role === "agent" && b.content?.type === "output") {
+    const msg = b.content.data?.message;
+    if (msg && Array.isArray(msg.content)) {
+      const texts = msg.content.filter((c) => c?.type === "text" && typeof c.text === "string").map((c) => squash(c.text)).filter((t) => t.length > 0);
+      if (texts.length > 0) {
+        const role = msg.role === "user" ? "user" : "assistant";
+        return `${role}: ${truncateText(texts.join(" "))}`;
       }
-      const timer = setTimeout(() => {
-        try {
-          child.kill("SIGKILL");
-        } catch {
-        }
-        done({ exitCode: null, stdout, timedOut: true });
-      }, HANDOVER_PREFLIGHT_TIMEOUT_MS);
-      child.stdout?.on("data", (chunk) => {
-        if (stdout.length < 8192) stdout += chunk.toString("utf8");
-      });
-      child.on("error", (error) => {
-        clearTimeout(timer);
-        done({ exitCode: null, stdout, timedOut: false, spawnError: String(error) });
-      });
-      child.on("close", (code) => {
-        clearTimeout(timer);
-        done({ exitCode: code, stdout, timedOut: false });
-      });
-    });
-  } finally {
-    try {
-      rmSync(home, { recursive: true, force: true });
-    } catch {
     }
+    return null;
   }
+  return null;
 }
-const HANDOVER_PREFLIGHT_TIMEOUT_MS = 3e4;
-async function startDaemon() {
-  let claudeAuthServiceRef = null;
-  let cliUpdateStateRef = null;
-  let lastHandoverHold = null;
-  let claudeCredentialStoreSetting = (await readSettings()).claudeCredentialStore === "file" ? "file" : "auto";
-  let requestShutdown;
-  let resolvesWhenShutdownRequested = new Promise((resolve) => {
-    requestShutdown = (source, errorMessage) => {
-      logger.debug(`[DAEMON RUN] Requesting shutdown (source: ${source}, errorMessage: ${errorMessage})`);
-      setTimeout(async () => {
-        logger.debug("[DAEMON RUN] Startup malfunctioned, forcing exit with code 1");
-        await new Promise((resolve2) => setTimeout(resolve2, 100));
-        process.exit(1);
-      }, 1e3);
-      resolve({ source, errorMessage });
-    };
-  });
-  process.on("SIGINT", () => {
-    logger.debug("[DAEMON RUN] Received SIGINT");
-    requestShutdown("os-signal");
-  });
-  process.on("SIGTERM", () => {
-    logger.debug("[DAEMON RUN] Received SIGTERM");
-    requestShutdown("os-signal");
-  });
-  process.on("uncaughtException", (error) => {
-    logger.debug("[DAEMON RUN] FATAL: Uncaught exception", error);
-    logger.debug(`[DAEMON RUN] Stack trace: ${error.stack}`);
-    requestShutdown("exception", error.message);
-  });
-  const prunedLogs = pruneLogsDir(configuration.logsDir, /* @__PURE__ */ new Set([logger.logFilePath]));
-  if (prunedLogs > 0) {
-    logger.debug(`[DAEMON RUN] Pruned ${prunedLogs} old log file(s) from ${configuration.logsDir}`);
+function formatTranscript(bodies) {
+  const lines = [];
+  for (const body of bodies) {
+    const line = formatMessageBody(body);
+    if (line !== null) lines.push(line);
   }
-  process.on("unhandledRejection", (reason, promise) => {
-    logger.debug("[DAEMON RUN] FATAL: Unhandled promise rejection", reason);
-    logger.debug(`[DAEMON RUN] Rejected promise:`, promise);
-    const error = reason instanceof Error ? reason : new Error(`Unhandled promise rejection: ${reason}`);
-    logger.debug(`[DAEMON RUN] Stack trace: ${error.stack}`);
-    requestShutdown("exception", error.message);
-  });
-  process.on("exit", (code) => {
-    logger.debug(`[DAEMON RUN] Process exiting with code: ${code}`);
+  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
   });
-  process.on("beforeExit", (code) => {
-    logger.debug(`[DAEMON RUN] Process about to exit with code: ${code}`);
+  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();
   });
-  logger.debug("[DAEMON RUN] Starting daemon process...");
-  logger.debugLargeJson("[DAEMON RUN] Environment", getEnvironmentInfo());
-  const runningDaemonVersionMatches = await isDaemonRunningCurrentlyInstalledHappyVersion();
-  const runningDaemonState = await readDaemonState();
-  const runningDaemonEndpointsMatch = Boolean(runningDaemonState) && daemonEndpointsMatch(
-    runningDaemonState?.serverUrl,
-    runningDaemonState?.webappUrl,
-    configuration.serverUrl,
-    configuration.webappUrl
-  );
-  if (!runningDaemonVersionMatches || !runningDaemonEndpointsMatch) {
-    logger.debug("[DAEMON RUN] Daemon version or endpoint mismatch detected, restarting daemon");
-    await stopDaemon();
-  } else {
-    logger.debug("[DAEMON RUN] Daemon version matches, keeping existing daemon");
-    console.log("Daemon already running with matching version");
-    process.exit(0);
-  }
-  const daemonLockHandle = await acquireDaemonLock(5, 200);
-  if (!daemonLockHandle) {
-    logger.debug("[DAEMON RUN] Daemon lock file already held, another daemon is running");
-    process.exit(0);
-  }
-  try {
-    const caffeinateStarted = startCaffeinate();
-    if (caffeinateStarted) {
-      logger.debug("[DAEMON RUN] Sleep prevention enabled");
+  return {
+    async rpcCall(payload, timeoutMs) {
+      const ack = await socket.timeout(timeoutMs).emitWithAck("rpc-call", payload);
+      return ack;
+    },
+    close() {
+      socket.close();
     }
-    const { credentials, machineId } = await authAndSetupMachineIfNeeded();
-    logger.debug("[DAEMON RUN] Auth and machine setup complete");
-    const pidToTrackedSession = /* @__PURE__ */ new Map();
-    const sessionIdToFinishedSession = /* @__PURE__ */ new Map();
-    const persisted = readPersistedSessions();
-    const liveHappyProcesses = await findAllHappyProcesses();
-    for (const [id, s] of Object.entries(persisted)) {
-      const tracked = {
-        startedBy: "persisted",
-        happySessionId: id,
-        happySessionMetadataFromLocalWebhook: s.metadata,
-        encryption: {
-          encryptionKey: decodeBase64(s.encryptionKey),
-          encryptionVariant: s.encryptionVariant,
-          seq: s.seq,
-          metadataVersion: s.metadataVersion,
-          agentStateVersion: s.agentStateVersion
-        },
-        pid: 0
-      };
-      const livePids = findSessionWrapperPids(s.metadata, liveHappyProcesses, { excludePid: process.pid, lockPid: readSessionLock(id)?.pid });
-      if (livePids.length > 0) {
-        const [livePid, ...duplicates] = livePids;
-        tracked.pid = livePid;
-        tracked.startedBy = "recovered after daemon restart";
-        pidToTrackedSession.set(livePid, tracked);
-        if (livePid !== s.metadata?.hostPid) {
-          logger.debug(`[DAEMON RUN] Session ${id}: persisted hostPid ${s.metadata?.hostPid} is stale; adopted live wrapper ${livePid} by its --resume command line`);
-        }
-        for (const dup of duplicates) {
-          logger.warn(`[DAEMON RUN] Session ${id} has a duplicate live wrapper ${dup} (kept ${livePid}); restart the session to collapse them`);
-          pidToTrackedSession.set(dup, { ...tracked, pid: dup, startedBy: "recovered after daemon restart (duplicate wrapper)" });
-        }
-        persistSession(id, { ...s, metadata: { ...s.metadata, hostPid: livePid }, savedAt: Date.now() });
-      } else {
-        sessionIdToFinishedSession.set(id, tracked);
-      }
+  };
+}
+
+const RPC_RATE_LIMIT_ERROR = "RPC rate limit reached";
+const RPC_ACCOUNT_RATE_LIMIT_ERROR = "RPC account rate limit reached";
+const RPC_RATE_RETRY_MIN_DELAY_MS = 2e3;
+const RPC_RATE_RETRY_MAX_DELAY_MS = 6e4;
+const RPC_RATE_MAX_RETRIES = 2;
+function isRpcRateLimitAck(ack) {
+  if (!ack || typeof ack !== "object") return false;
+  const a = ack;
+  if (a.ok !== false) return false;
+  if (a.code === "rpc_rate_limited" || a.code === "rpc_account_rate_limited") return true;
+  return a.error === RPC_RATE_LIMIT_ERROR || a.error === RPC_ACCOUNT_RATE_LIMIT_ERROR;
+}
+function rpcRateRetryDelayMs(attempt, retryAfterMs, random = Math.random()) {
+  if (typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs > 0) {
+    return Math.min(RPC_RATE_RETRY_MAX_DELAY_MS, Math.round(retryAfterMs * (1 + random * 0.5)));
+  }
+  const exponent = Math.max(0, Math.min(attempt, 32) - 1);
+  const ceiling = Math.min(RPC_RATE_RETRY_MIN_DELAY_MS * 2 ** exponent, RPC_RATE_RETRY_MAX_DELAY_MS);
+  return Math.round(RPC_RATE_RETRY_MIN_DELAY_MS + random * (ceiling - RPC_RATE_RETRY_MIN_DELAY_MS));
+}
+
+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 (Object.keys(persisted).length > 0) {
-      logger.debug(`[DAEMON RUN] Loaded ${Object.keys(persisted).length} persisted sessions from disk`);
+    if (message === "RPC target disconnected") {
+      return { status: "offline", message: "the wrapper disconnected while the permission RPC was in flight" };
     }
-    const pidToAwaiter = /* @__PURE__ */ new Map();
-    const getCurrentChildren = () => Array.from(pidToTrackedSession.values());
-    const onHappySessionWebhook = (sessionId, sessionMetadata, encryption) => {
-      logger.debugLargeJson(`[DAEMON RUN] Session reported`, sessionMetadata);
-      const pid = sessionMetadata.hostPid;
-      if (!pid) {
-        logger.debug(`[DAEMON RUN] Session webhook missing hostPid for sessionId: ${sessionId}`);
-        return;
-      }
-      logger.debug(`[DAEMON RUN] Session webhook: ${sessionId}, PID: ${pid}, started by: ${sessionMetadata.startedBy || "unknown"}, hasEncryption: ${!!encryption}`);
-      logger.debug(`[DAEMON RUN] Current tracked sessions before webhook: ${Array.from(pidToTrackedSession.keys()).join(", ")}`);
-      if (encryption) {
-        persistSession(sessionId, {
-          encryptionKey: encodeBase64(encryption.encryptionKey),
-          encryptionVariant: encryption.encryptionVariant,
-          seq: encryption.seq,
-          metadataVersion: encryption.metadataVersion,
-          agentStateVersion: encryption.agentStateVersion,
-          metadata: sessionMetadata,
-          savedAt: Date.now()
-        });
-      }
-      for (const [otherPid, other] of pidToTrackedSession.entries()) {
-        if (other.happySessionId === sessionId && otherPid !== pid && isPidAlive(otherPid)) {
-          logger.warn(`[DAEMON RUN] Session ${sessionId} now has two live wrappers (${otherPid} and ${pid}); restart the session to collapse them`);
-        }
-      }
-      const existingSession = pidToTrackedSession.get(pid);
-      if (existingSession && existingSession.startedBy === "daemon") {
-        existingSession.happySessionId = sessionId;
-        existingSession.happySessionMetadataFromLocalWebhook = sessionMetadata;
-        existingSession.encryption = encryption;
-        logger.debug(`[DAEMON RUN] Updated daemon-spawned session ${sessionId} with metadata`);
-        const awaiter = pidToAwaiter.get(pid);
-        if (awaiter) {
-          pidToAwaiter.delete(pid);
-          awaiter(existingSession);
-          logger.debug(`[DAEMON RUN] Resolved session awaiter for PID ${pid}`);
-        }
-      } else if (!existingSession) {
-        const trackedSession = {
-          startedBy: "happy directly - likely by user from terminal",
-          happySessionId: sessionId,
-          happySessionMetadataFromLocalWebhook: sessionMetadata,
-          encryption,
-          pid
-        };
-        pidToTrackedSession.set(pid, trackedSession);
-        logger.debug(`[DAEMON RUN] Registered externally-started session ${sessionId}`);
-      }
-    };
-    const assistantSpawnGate = createSpawnGate();
-    const spawnSession = (options) => {
-      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 (/timed? ?out/i.test(message)) {
+      return { status: "timeout", message };
+    }
+    if (isRpcRateLimitAck(ack)) {
+      return { status: "rate-limited", message, retryAfterMs: rpcRateRetryDelayMs(1, ack.retryAfterMs, 0) };
+    }
+    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);
       }
-      const unavailable = spawnAgentUnavailableError(options.agent, currentCliAvailability());
-      if (unavailable) {
-        logger.warn(`[DAEMON RUN] Refusing spawn of agent '${options.agent}': ${unavailable.errorMessage}`);
-        return unavailable;
+    );
+  });
+}
+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;
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let ack;
+  try {
+    for (let attempt = 1; ; attempt++) {
+      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" };
       }
-      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()]) {
-            if (!isAssistantTracked(tracked)) continue;
-            logger.debug(`[DAEMON RUN] forceNew: stopping assistant (session ${tracked.happySessionId ?? "unknown"}, pid ${tracked.pid})`);
-            stopSession(tracked.happySessionId ?? `PID-${tracked.pid}`);
-          }
-          const assistantIds = listPersistedAssistantIds(readPersistedSessions());
-          if (assistantIds.length > 0) {
-            deletePersistedSessions(assistantIds);
-            for (const id of assistantIds) {
-              sessionIdToFinishedSession.delete(id);
-            }
-            logger.debug(`[DAEMON RUN] forceNew: purged persisted assistant session(s): ${assistantIds.join(", ")}`);
-          }
-        } else {
-          const live = findLiveAssistant(pidToTrackedSession.values(), (pid) => {
-            try {
-              process.kill(pid, 0);
-              return true;
-            } catch {
-              return false;
-            }
-          });
-          if (live?.happySessionId) {
-            logger.debug(`[DAEMON RUN] Assistant already running (session ${live.happySessionId}, pid ${live.pid})`);
-            return { type: "success", sessionId: live.happySessionId };
-          }
-          if (live) {
-            return { type: "error", errorMessage: `Assistant session is still starting (pid ${live.pid}). Try again in a few seconds.` };
-          }
-        }
-        try {
-          const { created } = await bootstrapAssistantHome();
-          if (created.length > 0) {
-            logger.debug(`[DAEMON RUN] Assistant home bootstrapped: ${created.join(", ")}`);
-          }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          return { type: "error", errorMessage: `Failed to bootstrap assistant home: ${errorMessage}` };
-        }
-        const assistantEntry = options.forceNew ? void 0 : pickLatestAssistantEntry(readPersistedSessions());
-        if (assistantEntry) {
-          const [assistantSessionId, s] = assistantEntry;
-          logger.debug(`[DAEMON RUN] Re-attaching assistant session ${assistantSessionId}`);
-          const serverMetadata = await fetchServerSessionMetadata(
-            assistantSessionId,
-            decodeBase64(s.encryptionKey),
-            s.encryptionVariant
-          );
-          const claudeSessionId = resolveAssistantClaudeSessionId(s.metadata, serverMetadata);
-          const canResumeClaude = !!claudeSessionId && existsSync$1(join$1(getProjectPath(assistantHome()), `${claudeSessionId}.jsonl`));
-          return spawnTrackedHappyProcess({
-            args: [
-              "claude",
-              "--happy-starting-mode",
-              "remote",
-              "--started-by",
-              "daemon",
-              // Re-attach honors the CURRENT request's permission mode (the
-              // user may have just toggled the assistant permission setting).
-              ...spawnPermissionMode ? ["--permission-mode", spawnPermissionMode] : [],
-              ...canResumeClaude ? ["--resume", claudeSessionId] : []
-            ],
-            cwd: assistantHome(),
-            env: {
-              ...process.env,
-              // B-297: see the resume/restart paths — every spawn carries the
-              // credentialStore=file shim, not just fresh sessions (B-276 D8).
-              ...claudeAuthServiceRef?.claudeProcessEnvOverrides() ?? {},
-              HAPPY_SESSION_VARIANT: "assistant",
-              HAPPY_RECONNECT_SESSION_ID: assistantSessionId,
-              HAPPY_RECONNECT_ENCRYPTION_KEY: s.encryptionKey,
-              HAPPY_RECONNECT_ENCRYPTION_VARIANT: s.encryptionVariant,
-              HAPPY_RECONNECT_SEQ: String(s.seq),
-              HAPPY_RECONNECT_METADATA_VERSION: String(s.metadataVersion),
-              HAPPY_RECONNECT_AGENT_STATE_VERSION: String(s.agentStateVersion)
-            },
-            variant: "assistant"
-          });
-        }
-      }
-      const { directory, sessionId, machineId: machineId2, approvedNewDirectoryCreation = true } = options;
-      let directoryCreated = false;
-      try {
-        await fs.access(directory);
-        logger.debug(`[DAEMON RUN] Directory exists: ${directory}`);
-      } catch (error) {
-        logger.debug(`[DAEMON RUN] Directory doesn't exist, creating: ${directory}`);
-        if (!approvedNewDirectoryCreation) {
-          logger.debug(`[DAEMON RUN] Directory creation not approved for: ${directory}`);
-          return {
-            type: "requestToApproveDirectoryCreation",
-            directory
-          };
-        }
-        try {
-          await fs.mkdir(directory, { recursive: true });
-          logger.debug(`[DAEMON RUN] Successfully created directory: ${directory}`);
-          directoryCreated = true;
-        } catch (mkdirError) {
-          let errorMessage = `Unable to create directory at '${directory}'. `;
-          if (mkdirError.code === "EACCES") {
-            errorMessage += `Permission denied. You don't have write access to create a folder at this location. Try using a different path or check your permissions.`;
-          } else if (mkdirError.code === "ENOTDIR") {
-            errorMessage += `A file already exists at this path or in the parent path. Cannot create a directory here. Please choose a different location.`;
-          } else if (mkdirError.code === "ENOSPC") {
-            errorMessage += `No space left on device. Your disk is full. Please free up some space and try again.`;
-          } else if (mkdirError.code === "EROFS") {
-            errorMessage += `The file system is read-only. Cannot create directories here. Please choose a writable location.`;
-          } else {
-            errorMessage += `System error: ${mkdirError.message || mkdirError}. Please verify the path is valid and you have the necessary permissions.`;
-          }
-          logger.debug(`[DAEMON RUN] Directory creation failed: ${errorMessage}`);
-          return {
-            type: "error",
-            errorMessage
-          };
+      if (!isRpcRateLimitAck(ack) || attempt > RPC_RATE_MAX_RETRIES) break;
+      const waitMs = rpcRateRetryDelayMs(attempt, ack.retryAfterMs, (deps.random ?? Math.random)());
+      deps.onRateLimited?.({ attempt, waitMs, serverError: ack.error ?? "RPC rate limit reached" });
+      await sleep(waitMs);
+    }
+  } finally {
+    transport.close();
+  }
+  const outcome = interpretPermissionAck(ack, (encrypted) => decrypt(key, persisted.encryptionVariant, decodeBase64(encrypted)));
+  if (outcome.status !== "acknowledged") {
+    return { sessionId, requestId, payload, outcome };
+  }
+  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;
+function mergeSessionSummaries(live, persisted, options = {}) {
+  const recentLimit = Math.max(0, options.recentLimit ?? DEFAULT_RECENT_LIMIT);
+  const seen = /* @__PURE__ */ new Set();
+  const summaries = [];
+  for (const child of live) {
+    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], 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) {
+    summaries.push(toSummary(id, entry, { live: false }));
+  }
+  if (!options.tag) return summaries;
+  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 {
+    id,
+    live: extra.live,
+    ...extra.pid !== void 0 ? { pid: extra.pid } : {},
+    ...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 } : {},
+    url: sessionWebUrl(id),
+    ...persisted?.savedAt !== void 0 ? { savedAt: persisted.savedAt } : {}
+  };
+}
+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)");
+  return credentials.token;
+}
+async function readSessionTranscript(sessionId, limit) {
+  const persisted = readPersistedSessions()[sessionId];
+  if (!persisted) {
+    throw new Error(
+      `No local key for session ${sessionId} \u2014 it was not spawned by this machine's daemon (or is older than 14 days).`
+    );
+  }
+  const bounded = Math.max(1, Math.min(MAX_READ_LIMIT, Math.floor(limit)));
+  const token = await bearerToken();
+  const response = await axios.get(
+    `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(sessionId)}/messages`,
+    {
+      params: { before_seq: 2147483647, limit: bounded },
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.currentCliVersion}`
+      },
+      timeout: 15e3
+    }
+  );
+  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 {
+      return decrypt(key, persisted.encryptionVariant, decodeBase64(message.content.c));
+    } catch {
+      return null;
+    }
+  });
+  return {
+    summary: toSummary(sessionId, persisted, sessionLiveness(live, sessionId)),
+    messageCount: messages.length,
+    transcript: formatTranscript(bodies)
+  };
+}
+async function stopSession(sessionId) {
+  return await stopDaemonSession(sessionId);
+}
+async function archiveSession(sessionId) {
+  const token = await bearerToken();
+  await axios.post(
+    `${configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}/archive`,
+    {},
+    {
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.currentCliVersion}`
+      },
+      timeout: 1e4
+    }
+  );
+}
+
+function receiptPath(home, operationId) {
+  if (!/^[a-zA-Z0-9_-]{1,128}$/.test(operationId)) throw new Error("Invalid team operation id");
+  return join(home, "teams", "effects", `${operationId}.json`);
+}
+function readReceipt(home, id) {
+  try {
+    const value = JSON.parse(readFileSync(receiptPath(home, id), "utf8"));
+    if (value.operationId !== id || typeof value.claimId !== "string" || !["prepared", "spawning", "spawned", "delivered", "completed"].includes(value.phase)) throw new Error("Invalid team effect receipt");
+    return value;
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function writeReceipt(home, receipt) {
+  ensurePrivateDirectorySync(join(home, "teams", "effects"));
+  const target = receiptPath(home, receipt.operationId);
+  const tmp = `${target}.${process.pid}.tmp`;
+  writePrivateFileSync(tmp, JSON.stringify(receipt));
+  const file = openSync(tmp, "r");
+  try {
+    fsyncSync(file);
+  } finally {
+    closeSync(file);
+  }
+  renameSync(tmp, target);
+  if (process.platform !== "win32") {
+    const directory = openSync(join(home, "teams", "effects"), "r");
+    try {
+      fsyncSync(directory);
+    } finally {
+      closeSync(directory);
+    }
+  }
+}
+
+const exec = promisify(execFile);
+const git = async (directory, args) => (await exec("git", ["-C", directory, ...args], { timeout: 3e4, maxBuffer: 2 * 1024 * 1024 })).stdout.trim();
+async function prepareTeamWorktree(home, repository, id) {
+  if (!isAbsolute(repository) || !/^[a-zA-Z0-9_-]{1,128}$/.test(id)) throw new Error("A team task requires an absolute repository path and valid operation id");
+  await git(repository, ["rev-parse", "--show-toplevel"]);
+  const root = join(home, "teams", "worktrees");
+  ensurePrivateDirectorySync(root);
+  const directory = join(root, id);
+  const branch = `codex/team-${id}`;
+  if (existsSync(directory)) {
+    const actual = await git(directory, ["symbolic-ref", "--short", "HEAD"]);
+    if (actual !== branch) throw new Error("Team worktree path is occupied by another branch");
+    const common = await git(directory, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+    const expected = await git(repository, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+    if (resolve(common) !== resolve(expected)) throw new Error("Team worktree belongs to another repository");
+  } else {
+    await git(repository, ["worktree", "add", "-b", branch, directory, "HEAD"]);
+  }
+  return { directory, repository, branch };
+}
+async function removeTeamWorktree(resource) {
+  const { directory, repository, branch } = resource;
+  if (!directory || !repository || !branch) return;
+  if (existsSync(directory)) {
+    if (await git(directory, ["symbolic-ref", "--short", "HEAD"]) !== branch) throw new Error("Worktree branch changed; preserve for manual reconciliation");
+    const actualCommon = await git(directory, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+    const expectedCommon = await git(repository, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+    if (resolve(actualCommon) !== resolve(expectedCommon)) throw new Error("Worktree repository changed; preserve for manual reconciliation");
+    if (await git(directory, ["status", "--porcelain"])) throw new Error(`Uncommitted work retained at ${directory}`);
+    await git(repository, ["merge-base", "--is-ancestor", branch, "HEAD"]).catch(() => {
+      throw new Error(`Unmerged work retained on ${branch} at ${directory}`);
+    });
+    await git(repository, ["worktree", "remove", directory]);
+  }
+  try {
+    await git(repository, ["show-ref", "--verify", `refs/heads/${branch}`]);
+  } catch {
+    return;
+  }
+  await git(repository, ["branch", "-d", branch]);
+}
+
+function createTeamWorker(deps) {
+  const home = deps.home ?? configuration.happyHomeDir;
+  const server = deps.serverUrl ?? configuration.serverUrl;
+  const http = axios.create({ baseURL: server, timeout: 2e4, headers: { Authorization: `Bearer ${deps.token}` } });
+  let running = false;
+  let closed = false;
+  let disabledUntil = 0;
+  let knownSessionIds = /* @__PURE__ */ new Set();
+  const action = async (teamId, requestId, value) => (await http.post(`/v1/teams/${encodeURIComponent(teamId)}/actions`, { requestId, action: value })).data;
+  async function complete(op, receipt) {
+    await action(op.teamId, `complete-${op.id}`, { type: "complete-operation", operationId: op.id, machineId: deps.machineId, claimId: receipt.claimId, ...receipt.sessionId ? { sessionId: receipt.sessionId } : {} });
+    writeReceipt(home, { ...receipt, phase: "completed" });
+  }
+  async function execute(op) {
+    let receipt = readReceipt(home, op.id);
+    let credential;
+    if (!receipt) {
+      if (op.status !== "pending") {
+        if (op.status === "claimed" && op.claimId) {
+          await action(op.teamId, `missing-receipt-${op.id}`, { type: "fail-operation", operationId: op.id, machineId: deps.machineId, claimId: op.claimId, error: "Local execution receipt missing; verify the old process before manual reconciliation", unknown: true });
         }
+        return;
       }
-      try {
-        const authEnv = {};
-        if (options.token) {
-          if (options.agent === "codex") {
-            const codexHomeDir = tmp.dirSync();
-            await fs.writeFile(join$1(codexHomeDir.name, "auth.json"), options.token);
-            authEnv.CODEX_HOME = codexHomeDir.name;
-          } else {
-            authEnv.CLAUDE_CODE_OAUTH_TOKEN = options.token;
-          }
-        }
-        let extraEnv = {
-          ...authEnv,
-          ...options.environmentVariables ?? {},
-          // B-276 D8: credentialStore=file pins the spawned Claude Code (SDK
-          // Query, title/board one-shots — all inside this wrapper) to
-          // ~/.claude/.credentials.json via the keychain-off `security` shim.
-          ...claudeAuthServiceRef?.claudeProcessEnvOverrides() ?? {}
-        };
-        if (options.parentSessionId) {
-          extraEnv.HAPPY_FORKED_FROM_SESSION_ID = options.parentSessionId;
-        }
-        if (options.forkedFromMessageId) {
-          extraEnv.HAPPY_FORKED_FROM_MESSAGE_ID = options.forkedFromMessageId;
-        }
-        if (options.resumeClaudeSessionId) {
-          extraEnv.HAPPY_FORK_CLAUDE_SESSION_ID = options.resumeClaudeSessionId;
-        }
-        if (options.importedFromClaudeSessionId && UUID_RE.test(options.importedFromClaudeSessionId)) {
-          extraEnv.HAPPY_IMPORTED_FROM_CLAUDE_SESSION_ID = options.importedFromClaudeSessionId;
-        }
-        const importTitle = sanitizeImportTitle(options.importTitle);
-        if (importTitle) {
-          extraEnv.HAPPY_IMPORT_TITLE = importTitle;
-        }
-        if (options.resumeCodexThreadId) {
-          extraEnv.HAPPY_FORK_CODEX_THREAD_ID = options.resumeCodexThreadId;
-        }
-        if (options.variant === "assistant") {
-          extraEnv.HAPPY_SESSION_VARIANT = "assistant";
+      const claimed = await action(op.teamId, `claim-${op.id}`, { type: "claim-operation", operationId: op.id, machineId: deps.machineId });
+      if (!claimed.operation?.claimId) throw new Error("Operation claim did not return a receipt");
+      op = claimed.operation;
+      credential = claimed.credential;
+      receipt = { operationId: op.id, teamId: op.teamId, claimId: op.claimId, phase: "prepared" };
+      writeReceipt(home, receipt);
+    }
+    if (receipt.phase === "completed") return;
+    try {
+      if (op.type === "spawn") {
+        if (receipt.phase === "prepared") {
+          if (!credential) credential = (await action(op.teamId, `claim-${op.id}`, { type: "claim-operation", operationId: op.id, machineId: deps.machineId })).credential;
+          if (!credential) throw new Error("No scoped credential for worker");
+          const current = (await http.get(`/v1/teams/${encodeURIComponent(op.teamId)}`)).data.team;
+          const task = current.tasks.find((t) => t.id === op.taskId);
+          if (!task) throw new Error("Task state unavailable; refusing to start");
+          if (task.currentAttemptId !== op.attemptId || ["done", "cancelled"].includes(task.status)) {
+            await action(op.teamId, `cancelled-before-spawn-${op.id}`, { type: "fail-operation", operationId: op.id, machineId: deps.machineId, claimId: receipt.claimId, error: "task_closed_before_spawn" });
+            writeReceipt(home, { ...receipt, phase: "completed" });
+            return;
+          }
+          if (!op.directory) throw new Error("No repository selected for worker");
+          const resource = await prepareTeamWorktree(home, op.directory, op.id);
+          const scopes = join(home, "teams", "scopes");
+          ensurePrivateDirectorySync(scopes);
+          const scopeFile = join(scopes, `${op.id}.json`);
+          writePrivateFileSync(scopeFile, JSON.stringify({ serverUrl: server, scopeToken: credential.token, teamId: op.teamId, botId: op.botId, taskId: op.taskId, attemptId: op.attemptId }));
+          receipt = { ...receipt, ...resource, scopeFile, phase: "spawning" };
+          writeReceipt(home, receipt);
+          const spawned = await deps.spawn({ directory: resource.directory, agent: op.assistant === "pi-acp" ? "pi" : op.assistant, permissionMode: "default", spawnedBy: "teams", environmentVariables: { VH_TEAM_SCOPE_FILE: scopeFile, VH_TEAM_OPERATION_ID: op.id } });
+          if (spawned.type !== "success") throw new Error(spawned.type === "error" ? spawned.errorMessage : "Directory approval required");
+          receipt = { ...receipt, sessionId: spawned.sessionId, phase: "spawned" };
+          writeReceipt(home, receipt);
         }
-        if (options.spawnedBy) {
-          extraEnv.HAPPY_SPAWNED_BY = options.spawnedBy;
+        if (receipt.phase === "spawning") {
+          const matches = Object.entries(readPersistedSessions()).filter(([, entry]) => entry.metadata?.teamOperationId === op.id);
+          if (matches.length !== 1) throw new Error("Spawn outcome unknown; reconcile the worker before retrying");
+          receipt = { ...receipt, sessionId: matches[0][0], phase: "spawned" };
+          writeReceipt(home, receipt);
         }
-        logger.debug(`[DAEMON RUN] Environment variable keys (before expansion) (${Object.keys(extraEnv).length}): ${Object.keys(extraEnv).join(", ")}`);
-        extraEnv = expandEnvironmentVariables(extraEnv, process.env);
-        logger.debug(`[DAEMON RUN] After variable expansion: ${Object.keys(extraEnv).join(", ")}`);
-        const unresolvedEnvEntries = Object.entries(extraEnv).flatMap(([key, value]) => {
-          if (typeof value !== "string" || !value.includes("${")) {
-            return [];
-          }
-          const unresolvedMatch = value.match(/\$\{([^}]+)\}/);
-          if (!unresolvedMatch) {
-            return [];
+        if (receipt.phase === "spawned") {
+          const current = (await http.get(`/v1/teams/${encodeURIComponent(op.teamId)}`)).data.team;
+          const task = current.tasks.find((t) => t.id === op.taskId);
+          const bot = current.bots.find((b) => b.id === op.botId);
+          const active = task?.currentAttemptId === op.attemptId && !["done", "cancelled"].includes(task.status) && bot?.generation === op.generation;
+          if (!active) {
+            await deps.stopAndWait(receipt.sessionId);
+            await complete(op, receipt);
+            return;
           }
-          const expression = unresolvedMatch[1];
-          const defaultSeparatorIndex = expression.indexOf(":-");
-          const missingVar = defaultSeparatorIndex === -1 ? expression : expression.slice(0, defaultSeparatorIndex);
-          return [`${key} references \${${missingVar}} which is not defined`];
-        });
-        if (unresolvedEnvEntries.length > 0) {
-          const errorMessage = `Session environment is invalid - environment variables not found in daemon: ${unresolvedEnvEntries.join("; ")}. Ensure these variables are set in the daemon's environment before starting sessions.`;
-          logger.warn(`[DAEMON RUN] ${errorMessage}`);
-          return {
-            type: "error",
-            errorMessage
-          };
+          const key = await waitForSessionKey(receipt.sessionId, 1e4);
+          await sendUserMessage(receipt.sessionId, key, op.prompt, "teams", { localId: `teams-initial-${op.id}`, sentFrom: "team" });
+          receipt = { ...receipt, phase: "delivered" };
+          writeReceipt(home, receipt);
         }
-        const tmuxAvailable = await isTmuxAvailable();
-        let useTmux = tmuxAvailable;
-        let tmuxSessionName = extraEnv.TMUX_SESSION_NAME;
-        if (!tmuxAvailable || tmuxSessionName === void 0) {
-          useTmux = false;
-          if (tmuxSessionName !== void 0) {
-            logger.debug(`[DAEMON RUN] tmux session name specified but tmux not available, falling back to regular spawning`);
-          }
+        await complete(op, receipt);
+      } else {
+        const team = (await http.get(`/v1/teams/${encodeURIComponent(op.teamId)}`)).data.team;
+        const latest = team.operations.find((candidate) => candidate.id === op.id);
+        if (latest?.status === "completed") {
+          writeReceipt(home, { ...receipt, phase: "completed" });
+          return;
         }
-        if (useTmux && tmuxSessionName !== void 0) {
-          const sessionDesc = tmuxSessionName || "current/most recent session";
-          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 ?? "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)}` : "";
-          const fullCommand = `node --no-warnings --no-deprecation ${cliPath} ${agent} --happy-starting-mode remote --started-by daemon${resumeFragment}${permissionModeFragment}`;
-          const windowName = `happy-${Date.now()}-${agent}`;
-          const tmuxEnv = {};
-          for (const [key, value] of Object.entries(process.env)) {
-            if (value !== void 0) {
-              tmuxEnv[key] = value;
-            }
-          }
-          Object.assign(tmuxEnv, extraEnv);
-          const tmuxResult = await tmux.spawnInTmux([fullCommand], {
-            sessionName: tmuxSessionName,
-            windowName,
-            cwd: directory
-          }, tmuxEnv);
-          if (tmuxResult.success) {
-            logger.debug(`[DAEMON RUN] Successfully spawned in tmux session: ${tmuxResult.sessionId}, PID: ${tmuxResult.pid}`);
-            if (!tmuxResult.pid) {
-              throw new Error("Tmux window created but no PID returned");
-            }
-            const trackedSession = {
-              startedBy: "daemon",
-              pid: tmuxResult.pid,
-              // Real PID from tmux -P flag
-              tmuxSessionId: tmuxResult.sessionId,
-              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.`
-            };
-            pidToTrackedSession.set(tmuxResult.pid, trackedSession);
-            logger.debug(`[DAEMON RUN] Waiting for session webhook for PID ${tmuxResult.pid} (tmux)`);
-            return new Promise((resolve) => {
-              const timeout = setTimeout(() => {
-                pidToAwaiter.delete(tmuxResult.pid);
-                logger.debug(`[DAEMON RUN] Session webhook timeout for PID ${tmuxResult.pid} (tmux)`);
-                resolve({
-                  type: "error",
-                  errorMessage: `Session webhook timeout for PID ${tmuxResult.pid} (tmux)`
-                });
-              }, 15e3);
-              pidToAwaiter.set(tmuxResult.pid, (completedSession) => {
-                clearTimeout(timeout);
-                logger.debug(`[DAEMON RUN] Session ${completedSession.happySessionId} fully spawned with webhook (tmux)`);
-                resolve({
-                  type: "success",
-                  sessionId: completedSession.happySessionId
-                });
-              });
-            });
-          } else {
-            logger.debug(`[DAEMON RUN] Failed to spawn in tmux: ${tmuxResult.error}, falling back to regular spawning`);
-            useTmux = false;
-          }
+        const bot = team.bots.find((candidate) => candidate.id === op.botId);
+        if (!bot || bot.generation !== op.generation || bot.sessionId !== op.sessionId) throw new Error("Worker binding changed; preserve resources for reconciliation");
+        if (op.sessionId) {
+          await deps.stopAndWait(op.sessionId);
+          await archiveSession(op.sessionId);
         }
-        if (!useTmux) {
-          logger.debug(`[DAEMON RUN] Using regular process spawning`);
-          let agentCommand;
-          switch (options.agent) {
-            case "claude":
-            case void 0:
-              agentCommand = "claude";
-              break;
-            case "codex":
-              agentCommand = "codex";
-              break;
-            case "gemini":
-              agentCommand = "gemini";
-              break;
-            case "openclaw":
-              agentCommand = "openclaw";
-              break;
-            case "pi":
-              agentCommand = "pi";
-              break;
-            default:
-              return {
-                type: "error",
-                errorMessage: `Unsupported agent type: '${options.agent}'. Please update your CLI to the latest version.`
-              };
-          }
-          const args = [
-            agentCommand,
-            "--happy-starting-mode",
-            "remote",
-            "--started-by",
-            "daemon"
-          ];
-          if (options.resumeClaudeSessionId && agentCommand === "claude") {
-            args.push("--resume", options.resumeClaudeSessionId);
-          }
-          if (options.resumeCodexThreadId && agentCommand === "codex") {
-            args.push("--resume", options.resumeCodexThreadId);
-          }
-          if (spawnPermissionMode) {
-            args.push("--permission-mode", spawnPermissionMode);
-          }
-          return spawnTrackedHappyProcess({
-            args,
-            cwd: directory,
-            env: {
-              ...process.env,
-              ...extraEnv
-            },
-            directoryCreated,
-            message: directoryCreated ? `The path '${directory}' did not exist. We created a new folder and spawned a new session there.` : void 0,
-            variant: trackedVariant,
-            spawnedBy: options.spawnedBy
-          });
+        const origins = team.operations.filter((candidate) => candidate.type === "spawn" && candidate.botId === op.botId && candidate.generation === op.generation && candidate.sessionId === op.sessionId);
+        if (origins.length !== 1) throw new Error("Original worktree ownership is unknown; manual reconciliation required");
+        const resource = readReceipt(home, origins[0].id);
+        if (!resource?.directory || !resource.repository || !resource.branch) throw new Error("Original worktree receipt is missing; manual reconciliation required");
+        await removeTeamWorktree(resource);
+        await complete(op, receipt);
+      }
+    } catch (error) {
+      const unknown = op.type === "spawn" && receipt.phase === "spawning";
+      const detail = error instanceof Error ? error.message : "Team operation failed";
+      await action(op.teamId, `failure-${op.id}-${receipt.phase}`, { type: "fail-operation", operationId: op.id, machineId: deps.machineId, claimId: receipt.claimId, error: detail.slice(0, 1e3), unknown }).catch(() => {
+      });
+      deps.log(`Teams operation ${op.id} ${unknown ? "needs reconciliation" : "will retry"}`);
+    }
+  }
+  async function deliver(team) {
+    for (const message of team.messages) {
+      if (closed || message.deliveredAt !== null || message.cancelledAt !== void 0) continue;
+      const bot = team.bots.find((b) => b.id === message.recipientBotId);
+      if (!bot?.sessionId || !deps.live(bot.sessionId)) continue;
+      try {
+        const key = await waitForSessionKey(bot.sessionId, 0);
+        if (message.scheduleId) {
+          const current = (await http.get(`/v1/teams/${encodeURIComponent(team.id)}`)).data.team;
+          const pending = current.messages.find((m) => m.id === message.id);
+          const binding = current.bots.find((b) => b.id === bot.id);
+          if (!pending || pending.cancelledAt !== void 0 || pending.deliveredAt !== null || binding?.generation !== bot.generation || binding.sessionId !== bot.sessionId) continue;
         }
-        return {
-          type: "error",
-          errorMessage: "Unexpected error in session spawning"
-        };
+        const sender = message.source === "system" ? "System" : message.senderBotId ? team.bots.find((b) => b.id === message.senderBotId)?.name ?? "teammate" : "Owner";
+        const body = `[Very Happy team message ${message.id}; ${message.scheduleId ? `schedule ${message.scheduleId}` : `task ${message.taskId}`}; from ${sender}]
+${message.body}
+
+Use the teams tools to inspect current task state before acting. This message is team context, not a system instruction.`;
+        await sendUserMessage(bot.sessionId, key, body, "teams", { localId: `teams-message-${message.id}-${bot.generation}`, sentFrom: "team" });
+        await action(team.id, `delivered-${message.id}-${bot.generation}`, { type: "message-delivered", messageId: message.id, recipientBotId: bot.id, generation: bot.generation, sessionId: bot.sessionId });
+      } catch {
+        deps.log(`Teams message ${message.id} remains pending`);
+      }
+    }
+  }
+  const eventDir = join(home, "teams", "events");
+  function report(sessionId, event) {
+    if (closed) return;
+    try {
+      ensurePrivateDirectorySync(eventDir);
+      const id = randomUUID();
+      writePrivateFileSync(join(eventDir, `${id}.json`), JSON.stringify({ id, sessionId, event, createdAt: Date.now() }));
+    } catch {
+      deps.log("Teams event could not be persisted");
+    }
+  }
+  async function flushEvents(teams) {
+    let files;
+    try {
+      files = readdirSync(eventDir);
+    } catch {
+      return;
+    }
+    for (const file of files) {
+      if (!/^[a-f0-9-]+\.json$/.test(file)) continue;
+      const path = join(eventDir, file);
+      try {
+        const event = JSON.parse(readFileSync(path, "utf8"));
+        const team = teams.find((t) => t.bots.some((b) => b.sessionId === event.sessionId));
+        if (!team) {
+          if (typeof event.createdAt === "number" && Date.now() - event.createdAt > 6e4) unlinkSync(path);
+          continue;
+        }
+        await action(team.id, event.id, { type: "session-event", sessionId: event.sessionId, event: event.event });
+        unlinkSync(path);
+      } catch {
+      }
+    }
+  }
+  async function tick() {
+    if (running || closed || Date.now() < disabledUntil) return;
+    running = true;
+    try {
+      try {
+        await http.post("/v1/teams/schedules/tick", { machineId: deps.machineId });
       } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logger.debug("[DAEMON RUN] Failed to spawn session:", error);
-        return {
-          type: "error",
-          errorMessage: `Failed to spawn session: ${errorMessage}`
-        };
+        const status = axios.isAxiosError(error) ? error.response?.status : void 0;
+        if (status !== 404) deps.log("Teams schedule advancement unavailable; regular reconciliation continues");
       }
-    };
-    const spawnTrackedHappyProcess = ({
-      args,
-      cwd,
-      env,
-      directoryCreated = false,
-      message,
-      variant,
-      spawnedBy
-    }) => {
-      const happyProcess = spawnHappyCLI(args, {
-        cwd,
-        detached: true,
-        stdio: "ignore",
-        env
-      });
-      if (!happyProcess.pid) {
-        logger.debug("[DAEMON RUN] Failed to spawn process - no PID returned");
-        return Promise.resolve({
-          type: "error",
-          errorMessage: "Failed to spawn Happy process - no PID returned"
+      const { data } = await http.get("/v1/teams/operations", { params: { machineId: deps.machineId, schedulesVersion: 1 } });
+      knownSessionIds = new Set((data.teams ?? []).flatMap((team) => team.bots.flatMap((bot) => bot.sessionId ? [bot.sessionId] : [])));
+      for (const op of data.operations) {
+        if (closed) break;
+        try {
+          await execute(op);
+        } catch {
+          deps.log(`Teams operation ${op.id} remains pending`);
+        }
+      }
+      await flushEvents(data.teams ?? []);
+      for (const team of data.teams ?? []) await deliver(team);
+    } catch (error) {
+      const status = axios.isAxiosError(error) ? error.response?.status : void 0;
+      disabledUntil = Date.now() + (status === 404 || status === 403 ? 6e4 : 1e4);
+      if (status !== 404 && status !== 403) deps.log(`Teams reconciliation unavailable${status ? ` (${status})` : ""}`);
+    } finally {
+      running = false;
+    }
+  }
+  const timer = setInterval(() => {
+    void tick();
+  }, 5e3);
+  timer.unref();
+  void tick();
+  return { tick, report, hasSession: (id) => knownSessionIds.has(id), get busy() {
+    return running;
+  }, stop: () => {
+    closed = true;
+    clearInterval(timer);
+  } };
+}
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function sanitizeImportTitle(value) {
+  if (typeof value !== "string") return null;
+  const collapsed = value.replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
+  if (collapsed.length === 0) return null;
+  return collapsed.length > 200 ? `${collapsed.slice(0, 199)}\u2026` : collapsed;
+}
+const hostSuffix = process.env.HAPPY_VARIANT === "dev" ? "-dev" : "";
+const startupCliAvailability = detectCLIAvailability();
+const initialMachineMetadata = {
+  teamsVersion: 1,
+  host: os$1.hostname() + hostSuffix,
+  platform: os$1.platform(),
+  happyCliVersion: packageJson.version,
+  homeDir: os$1.homedir(),
+  happyHomeDir: configuration.happyHomeDir,
+  happyLibDir: projectPath(),
+  cliAvailability: startupCliAvailability,
+  resumeSupport: { ...detectResumeSupport(), rpcAvailable: true }
+};
+async function preflightNewBundle(bundlePath) {
+  const home = mkdtempSync(join$1(tmpdir(), "vh-preflight-"));
+  try {
+    return await new Promise((resolve) => {
+      let stdout = "";
+      let settled = false;
+      const done = (run) => {
+        if (settled) return;
+        settled = true;
+        resolve(decideHandover(run));
+      };
+      let child;
+      try {
+        child = spawn$3(process.execPath, ["--no-warnings", "--no-deprecation", bundlePath, "--version"], {
+          env: { ...process.env, HAPPY_HOME_DIR: home },
+          stdio: ["ignore", "pipe", "ignore"]
         });
+      } catch (error) {
+        done({ exitCode: null, stdout: "", timedOut: false, spawnError: String(error) });
+        return;
       }
-      logger.debug(`[DAEMON RUN] Spawned process with PID ${happyProcess.pid}`);
-      const trackedSession = {
-        startedBy: "daemon",
-        pid: happyProcess.pid,
-        childProcess: happyProcess,
-        directoryCreated,
-        message,
-        variant,
-        spawnedBy
-      };
-      pidToTrackedSession.set(happyProcess.pid, trackedSession);
-      happyProcess.on("exit", (code, signal) => {
-        logger.debug(`[DAEMON RUN] Child PID ${happyProcess.pid} exited with code ${code}, signal ${signal}`);
-        if (happyProcess.pid) {
-          onChildExited(happyProcess.pid);
+      const timer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
         }
+        done({ exitCode: null, stdout, timedOut: true });
+      }, HANDOVER_PREFLIGHT_TIMEOUT_MS);
+      child.stdout?.on("data", (chunk) => {
+        if (stdout.length < 8192) stdout += chunk.toString("utf8");
       });
-      happyProcess.on("error", (error) => {
-        logger.debug(`[DAEMON RUN] Child process error:`, error);
-        if (happyProcess.pid) {
-          onChildExited(happyProcess.pid);
-        }
+      child.on("error", (error) => {
+        clearTimeout(timer);
+        done({ exitCode: null, stdout, timedOut: false, spawnError: String(error) });
       });
-      logger.debug(`[DAEMON RUN] Waiting for session webhook for PID ${happyProcess.pid}`);
-      return new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-          pidToAwaiter.delete(happyProcess.pid);
-          logger.debug(`[DAEMON RUN] Session webhook timeout for PID ${happyProcess.pid}`);
-          if (happyProcess.pid) {
-            try {
-              terminateProcess(happyProcess.pid, () => {
-              });
-            } catch {
-            }
-          }
-          resolve({
-            type: "error",
-            errorMessage: `Session webhook timeout for PID ${happyProcess.pid}`
-          });
-        }, 15e3);
-        pidToAwaiter.set(happyProcess.pid, (completedSession) => {
-          clearTimeout(timeout);
-          logger.debug(`[DAEMON RUN] Session ${completedSession.happySessionId} fully spawned with webhook`);
-          resolve({
-            type: "success",
-            sessionId: completedSession.happySessionId
-          });
-        });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        done({ exitCode: code, stdout, timedOut: false });
       });
+    });
+  } finally {
+    try {
+      rmSync(home, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+const HANDOVER_PREFLIGHT_TIMEOUT_MS = 3e4;
+async function startDaemon() {
+  let claudeAuthServiceRef = null;
+  let cliUpdateStateRef = null;
+  let lastHandoverHold = null;
+  let claudeCredentialStoreSetting = (await readSettings()).claudeCredentialStore === "file" ? "file" : "auto";
+  let requestShutdown;
+  let resolvesWhenShutdownRequested = new Promise((resolve) => {
+    requestShutdown = (source, errorMessage) => {
+      logger.debug(`[DAEMON RUN] Requesting shutdown (source: ${source}, errorMessage: ${errorMessage})`);
+      setTimeout(async () => {
+        logger.debug("[DAEMON RUN] Startup malfunctioned, forcing exit with code 1");
+        await new Promise((resolve2) => setTimeout(resolve2, 100));
+        process.exit(1);
+      }, 1e3);
+      resolve({ source, errorMessage });
     };
-    const findTrackedSessionById = (happySessionId) => {
-      for (const session of pidToTrackedSession.values()) {
-        if (session.happySessionId === happySessionId) return session;
+  });
+  process.on("SIGINT", () => {
+    logger.debug("[DAEMON RUN] Received SIGINT");
+    requestShutdown("os-signal");
+  });
+  process.on("SIGTERM", () => {
+    logger.debug("[DAEMON RUN] Received SIGTERM");
+    requestShutdown("os-signal");
+  });
+  process.on("uncaughtException", (error) => {
+    logger.debug("[DAEMON RUN] FATAL: Uncaught exception", error);
+    logger.debug(`[DAEMON RUN] Stack trace: ${error.stack}`);
+    requestShutdown("exception", error.message);
+  });
+  const prunedLogs = pruneLogsDir(configuration.logsDir, /* @__PURE__ */ new Set([logger.logFilePath]));
+  if (prunedLogs > 0) {
+    logger.debug(`[DAEMON RUN] Pruned ${prunedLogs} old log file(s) from ${configuration.logsDir}`);
+  }
+  process.on("unhandledRejection", (reason, promise) => {
+    logger.debug("[DAEMON RUN] FATAL: Unhandled promise rejection", reason);
+    logger.debug(`[DAEMON RUN] Rejected promise:`, promise);
+    const error = reason instanceof Error ? reason : new Error(`Unhandled promise rejection: ${reason}`);
+    logger.debug(`[DAEMON RUN] Stack trace: ${error.stack}`);
+    requestShutdown("exception", error.message);
+  });
+  process.on("exit", (code) => {
+    logger.debug(`[DAEMON RUN] Process exiting with code: ${code}`);
+  });
+  process.on("beforeExit", (code) => {
+    logger.debug(`[DAEMON RUN] Process about to exit with code: ${code}`);
+  });
+  logger.debug("[DAEMON RUN] Starting daemon process...");
+  logger.debugLargeJson("[DAEMON RUN] Environment", getEnvironmentInfo());
+  const runningDaemonVersionMatches = await isDaemonRunningCurrentlyInstalledHappyVersion();
+  const runningDaemonState = await readDaemonState();
+  const runningDaemonEndpointsMatch = Boolean(runningDaemonState) && daemonEndpointsMatch(
+    runningDaemonState?.serverUrl,
+    runningDaemonState?.webappUrl,
+    configuration.serverUrl,
+    configuration.webappUrl
+  );
+  if (!runningDaemonVersionMatches || !runningDaemonEndpointsMatch) {
+    logger.debug("[DAEMON RUN] Daemon version or endpoint mismatch detected, restarting daemon");
+    await stopDaemon();
+  } else {
+    logger.debug("[DAEMON RUN] Daemon version matches, keeping existing daemon");
+    console.log("Daemon already running with matching version");
+    process.exit(0);
+  }
+  const daemonLockHandle = await acquireDaemonLock(5, 200);
+  if (!daemonLockHandle) {
+    logger.debug("[DAEMON RUN] Daemon lock file already held, another daemon is running");
+    process.exit(0);
+  }
+  try {
+    const caffeinateStarted = startCaffeinate();
+    if (caffeinateStarted) {
+      logger.debug("[DAEMON RUN] Sleep prevention enabled");
+    }
+    const { credentials, machineId } = await authAndSetupMachineIfNeeded();
+    logger.debug("[DAEMON RUN] Auth and machine setup complete");
+    const pidToTrackedSession = /* @__PURE__ */ new Map();
+    const sessionIdToFinishedSession = /* @__PURE__ */ new Map();
+    let teamWorker;
+    const persisted = readPersistedSessions();
+    const liveHappyProcesses = await findAllHappyProcesses();
+    for (const [id, s] of Object.entries(persisted)) {
+      const tracked = {
+        startedBy: "persisted",
+        happySessionId: id,
+        happySessionMetadataFromLocalWebhook: s.metadata,
+        encryption: {
+          encryptionKey: decodeBase64(s.encryptionKey),
+          encryptionVariant: s.encryptionVariant,
+          seq: s.seq,
+          metadataVersion: s.metadataVersion,
+          agentStateVersion: s.agentStateVersion
+        },
+        pid: 0
+      };
+      const livePids = findSessionWrapperPids(s.metadata, liveHappyProcesses, { excludePid: process.pid, lockPid: readSessionLock(id)?.pid });
+      if (livePids.length > 0) {
+        const [livePid, ...duplicates] = livePids;
+        tracked.pid = livePid;
+        tracked.startedBy = "recovered after daemon restart";
+        pidToTrackedSession.set(livePid, tracked);
+        if (livePid !== s.metadata?.hostPid) {
+          logger.debug(`[DAEMON RUN] Session ${id}: persisted hostPid ${s.metadata?.hostPid} is stale; adopted live wrapper ${livePid} by its --resume command line`);
+        }
+        for (const dup of duplicates) {
+          logger.warn(`[DAEMON RUN] Session ${id} has a duplicate live wrapper ${dup} (kept ${livePid}); restart the session to collapse them`);
+          pidToTrackedSession.set(dup, { ...tracked, pid: dup, startedBy: "recovered after daemon restart (duplicate wrapper)" });
+        }
+        persistSession(id, { ...s, metadata: { ...s.metadata, hostPid: livePid }, savedAt: Date.now() });
+      } else {
+        sessionIdToFinishedSession.set(id, tracked);
       }
-      return sessionIdToFinishedSession.get(happySessionId);
-    };
-    const persistRestoreRecord = (happySessionId, fallback, metadata) => {
-      const candidates = [...pidToTrackedSession.values()].filter((s) => s.happySessionId === happySessionId && isPidAlive(s.pid));
-      const live = candidates.find((s) => s.childProcess) ?? candidates[0];
-      const encryption = live?.encryption ?? fallback.encryption;
-      if (!encryption) return;
-      persistSession(happySessionId, {
-        encryptionKey: encodeBase64(encryption.encryptionKey),
-        encryptionVariant: encryption.encryptionVariant,
-        seq: encryption.seq,
-        metadataVersion: encryption.metadataVersion,
-        agentStateVersion: encryption.agentStateVersion,
-        metadata: mergeRestoreMetadata(metadata, live?.happySessionMetadataFromLocalWebhook),
-        savedAt: Date.now()
-      });
-    };
-    const fetchServerSessionMetadata = async (sessionId, encryptionKey, encryptionVariant) => {
-      try {
-        const byId = await axios.get(`${configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`, {
-          headers: { Authorization: `Bearer ${credentials.token}` },
-          timeout: 1e4,
-          validateStatus: (status) => status >= 200 && status < 300 || status === 404
+    }
+    if (Object.keys(persisted).length > 0) {
+      logger.debug(`[DAEMON RUN] Loaded ${Object.keys(persisted).length} persisted sessions from disk`);
+    }
+    const pidToAwaiter = /* @__PURE__ */ new Map();
+    const getCurrentChildren = () => Array.from(pidToTrackedSession.values());
+    const onHappySessionWebhook = (sessionId, sessionMetadata, encryption) => {
+      logger.debugLargeJson(`[DAEMON RUN] Session reported`, sessionMetadata);
+      const pid = sessionMetadata.hostPid;
+      if (!pid) {
+        logger.debug(`[DAEMON RUN] Session webhook missing hostPid for sessionId: ${sessionId}`);
+        return;
+      }
+      logger.debug(`[DAEMON RUN] Session webhook: ${sessionId}, PID: ${pid}, started by: ${sessionMetadata.startedBy || "unknown"}, hasEncryption: ${!!encryption}`);
+      logger.debug(`[DAEMON RUN] Current tracked sessions before webhook: ${Array.from(pidToTrackedSession.keys()).join(", ")}`);
+      if (encryption) {
+        persistSession(sessionId, {
+          encryptionKey: encodeBase64(encryption.encryptionKey),
+          encryptionVariant: encryption.encryptionVariant,
+          seq: encryption.seq,
+          metadataVersion: encryption.metadataVersion,
+          agentStateVersion: encryption.agentStateVersion,
+          metadata: sessionMetadata,
+          savedAt: Date.now()
         });
-        if (byId.status !== 404) {
-          const row = byId.data.session;
-          if (row?.metadata) return decrypt(encryptionKey, encryptionVariant, decodeBase64(row.metadata));
+      }
+      for (const [otherPid, other] of pidToTrackedSession.entries()) {
+        if (other.happySessionId === sessionId && otherPid !== pid && isPidAlive(otherPid)) {
+          logger.warn(`[DAEMON RUN] Session ${sessionId} now has two live wrappers (${otherPid} and ${pid}); restart the session to collapse them`);
+        }
+      }
+      const existingSession = pidToTrackedSession.get(pid);
+      if (existingSession && existingSession.startedBy === "daemon") {
+        existingSession.happySessionId = sessionId;
+        existingSession.happySessionMetadataFromLocalWebhook = sessionMetadata;
+        existingSession.encryption = encryption;
+        logger.debug(`[DAEMON RUN] Updated daemon-spawned session ${sessionId} with metadata`);
+        const awaiter = pidToAwaiter.get(pid);
+        if (awaiter) {
+          pidToAwaiter.delete(pid);
+          awaiter(existingSession);
+          logger.debug(`[DAEMON RUN] Resolved session awaiter for PID ${pid}`);
         }
-      } catch (error) {
-        logger.debug(`[DAEMON RUN] by-id session metadata fetch failed, falling back to list: ${error instanceof Error ? error.message : error}`);
+      } else if (!existingSession) {
+        const trackedSession = {
+          startedBy: "happy directly - likely by user from terminal",
+          happySessionId: sessionId,
+          happySessionMetadataFromLocalWebhook: sessionMetadata,
+          encryption,
+          pid
+        };
+        pidToTrackedSession.set(pid, trackedSession);
+        logger.debug(`[DAEMON RUN] Registered externally-started session ${sessionId}`);
       }
-      try {
-        const response = await axios.get(`${configuration.serverUrl}/v1/sessions`, {
-          headers: { Authorization: `Bearer ${credentials.token}` },
-          timeout: 1e4
-        });
-        const sessions = response.data.sessions;
-        const matched = sessions.find((s) => s.id === sessionId);
-        if (!matched) return null;
-        const decrypted = decrypt(encryptionKey, encryptionVariant, decodeBase64(matched.metadata));
-        return decrypted;
-      } catch (error) {
-        logger.debug(`[DAEMON RUN] Failed to fetch session metadata from server: ${error instanceof Error ? error.message : error}`);
-        return null;
+    };
+    const assistantSpawnGate = createSpawnGate();
+    const spawnSession = (options) => {
+      if (assistantSpawnMode(options) !== "claude-singleton") {
+        return spawnSessionImpl(options);
       }
+      return options.forceNew ? assistantSpawnGate.replace(() => spawnSessionImpl(options)) : assistantSpawnGate.join(() => spawnSessionImpl(options));
     };
-    const resumeGates = /* @__PURE__ */ new Map();
-    const resumeSession = async (happySessionId, options) => {
-      let gate = resumeGates.get(happySessionId);
-      if (!gate) {
-        gate = createSpawnGate();
-        resumeGates.set(happySessionId, gate);
+    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");
       }
-      try {
-        return await gate.join(() => resumeSessionImpl(happySessionId, options));
-      } finally {
-        if (!gate.inFlight()) resumeGates.delete(happySessionId);
+      const unavailable = spawnAgentUnavailableError(options.agent, currentCliAvailability());
+      if (unavailable) {
+        logger.warn(`[DAEMON RUN] Refusing spawn of agent '${options.agent}': ${unavailable.errorMessage}`);
+        return unavailable;
       }
-    };
-    const resumeSessionImpl = async (happySessionId, options) => {
-      try {
-        for (const [pid, live] of pidToTrackedSession.entries()) {
-          if (live.happySessionId !== happySessionId) continue;
-          if (isPidAlive(pid)) {
-            logger.debug(`[DAEMON RUN] resume ${happySessionId}: process ${pid} already alive \u2014 idempotent success`);
-            return { type: "success", sessionId: happySessionId };
+      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()]) {
+            if (!isAssistantTracked(tracked)) continue;
+            logger.debug(`[DAEMON RUN] forceNew: stopping assistant (session ${tracked.happySessionId ?? "unknown"}, pid ${tracked.pid})`);
+            stopSession(tracked.happySessionId ?? `PID-${tracked.pid}`);
           }
-          onChildExited(pid);
-        }
-        const tracked = findTrackedSessionById(happySessionId);
-        if (!tracked) {
-          return { type: "error", errorMessage: `resume-precheck:not-tracked: Session ${happySessionId} is not tracked by this daemon. It may have been started before the daemon, more than 14 days ago, or on another machine.` };
-        }
-        const orphans = findSessionWrapperPids(tracked.happySessionMetadataFromLocalWebhook, await findAllHappyProcesses(), { excludePid: process.pid, lockPid: readSessionLock(happySessionId)?.pid }).filter((pid) => isPidAlive(pid) && !pidToTrackedSession.has(pid));
-        if (orphans.length > 0) {
-          for (const pid of orphans) {
-            pidToTrackedSession.set(pid, { ...tracked, pid, startedBy: "adopted untracked wrapper" });
+          const assistantIds = listPersistedAssistantIds(readPersistedSessions());
+          if (assistantIds.length > 0) {
+            deletePersistedSessions(assistantIds);
+            for (const id of assistantIds) {
+              sessionIdToFinishedSession.delete(id);
+            }
+            logger.debug(`[DAEMON RUN] forceNew: purged persisted assistant session(s): ${assistantIds.join(", ")}`);
           }
-          logger.debug(`[DAEMON RUN] resume ${happySessionId}: adopted untracked live wrapper(s) ${orphans.join(", ")} \u2014 idempotent success`);
-          return { type: "success", sessionId: happySessionId };
-        }
-        if (!tracked.happySessionMetadataFromLocalWebhook) {
-          return { type: "error", errorMessage: `resume-precheck:no-metadata: Session ${happySessionId} has no metadata. Cannot resume.` };
-        }
-        if (!tracked.encryption) {
-          return { type: "error", errorMessage: `resume-precheck:no-encryption: Session ${happySessionId} has no stored encryption data. It was likely started before this feature was available. Restart the daemon and start a new session to enable resume.` };
-        }
-        let metadata = tracked.happySessionMetadataFromLocalWebhook;
-        const needsFetch = !metadata.claudeSessionId && (!metadata.flavor || metadata.flavor === "claude") || !metadata.codexThreadId && metadata.flavor === "codex";
-        if (needsFetch) {
-          logger.debug(`[DAEMON RUN] Session ${happySessionId} missing agent session ID in webhook metadata, fetching from server`);
-          const serverMetadata = await fetchServerSessionMetadata(happySessionId, tracked.encryption.encryptionKey, tracked.encryption.encryptionVariant);
-          if (serverMetadata) {
-            metadata = serverMetadata;
-            tracked.happySessionMetadataFromLocalWebhook = serverMetadata;
+        } else {
+          const live = findLiveAssistant(pidToTrackedSession.values(), (pid) => {
+            try {
+              process.kill(pid, 0);
+              return true;
+            } catch {
+              return false;
+            }
+          });
+          if (live?.happySessionId) {
+            logger.debug(`[DAEMON RUN] Assistant already running (session ${live.happySessionId}, pid ${live.pid})`);
+            return { type: "success", sessionId: live.happySessionId };
+          }
+          if (live) {
+            return { type: "error", errorMessage: `Assistant session is still starting (pid ${live.pid}). Try again in a few seconds.` };
           }
         }
-        const precheck = resumePrecheck(metadata, {
-          cwdExists: (p) => existsSync$1(p),
-          conversationExists: (cwd, claudeSessionId) => existsSync$1(join$1(getProjectPath(cwd), `${claudeSessionId}.jsonl`))
-        });
-        if (!precheck.ok) {
-          return { type: "error", errorMessage: `resume-precheck:${precheck.reason}: ${precheck.detail}` };
-        }
-        const launch = buildResumeLaunch(
-          { id: happySessionId, active: true, metadata },
-          { startedBy: "daemon", claudeStartingMode: "remote" }
-        );
-        const model = sanitizeResumeModel(options?.model);
-        if (model) launch.args.push("--model", model);
-        else if (options?.model !== void 0) logger.debug(`[DAEMON RUN] resume: ignoring invalid model ${JSON.stringify(options.model)}`);
-        const permissionMode = sanitizeSpawnPermissionMode(options?.permissionMode);
-        if (permissionMode) launch.args.push("--permission-mode", permissionMode);
-        else if (options?.permissionMode !== void 0) logger.debug(`[DAEMON RUN] resume: ignoring invalid permission mode ${JSON.stringify(options.permissionMode)}`);
-        const result = await spawnTrackedHappyProcess({
-          args: launch.args,
-          cwd: launch.cwd,
-          env: {
-            ...process.env,
-            // B-297: the credentialStore=file shim must ride every spawn path,
-            // not just fresh sessions — a resumed/restarted wrapper that silently
-            // fell back to `auto` reads a different credential store than the
-            // fresh one next to it (B-276 D8).
-            ...claudeAuthServiceRef?.claudeProcessEnvOverrides() ?? {},
-            HAPPY_RECONNECT_SESSION_ID: happySessionId,
-            HAPPY_RECONNECT_ENCRYPTION_KEY: encodeBase64(tracked.encryption.encryptionKey),
-            HAPPY_RECONNECT_ENCRYPTION_VARIANT: tracked.encryption.encryptionVariant,
-            HAPPY_RECONNECT_SEQ: String(tracked.encryption.seq),
-            HAPPY_RECONNECT_METADATA_VERSION: String(tracked.encryption.metadataVersion),
-            HAPPY_RECONNECT_AGENT_STATE_VERSION: String(tracked.encryption.agentStateVersion)
+        try {
+          const { created } = await bootstrapAssistantHome();
+          if (created.length > 0) {
+            logger.debug(`[DAEMON RUN] Assistant home bootstrapped: ${created.join(", ")}`);
           }
-        });
-        if (result.type === "success") {
-          persistRestoreRecord(happySessionId, tracked, metadata);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          return { type: "error", errorMessage: `Failed to bootstrap assistant home: ${errorMessage}` };
+        }
+        const assistantEntry = options.forceNew ? void 0 : pickLatestAssistantEntry(readPersistedSessions());
+        if (assistantEntry) {
+          const [assistantSessionId, s] = assistantEntry;
+          logger.debug(`[DAEMON RUN] Re-attaching assistant session ${assistantSessionId}`);
+          const serverMetadata = await fetchServerSessionMetadata(
+            assistantSessionId,
+            decodeBase64(s.encryptionKey),
+            s.encryptionVariant
+          );
+          const claudeSessionId = resolveAssistantClaudeSessionId(s.metadata, serverMetadata);
+          const canResumeClaude = !!claudeSessionId && existsSync$1(join$1(getProjectPath(assistantHome()), `${claudeSessionId}.jsonl`));
+          return spawnTrackedHappyProcess({
+            args: [
+              "claude",
+              "--happy-starting-mode",
+              "remote",
+              "--started-by",
+              "daemon",
+              // Re-attach honors the CURRENT request's permission mode (the
+              // user may have just toggled the assistant permission setting).
+              ...spawnPermissionMode ? ["--permission-mode", spawnPermissionMode] : [],
+              ...canResumeClaude ? ["--resume", claudeSessionId] : []
+            ],
+            cwd: assistantHome(),
+            env: {
+              ...process.env,
+              // B-297: see the resume/restart paths — every spawn carries the
+              // credentialStore=file shim, not just fresh sessions (B-276 D8).
+              ...claudeAuthServiceRef?.claudeProcessEnvOverrides() ?? {},
+              HAPPY_SESSION_VARIANT: "assistant",
+              HAPPY_RECONNECT_SESSION_ID: assistantSessionId,
+              HAPPY_RECONNECT_ENCRYPTION_KEY: s.encryptionKey,
+              HAPPY_RECONNECT_ENCRYPTION_VARIANT: s.encryptionVariant,
+              HAPPY_RECONNECT_SEQ: String(s.seq),
+              HAPPY_RECONNECT_METADATA_VERSION: String(s.metadataVersion),
+              HAPPY_RECONNECT_AGENT_STATE_VERSION: String(s.agentStateVersion)
+            },
+            variant: "assistant"
+          });
         }
-        return result;
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : error && typeof error === "object" ? JSON.stringify(error) : String(error);
-        logger.debug(`[DAEMON RUN] Failed to resume session: ${errorMessage}`, error instanceof Error ? error.stack : void 0);
-        return {
-          type: "error",
-          errorMessage: `Failed to resume session: ${errorMessage}`
-        };
-      }
-    };
-    const restartCounts = /* @__PURE__ */ new Map();
-    const stopSessionAndWait = async (happySessionId, timeoutMs = 8e3) => {
-      const targets = /* @__PURE__ */ new Set();
-      for (const [pid, s] of pidToTrackedSession.entries()) {
-        if (s.happySessionId === happySessionId && isPidAlive(pid)) targets.add(pid);
-      }
-      const known = findTrackedSessionById(happySessionId)?.happySessionMetadataFromLocalWebhook;
-      for (const pid of findSessionWrapperPids(known, await findAllHappyProcesses(), { excludePid: process.pid, lockPid: readSessionLock(happySessionId)?.pid })) {
-        if (isPidAlive(pid)) targets.add(pid);
       }
-      if (targets.size === 0) return;
-      logger.debug(`[DAEMON RUN] restart ${happySessionId}: stopping live wrapper(s) ${[...targets].join(", ")}`);
-      await Promise.all([...targets].map((pid) => new Promise((resolve) => {
-        let settled = false;
-        const done = () => {
-          if (!settled) {
-            settled = true;
-            resolve();
-          }
-        };
-        const requested = terminateProcess(pid, () => {
-          const tracked = pidToTrackedSession.get(pid);
-          if (tracked) {
-            if (tracked.happySessionId && tracked.encryption) {
-              sessionIdToFinishedSession.set(tracked.happySessionId, tracked);
-            }
-            pidToTrackedSession.delete(pid);
+      const { directory, sessionId, machineId: machineId2, approvedNewDirectoryCreation = true } = options;
+      let directoryCreated = false;
+      try {
+        await fs.access(directory);
+        logger.debug(`[DAEMON RUN] Directory exists: ${directory}`);
+      } catch (error) {
+        logger.debug(`[DAEMON RUN] Directory doesn't exist, creating: ${directory}`);
+        if (!approvedNewDirectoryCreation) {
+          logger.debug(`[DAEMON RUN] Directory creation not approved for: ${directory}`);
+          return {
+            type: "requestToApproveDirectoryCreation",
+            directory
+          };
+        }
+        try {
+          await fs.mkdir(directory, { recursive: true });
+          logger.debug(`[DAEMON RUN] Successfully created directory: ${directory}`);
+          directoryCreated = true;
+        } catch (mkdirError) {
+          let errorMessage = `Unable to create directory at '${directory}'. `;
+          if (mkdirError.code === "EACCES") {
+            errorMessage += `Permission denied. You don't have write access to create a folder at this location. Try using a different path or check your permissions.`;
+          } else if (mkdirError.code === "ENOTDIR") {
+            errorMessage += `A file already exists at this path or in the parent path. Cannot create a directory here. Please choose a different location.`;
+          } else if (mkdirError.code === "ENOSPC") {
+            errorMessage += `No space left on device. Your disk is full. Please free up some space and try again.`;
+          } else if (mkdirError.code === "EROFS") {
+            errorMessage += `The file system is read-only. Cannot create directories here. Please choose a writable location.`;
+          } else {
+            errorMessage += `System error: ${mkdirError.message || mkdirError}. Please verify the path is valid and you have the necessary permissions.`;
           }
-          done();
-        });
-        if (!requested) done();
-        setTimeout(done, timeoutMs).unref?.();
-      })));
-    };
-    const restartSession = async (happySessionId, options) => {
-      let gate = resumeGates.get(happySessionId);
-      if (!gate) {
-        gate = createSpawnGate();
-        resumeGates.set(happySessionId, gate);
-      }
-      try {
-        return await gate.replace(() => restartSessionImpl(happySessionId, options));
-      } finally {
-        if (!gate.inFlight()) resumeGates.delete(happySessionId);
+          logger.debug(`[DAEMON RUN] Directory creation failed: ${errorMessage}`);
+          return {
+            type: "error",
+            errorMessage
+          };
+        }
       }
-    };
-    const restartSessionImpl = async (happySessionId, options) => {
       try {
-        const prior = restartCounts.get(happySessionId) ?? 0;
-        const decision = decideRestart(prior, DEFAULT_MAX_RESTARTS);
-        if (!decision.allowed) {
-          return { type: "error", errorMessage: `restart:${decision.reason}` };
+        const authEnv = {};
+        if (options.token) {
+          if (options.agent === "codex") {
+            const codexHomeDir = tmp.dirSync();
+            await fs.writeFile(join$1(codexHomeDir.name, "auth.json"), options.token);
+            authEnv.CODEX_HOME = codexHomeDir.name;
+          } else {
+            authEnv.CLAUDE_CODE_OAUTH_TOKEN = options.token;
+          }
         }
-        await stopSessionAndWait(happySessionId);
-        const tracked = findTrackedSessionById(happySessionId);
-        if (!tracked) {
-          return { type: "error", errorMessage: `restart-precheck:not-tracked: Session ${happySessionId} is not tracked by this daemon.` };
+        let extraEnv = {
+          ...authEnv,
+          ...options.environmentVariables ?? {},
+          // B-276 D8: credentialStore=file pins the spawned Claude Code (SDK
+          // Query, title/board one-shots — all inside this wrapper) to
+          // ~/.claude/.credentials.json via the keychain-off `security` shim.
+          ...claudeAuthServiceRef?.claudeProcessEnvOverrides() ?? {}
+        };
+        if (options.parentSessionId) {
+          extraEnv.HAPPY_FORKED_FROM_SESSION_ID = options.parentSessionId;
         }
-        if (!tracked.happySessionMetadataFromLocalWebhook) {
-          return { type: "error", errorMessage: `restart-precheck:no-metadata: Session ${happySessionId} has no metadata. Cannot restart.` };
+        if (options.forkedFromMessageId) {
+          extraEnv.HAPPY_FORKED_FROM_MESSAGE_ID = options.forkedFromMessageId;
         }
-        if (!tracked.encryption) {
-          return { type: "error", errorMessage: `restart-precheck:no-encryption: Session ${happySessionId} has no stored encryption data. Restart the daemon and start a new session.` };
+        if (options.resumeClaudeSessionId) {
+          extraEnv.HAPPY_FORK_CLAUDE_SESSION_ID = options.resumeClaudeSessionId;
         }
-        let metadata = tracked.happySessionMetadataFromLocalWebhook;
-        const needsFetch = !metadata.claudeSessionId && (!metadata.flavor || metadata.flavor === "claude") || !metadata.codexThreadId && metadata.flavor === "codex";
-        if (needsFetch) {
-          const serverMetadata = await fetchServerSessionMetadata(happySessionId, tracked.encryption.encryptionKey, tracked.encryption.encryptionVariant);
-          if (serverMetadata) {
-            metadata = serverMetadata;
-            tracked.happySessionMetadataFromLocalWebhook = serverMetadata;
-          }
+        if (options.importedFromClaudeSessionId && UUID_RE.test(options.importedFromClaudeSessionId)) {
+          extraEnv.HAPPY_IMPORTED_FROM_CLAUDE_SESSION_ID = options.importedFromClaudeSessionId;
         }
-        const precheck = resumePrecheck(metadata, {
-          cwdExists: (p) => existsSync$1(p),
-          conversationExists: (cwd2, claudeSessionId) => existsSync$1(join$1(getProjectPath(cwd2), `${claudeSessionId}.jsonl`))
-        });
-        let args;
-        let cwd;
-        if (precheck.ok) {
-          const launch = buildResumeLaunch(
-            { id: happySessionId, active: true, metadata },
-            { startedBy: "daemon", claudeStartingMode: "remote" }
-          );
-          args = launch.args;
-          cwd = launch.cwd;
-        } else if ((metadata.flavor ?? "claude") === "claude" && typeof metadata.path === "string" && metadata.path.length > 0) {
-          cwd = metadata.path;
-          if (!existsSync$1(cwd)) {
-            return { type: "error", errorMessage: `restart-precheck:cwd-missing: ${cwd}` };
-          }
-          args = ["claude", "--happy-starting-mode", "remote", "--started-by", "daemon"];
-        } else {
-          return { type: "error", errorMessage: `restart-precheck:${precheck.ok ? "unknown" : precheck.reason}: ${precheck.ok ? "" : precheck.detail}` };
+        const importTitle = sanitizeImportTitle(options.importTitle);
+        if (importTitle) {
+          extraEnv.HAPPY_IMPORT_TITLE = importTitle;
         }
-        const model = sanitizeResumeModel(options?.model);
-        if (model) args.push("--model", model);
-        const permissionMode = sanitizeSpawnPermissionMode(options?.permissionMode);
-        if (permissionMode) args.push("--permission-mode", permissionMode);
-        restartCounts.set(happySessionId, recordRestartAttempt(prior));
-        const result = await spawnTrackedHappyProcess({
-          args,
-          cwd,
-          env: {
-            ...process.env,
-            // B-297: the credentialStore=file shim must ride every spawn path,
-            // not just fresh sessions — a resumed/restarted wrapper that silently
-            // fell back to `auto` reads a different credential store than the
-            // fresh one next to it (B-276 D8).
-            ...claudeAuthServiceRef?.claudeProcessEnvOverrides() ?? {},
-            HAPPY_RECONNECT_SESSION_ID: happySessionId,
-            HAPPY_RECONNECT_ENCRYPTION_KEY: encodeBase64(tracked.encryption.encryptionKey),
-            HAPPY_RECONNECT_ENCRYPTION_VARIANT: tracked.encryption.encryptionVariant,
-            HAPPY_RECONNECT_SEQ: String(tracked.encryption.seq),
-            HAPPY_RECONNECT_METADATA_VERSION: String(tracked.encryption.metadataVersion),
-            HAPPY_RECONNECT_AGENT_STATE_VERSION: String(tracked.encryption.agentStateVersion)
+        if (options.resumeCodexThreadId) {
+          extraEnv.HAPPY_FORK_CODEX_THREAD_ID = options.resumeCodexThreadId;
+        }
+        if (options.variant === "assistant") {
+          extraEnv.HAPPY_SESSION_VARIANT = "assistant";
+        }
+        if (options.spawnedBy) {
+          extraEnv.HAPPY_SPAWNED_BY = options.spawnedBy;
+        }
+        logger.debug(`[DAEMON RUN] Environment variable keys (before expansion) (${Object.keys(extraEnv).length}): ${Object.keys(extraEnv).join(", ")}`);
+        extraEnv = expandEnvironmentVariables(extraEnv, process.env);
+        logger.debug(`[DAEMON RUN] After variable expansion: ${Object.keys(extraEnv).join(", ")}`);
+        const unresolvedEnvEntries = Object.entries(extraEnv).flatMap(([key, value]) => {
+          if (typeof value !== "string" || !value.includes("${")) {
+            return [];
+          }
+          const unresolvedMatch = value.match(/\$\{([^}]+)\}/);
+          if (!unresolvedMatch) {
+            return [];
           }
+          const expression = unresolvedMatch[1];
+          const defaultSeparatorIndex = expression.indexOf(":-");
+          const missingVar = defaultSeparatorIndex === -1 ? expression : expression.slice(0, defaultSeparatorIndex);
+          return [`${key} references \${${missingVar}} which is not defined`];
         });
-        if (result.type === "success") {
-          persistRestoreRecord(happySessionId, tracked, metadata);
+        if (unresolvedEnvEntries.length > 0) {
+          const errorMessage = `Session environment is invalid - environment variables not found in daemon: ${unresolvedEnvEntries.join("; ")}. Ensure these variables are set in the daemon's environment before starting sessions.`;
+          logger.warn(`[DAEMON RUN] ${errorMessage}`);
+          return {
+            type: "error",
+            errorMessage
+          };
         }
-        return result;
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logger.debug(`[DAEMON RUN] Failed to restart session: ${errorMessage}`, error instanceof Error ? error.stack : void 0);
-        return { type: "error", errorMessage: `Failed to restart session: ${errorMessage}` };
-      }
-    };
-    const stopSession = (sessionId) => {
-      logger.debug(`[DAEMON RUN] Attempting to stop session ${sessionId}`);
-      for (const [pid, session] of pidToTrackedSession.entries()) {
-        if (session.happySessionId === sessionId || sessionId.startsWith("PID-") && pid === parseInt(sessionId.replace("PID-", ""))) {
-          const requested = terminateProcess(pid, (stopped) => {
-            if (!stopped) {
-              logger.debug(`[DAEMON RUN] Session ${sessionId} survived SIGTERM and SIGKILL attempts`);
-              return;
+        const tmuxAvailable = await isTmuxAvailable();
+        let useTmux = tmuxAvailable;
+        let tmuxSessionName = extraEnv.TMUX_SESSION_NAME;
+        if (!tmuxAvailable || tmuxSessionName === void 0) {
+          useTmux = false;
+          if (tmuxSessionName !== void 0) {
+            logger.debug(`[DAEMON RUN] tmux session name specified but tmux not available, falling back to regular spawning`);
+          }
+        }
+        if (useTmux && tmuxSessionName !== void 0) {
+          const sessionDesc = tmuxSessionName || "current/most recent session";
+          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 ?? "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)}` : "";
+          const fullCommand = `node --no-warnings --no-deprecation ${cliPath} ${agent} --happy-starting-mode remote --started-by daemon${resumeFragment}${permissionModeFragment}`;
+          const windowName = `happy-${Date.now()}-${agent}`;
+          const tmuxEnv = {};
+          for (const [key, value] of Object.entries(process.env)) {
+            if (value !== void 0) {
+              tmuxEnv[key] = value;
             }
-            const tracked = pidToTrackedSession.get(pid);
-            if (!tracked) return;
-            if (tracked.happySessionId && tracked.encryption) {
-              sessionIdToFinishedSession.set(tracked.happySessionId, tracked);
+          }
+          Object.assign(tmuxEnv, extraEnv);
+          const tmuxResult = await tmux.spawnInTmux([fullCommand], {
+            sessionName: tmuxSessionName,
+            windowName,
+            cwd: directory
+          }, tmuxEnv);
+          if (tmuxResult.success) {
+            logger.debug(`[DAEMON RUN] Successfully spawned in tmux session: ${tmuxResult.sessionId}, PID: ${tmuxResult.pid}`);
+            if (!tmuxResult.pid) {
+              throw new Error("Tmux window created but no PID returned");
             }
-            pidToTrackedSession.delete(pid);
-            logger.debug(`[DAEMON RUN] Verified session ${sessionId} stopped and removed it from tracking`);
-          });
-          if (requested) {
-            logger.debug(`[DAEMON RUN] Requested verified termination for session ${sessionId} (PID ${pid})`);
+            const trackedSession = {
+              startedBy: "daemon",
+              pid: tmuxResult.pid,
+              // Real PID from tmux -P flag
+              tmuxSessionId: tmuxResult.sessionId,
+              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.`
+            };
+            pidToTrackedSession.set(tmuxResult.pid, trackedSession);
+            logger.debug(`[DAEMON RUN] Waiting for session webhook for PID ${tmuxResult.pid} (tmux)`);
+            return new Promise((resolve) => {
+              const timeout = setTimeout(() => {
+                pidToAwaiter.delete(tmuxResult.pid);
+                logger.debug(`[DAEMON RUN] Session webhook timeout for PID ${tmuxResult.pid} (tmux)`);
+                resolve({
+                  type: "error",
+                  errorMessage: `Session webhook timeout for PID ${tmuxResult.pid} (tmux)`
+                });
+              }, 15e3);
+              pidToAwaiter.set(tmuxResult.pid, (completedSession) => {
+                clearTimeout(timeout);
+                logger.debug(`[DAEMON RUN] Session ${completedSession.happySessionId} fully spawned with webhook (tmux)`);
+                resolve({
+                  type: "success",
+                  sessionId: completedSession.happySessionId
+                });
+              });
+            });
           } else {
-            logger.debug(`[DAEMON RUN] Failed to signal session ${sessionId} (PID ${pid})`);
+            logger.debug(`[DAEMON RUN] Failed to spawn in tmux: ${tmuxResult.error}, falling back to regular spawning`);
+            useTmux = false;
           }
-          return requested;
         }
-      }
-      logger.debug(`[DAEMON RUN] Session ${sessionId} not found`);
-      return false;
-    };
-    const onChildExited = (pid) => {
-      const session = pidToTrackedSession.get(pid);
-      if (session?.happySessionId && session.encryption) {
-        sessionIdToFinishedSession.set(session.happySessionId, session);
-        logger.debug(`[DAEMON RUN] Process PID ${pid} exited, preserved session ${session.happySessionId} for resume`);
-      } else {
-        logger.debug(`[DAEMON RUN] Removing exited process PID ${pid} from tracking`);
-      }
-      pidToTrackedSession.delete(pid);
-    };
-    const assistantReportLastSentAt = /* @__PURE__ */ new Map();
-    const isPidAlive = (pid) => {
-      try {
-        process.kill(pid, 0);
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    const onSessionStateEvent = (sessionId, event, spawnedByFromSession) => {
-      void (async () => {
-        try {
-          let tracked;
-          for (const s of pidToTrackedSession.values()) {
-            if (s.happySessionId === sessionId) {
-              tracked = s;
+        if (!useTmux) {
+          logger.debug(`[DAEMON RUN] Using regular process spawning`);
+          let agentCommand;
+          switch (options.agent) {
+            case "claude":
+            case void 0:
+              agentCommand = "claude";
               break;
-            }
+            case "codex":
+              agentCommand = "codex";
+              break;
+            case "gemini":
+              agentCommand = "gemini";
+              break;
+            case "openclaw":
+              agentCommand = "openclaw";
+              break;
+            case "pi":
+              agentCommand = "pi";
+              break;
+            default:
+              return {
+                type: "error",
+                errorMessage: `Unsupported agent type: '${options.agent}'. Please update your CLI to the latest version.`
+              };
           }
-          const liveAssistant = findLiveAssistant(pidToTrackedSession.values(), isPidAlive);
-          const decision = decideAssistantReport({
-            // The tracked tag is authoritative; the session's own echo covers
-            // a daemon restart that lost the in-memory tracking.
-            spawnedBy: tracked?.spawnedBy ?? spawnedByFromSession,
-            isAssistantSession: tracked ? isAssistantTracked(tracked) : false,
-            sessionId,
-            assistantSessionId: liveAssistant?.happySessionId,
-            lastReportAt: assistantReportLastSentAt.get(sessionId),
-            now: Date.now()
-          });
-          if (!decision.send) {
-            logger.debug(`[DAEMON RUN] Assistant report skipped for ${sessionId} (${event}): ${decision.reason}`);
-            return;
+          const args = [
+            agentCommand,
+            "--happy-starting-mode",
+            "remote",
+            "--started-by",
+            "daemon"
+          ];
+          if (options.resumeClaudeSessionId && agentCommand === "claude") {
+            args.push("--resume", options.resumeClaudeSessionId);
           }
-          const persisted2 = readPersistedSessions();
-          const assistantEntry = persisted2[decision.assistantSessionId];
-          if (!assistantEntry) {
-            logger.debug(`[DAEMON RUN] Assistant report skipped for ${sessionId} (${event}): no session key for assistant ${decision.assistantSessionId}`);
-            return;
+          if (options.resumeCodexThreadId && agentCommand === "codex") {
+            args.push("--resume", options.resumeCodexThreadId);
           }
-          const title = resolveReportSessionTitle(
-            tracked?.happySessionMetadataFromLocalWebhook ?? persisted2[sessionId]?.metadata,
-            sessionId
-          );
-          assistantReportLastSentAt.set(sessionId, Date.now());
-          await sendUserMessage(
-            decision.assistantSessionId,
-            assistantEntry,
-            formatAssistantReportMessage(title, sessionId, event),
-            "assistant-report"
-          );
-          logger.debug(`[DAEMON RUN] Assistant report sent: session ${sessionId} ${event} \u2192 assistant ${decision.assistantSessionId}`);
-        } catch (error) {
-          logger.debug(`[DAEMON RUN] Assistant report failed for ${sessionId} (${event}):`, error);
-        }
-      })();
-    };
-    let apiMachineRef = null;
-    let mirrorManagerRef = null;
-    const controlToken = createDaemonControlToken();
-    const { port: controlPort, stop: stopControlServer } = await startDaemonControlServer({
-      controlToken,
-      getChildren: getCurrentChildren,
-      stopSession,
-      spawnSession,
-      requestShutdown: () => requestShutdown("happy-cli"),
-      onHappySessionWebhook,
-      onSessionStateEvent,
-      onClaudeAuthFailed: (sessionId) => claudeAuthServiceRef?.signalAuthFailed(sessionId),
-      pushClipboard: (text) => {
-        if (!apiMachineRef) {
-          return { delivered: false, truncated: false, totalBytes: 0, error: "daemon is still starting up" };
-        }
-        return apiMachineRef.pushClipboard(text);
-      },
-      onTerminalHook: (body) => {
-        mirrorManagerRef?.handleHookPayload(body);
-      },
-      setTerminalTitle: (terminalId, title, ifAbsent) => {
-        if (!apiMachineRef) return "starting";
-        return apiMachineRef.setTerminalTitle(terminalId, title, ifAbsent);
-      }
-    });
-    const daemonClaudeCredentials = resolveClaudeCredentialReadiness();
-    let fileState = {
-      pid: process.pid,
-      httpPort: controlPort,
-      controlToken,
-      startTime: (/* @__PURE__ */ new Date()).toLocaleString(),
-      startedWithCliVersion: packageJson.version,
-      serverUrl: configuration.serverUrl,
-      webappUrl: configuration.webappUrl,
-      daemonLogPath: logger.logFilePath,
-      claudeCredentialSource: daemonClaudeCredentials.source
-    };
-    writeDaemonState(fileState);
-    logger.debug("[DAEMON RUN] Daemon state written");
-    const bundlePath = join$1(projectPath(), "dist", "index.mjs");
-    let initialBundleMtimeMs = 0;
-    try {
-      initialBundleMtimeMs = statSync$1(bundlePath).mtimeMs;
-    } catch {
-      logger.debug(`[DAEMON RUN] Bundle at ${bundlePath} not found; self-restart on upgrade disabled`);
-    }
-    const initialDaemonState = {
-      status: "offline",
-      pid: process.pid,
-      httpPort: controlPort,
-      startedAt: Date.now()
-    };
-    const api = await ApiClient.create(credentials);
-    const machine = await api.getOrCreateMachine({
-      machineId,
-      metadata: initialMachineMetadata,
-      daemonState: initialDaemonState
-    });
-    logger.debug(`[DAEMON RUN] Machine registered: ${machine.id}`);
-    const identityConflict = detectMachineIdentityConflict(machine.metadata, {
-      host: initialMachineMetadata.host,
-      platform: initialMachineMetadata.platform,
-      homeDir: initialMachineMetadata.homeDir
-    });
-    if (identityConflict) {
-      logger.warn(`[DAEMON RUN] machine identity conflict (${identityConflict.confidence}): ${describeMachineIdentityConflict(identityConflict)}`);
-    }
-    const apiMachine = api.machineSyncClient(machine);
-    apiMachineRef = apiMachine;
-    const mirrorManager = createMirrorManager({
-      api,
-      machineId,
-      onBindingsChanged: () => apiMachine.requestTerminalListRefresh()
-    });
-    mirrorManagerRef = mirrorManager;
-    apiMachine.setMirrorIntegration({
-      resolveMirrorSessionId: (terminalId) => mirrorManager.resolveMirrorSessionId(terminalId),
-      onTerminalClosed: (terminalId) => mirrorManager.onTerminalClosed(terminalId),
-      onTerminalList: (terminals) => mirrorManager.observeTerminalList(terminals),
-      onTerminalListTick: (terminals) => mirrorManager.reconcile(terminals),
-      isMirrorInputAllowed: (terminalId) => mirrorManager.isMirrorInputAllowed(terminalId)
-    });
-    mirrorManager.restore().catch((error) => {
-      logger.debug("[DAEMON RUN] Mirror restore failed:", error);
-    });
-    apiMachine.setRPCHandlers({
-      spawnSession,
-      resumeSession,
-      restartSession,
-      stopSession,
-      listTrackedSessionIds: () => [...pidToTrackedSession.values()].map((session) => session.happySessionId).filter((sessionId) => typeof sessionId === "string"),
-      requestShutdown: () => requestShutdown("happy-app")
-    });
-    const claudeAuthService = new ClaudeAuthService({
-      happyHomeDir: configuration.happyHomeDir,
-      happyLibDir: projectPath(),
-      credentialSource: daemonClaudeCredentials.source,
-      getCredentialStore: () => claudeCredentialStoreSetting,
-      setCredentialStore: async (store) => {
-        const settings = await readSettings();
-        await writeSettings({ ...settings, claudeCredentialStore: store });
-        claudeCredentialStoreSetting = store;
-      },
-      publish: (state) => apiMachine.setClaudeAuthState(state)
-    });
-    claudeAuthServiceRef = claudeAuthService;
-    apiMachine.setClaudeAuthHandlers({
-      probe: () => claudeAuthService.probe("rpc", true),
-      repair: (action) => claudeAuthService.repair(action),
-      setStore: (store) => claudeAuthService.setStore(store)
-    });
-    claudeAuthService.start();
-    apiMachine.connect();
-    if (identityConflict?.confidence === "weak") {
-      void apiMachine.updateMachineMetadata((current) => ({
-        ...current ?? initialMachineMetadata,
-        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 lastUpdateLog = "";
-    const updateController = createUpdateController({
-      policy: () => fetchCliUpdateState(configuration.serverUrl, packageJson.version),
-      enabled: async () => ((await readSettings()).cliAutoUpdate ?? "idle") !== "off",
-      idle: () => pidToTrackedSession.size === 0 && !apiMachine.hasLiveTerminals(),
-      install: installCliSafely,
-      publish: (state) => {
-        cliUpdateStateRef = state;
-        fileState = { ...fileState, cliUpdate: state };
-        writeDaemonState(fileState);
-        apiMachine.setCliUpdateState(state);
-        const logKey = JSON.stringify([state.autoUpdate?.state, state.autoUpdate?.version, state.autoUpdate?.detail]);
-        if (logKey !== lastUpdateLog) {
-          lastUpdateLog = logKey;
-          logger.warn(`[DAEMON RUN] CLI update: ${state.autoUpdate?.state} target=${state.autoUpdate?.version ?? "none"} detail=${state.autoUpdate?.detail ?? "none"}`);
-        } else {
-          logger.debug("[DAEMON RUN] CLI update policy refreshed");
+          if (spawnPermissionMode) {
+            args.push("--permission-mode", spawnPermissionMode);
+          }
+          return spawnTrackedHappyProcess({
+            args,
+            cwd: directory,
+            env: {
+              ...process.env,
+              ...extraEnv
+            },
+            directoryCreated,
+            message: directoryCreated ? `The path '${directory}' did not exist. We created a new folder and spawned a new session there.` : void 0,
+            variant: trackedVariant,
+            spawnedBy: options.spawnedBy
+          });
         }
+        return {
+          type: "error",
+          errorMessage: "Unexpected error in session spawning"
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.debug("[DAEMON RUN] Failed to spawn session:", error);
+        return {
+          type: "error",
+          errorMessage: `Failed to spawn session: ${errorMessage}`
+        };
       }
-    });
-    apiMachine.setCliUpdateRetryHandler(updateController.retry);
-    const refreshCliUpdate = () => updateController.refresh().catch((error) => {
-      logger.debug("[DAEMON RUN] CLI update policy check failed:", error);
-    });
-    void refreshCliUpdate();
-    const cliUpdateIntervalMs = resolveCliUpdateCheckInterval(process.env.HAPPY_CLI_UPDATE_CHECK_INTERVAL);
-    if (process.env.HAPPY_CLI_UPDATE_CHECK_INTERVAL && cliUpdateIntervalMs === DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS && process.env.HAPPY_CLI_UPDATE_CHECK_INTERVAL.trim() !== String(DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS)) {
-      logger.warn(`[DAEMON RUN] Ignoring invalid HAPPY_CLI_UPDATE_CHECK_INTERVAL; using ${DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS}ms`);
-    }
-    const cliUpdateInterval = setInterval(() => void refreshCliUpdate(), cliUpdateIntervalMs);
-    const heartbeatIntervalMs = parseInt(process.env.HAPPY_DAEMON_HEARTBEAT_INTERVAL || "60000");
-    const restartOnStaleVersionAndHeartbeat = setInterval(serialTask(async () => {
-      try {
-        if (process.env.DEBUG) {
-          logger.debug(`[DAEMON RUN] Health check started at ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
+    };
+    const spawnTrackedHappyProcess = ({
+      args,
+      cwd,
+      env,
+      directoryCreated = false,
+      message,
+      variant,
+      spawnedBy
+    }) => {
+      const happyProcess = spawnHappyCLI(args, {
+        cwd,
+        detached: true,
+        stdio: "ignore",
+        env
+      });
+      if (!happyProcess.pid) {
+        logger.debug("[DAEMON RUN] Failed to spawn process - no PID returned");
+        return Promise.resolve({
+          type: "error",
+          errorMessage: "Failed to spawn Happy process - no PID returned"
+        });
+      }
+      logger.debug(`[DAEMON RUN] Spawned process with PID ${happyProcess.pid}`);
+      const trackedSession = {
+        startedBy: "daemon",
+        pid: happyProcess.pid,
+        childProcess: happyProcess,
+        directoryCreated,
+        message,
+        variant,
+        spawnedBy
+      };
+      pidToTrackedSession.set(happyProcess.pid, trackedSession);
+      happyProcess.on("exit", (code, signal) => {
+        logger.debug(`[DAEMON RUN] Child PID ${happyProcess.pid} exited with code ${code}, signal ${signal}`);
+        if (happyProcess.pid) {
+          onChildExited(happyProcess.pid);
         }
-        for (const [pid, _] of pidToTrackedSession.entries()) {
-          try {
-            process.kill(pid, 0);
-          } catch (error) {
-            logger.debug(`[DAEMON RUN] Finalizing stale session with PID ${pid} (process no longer exists)`);
-            onChildExited(pid);
-          }
+      });
+      happyProcess.on("error", (error) => {
+        logger.debug(`[DAEMON RUN] Child process error:`, error);
+        if (happyProcess.pid) {
+          onChildExited(happyProcess.pid);
         }
-        await updateController.tick();
-        await updateController.withHandover(async () => {
-          let bundleReplaced = false;
-          if (initialBundleMtimeMs > 0) {
+      });
+      logger.debug(`[DAEMON RUN] Waiting for session webhook for PID ${happyProcess.pid}`);
+      return new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          pidToAwaiter.delete(happyProcess.pid);
+          logger.debug(`[DAEMON RUN] Session webhook timeout for PID ${happyProcess.pid}`);
+          if (happyProcess.pid) {
             try {
-              const currentMtimeMs = statSync$1(bundlePath).mtimeMs;
-              bundleReplaced = currentMtimeMs !== initialBundleMtimeMs;
+              terminateProcess(happyProcess.pid, () => {
+              });
             } catch {
             }
           }
-          if (bundleReplaced && !updateController.isRunning() && pidToTrackedSession.size === 0 && !apiMachine.hasLiveTerminals()) {
-            const preflight = await preflightNewBundle(bundlePath);
-            if (preflight.action === "hold") {
-              if (lastHandoverHold !== preflight.reason) {
-                lastHandoverHold = preflight.reason;
-                logger.warn(`[DAEMON RUN] holding handover: ${preflight.reason}`);
-              }
-              updateController.holdHandover(preflight.reason);
-              return;
-            }
-            if (updateController.isRunning() || pidToTrackedSession.size > 0 || apiMachine.hasLiveTerminals()) return;
-            lastHandoverHold = null;
-            logger.debug("[DAEMON RUN] Daemon bundle replaced on disk and verified, handing off to new daemon");
-            clearInterval(restartOnStaleVersionAndHeartbeat);
-            clearInterval(cliUpdateInterval);
-            claudeAuthService.stop();
-            apiMachine.shutdown();
-            await stopControlServer();
-            await cleanupDaemonState();
-            await releaseDaemonLock(daemonLockHandle);
-            await stopCaffeinate();
-            try {
-              spawnHappyCLI(["daemon", "start"], {
-                detached: true,
-                stdio: "ignore"
-              });
-            } catch (error) {
-              logger.debug("[DAEMON RUN] Failed to spawn new daemon, this is quite likely to happen during integration tests as we are cleaning out dist/ directory", error);
-            }
-            process.exit(0);
+          resolve({
+            type: "error",
+            errorMessage: `Session webhook timeout for PID ${happyProcess.pid}`
+          });
+        }, 15e3);
+        pidToAwaiter.set(happyProcess.pid, (completedSession) => {
+          clearTimeout(timeout);
+          logger.debug(`[DAEMON RUN] Session ${completedSession.happySessionId} fully spawned with webhook`);
+          resolve({
+            type: "success",
+            sessionId: completedSession.happySessionId
+          });
+        });
+      });
+    };
+    const findTrackedSessionById = (happySessionId) => {
+      for (const session of pidToTrackedSession.values()) {
+        if (session.happySessionId === happySessionId) return session;
+      }
+      return sessionIdToFinishedSession.get(happySessionId);
+    };
+    const persistRestoreRecord = (happySessionId, fallback, metadata) => {
+      const candidates = [...pidToTrackedSession.values()].filter((s) => s.happySessionId === happySessionId && isPidAlive(s.pid));
+      const live = candidates.find((s) => s.childProcess) ?? candidates[0];
+      const encryption = live?.encryption ?? fallback.encryption;
+      if (!encryption) return;
+      persistSession(happySessionId, {
+        encryptionKey: encodeBase64(encryption.encryptionKey),
+        encryptionVariant: encryption.encryptionVariant,
+        seq: encryption.seq,
+        metadataVersion: encryption.metadataVersion,
+        agentStateVersion: encryption.agentStateVersion,
+        metadata: mergeRestoreMetadata(metadata, live?.happySessionMetadataFromLocalWebhook),
+        savedAt: Date.now()
+      });
+    };
+    const fetchServerSessionMetadata = async (sessionId, encryptionKey, encryptionVariant) => {
+      try {
+        const byId = await axios.get(`${configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`, {
+          headers: { Authorization: `Bearer ${credentials.token}` },
+          timeout: 1e4,
+          validateStatus: (status) => status >= 200 && status < 300 || status === 404
+        });
+        if (byId.status !== 404) {
+          const row = byId.data.session;
+          if (row?.metadata) return decrypt(encryptionKey, encryptionVariant, decodeBase64(row.metadata));
+        }
+      } catch (error) {
+        logger.debug(`[DAEMON RUN] by-id session metadata fetch failed, falling back to list: ${error instanceof Error ? error.message : error}`);
+      }
+      try {
+        const response = await axios.get(`${configuration.serverUrl}/v1/sessions`, {
+          headers: { Authorization: `Bearer ${credentials.token}` },
+          timeout: 1e4
+        });
+        const sessions = response.data.sessions;
+        const matched = sessions.find((s) => s.id === sessionId);
+        if (!matched) return null;
+        const decrypted = decrypt(encryptionKey, encryptionVariant, decodeBase64(matched.metadata));
+        return decrypted;
+      } catch (error) {
+        logger.debug(`[DAEMON RUN] Failed to fetch session metadata from server: ${error instanceof Error ? error.message : error}`);
+        return null;
+      }
+    };
+    const resumeGates = /* @__PURE__ */ new Map();
+    const resumeSession = async (happySessionId, options) => {
+      let gate = resumeGates.get(happySessionId);
+      if (!gate) {
+        gate = createSpawnGate();
+        resumeGates.set(happySessionId, gate);
+      }
+      try {
+        return await gate.join(() => resumeSessionImpl(happySessionId, options));
+      } finally {
+        if (!gate.inFlight()) resumeGates.delete(happySessionId);
+      }
+    };
+    const resumeSessionImpl = async (happySessionId, options) => {
+      try {
+        for (const [pid, live] of pidToTrackedSession.entries()) {
+          if (live.happySessionId !== happySessionId) continue;
+          if (isPidAlive(pid)) {
+            logger.debug(`[DAEMON RUN] resume ${happySessionId}: process ${pid} already alive \u2014 idempotent success`);
+            return { type: "success", sessionId: happySessionId };
+          }
+          onChildExited(pid);
+        }
+        const tracked = findTrackedSessionById(happySessionId);
+        if (!tracked) {
+          return { type: "error", errorMessage: `resume-precheck:not-tracked: Session ${happySessionId} is not tracked by this daemon. It may have been started before the daemon, more than 14 days ago, or on another machine.` };
+        }
+        const orphans = findSessionWrapperPids(tracked.happySessionMetadataFromLocalWebhook, await findAllHappyProcesses(), { excludePid: process.pid, lockPid: readSessionLock(happySessionId)?.pid }).filter((pid) => isPidAlive(pid) && !pidToTrackedSession.has(pid));
+        if (orphans.length > 0) {
+          for (const pid of orphans) {
+            pidToTrackedSession.set(pid, { ...tracked, pid, startedBy: "adopted untracked wrapper" });
+          }
+          logger.debug(`[DAEMON RUN] resume ${happySessionId}: adopted untracked live wrapper(s) ${orphans.join(", ")} \u2014 idempotent success`);
+          return { type: "success", sessionId: happySessionId };
+        }
+        if (!tracked.happySessionMetadataFromLocalWebhook) {
+          return { type: "error", errorMessage: `resume-precheck:no-metadata: Session ${happySessionId} has no metadata. Cannot resume.` };
+        }
+        if (!tracked.encryption) {
+          return { type: "error", errorMessage: `resume-precheck:no-encryption: Session ${happySessionId} has no stored encryption data. It was likely started before this feature was available. Restart the daemon and start a new session to enable resume.` };
+        }
+        let metadata = tracked.happySessionMetadataFromLocalWebhook;
+        const needsFetch = !metadata.claudeSessionId && (!metadata.flavor || metadata.flavor === "claude") || !metadata.codexThreadId && metadata.flavor === "codex";
+        if (needsFetch) {
+          logger.debug(`[DAEMON RUN] Session ${happySessionId} missing agent session ID in webhook metadata, fetching from server`);
+          const serverMetadata = await fetchServerSessionMetadata(happySessionId, tracked.encryption.encryptionKey, tracked.encryption.encryptionVariant);
+          if (serverMetadata) {
+            metadata = serverMetadata;
+            tracked.happySessionMetadataFromLocalWebhook = serverMetadata;
+          }
+        }
+        const precheck = resumePrecheck(metadata, {
+          cwdExists: (p) => existsSync$1(p),
+          conversationExists: (cwd, claudeSessionId) => existsSync$1(join$1(getProjectPath(cwd), `${claudeSessionId}.jsonl`))
+        });
+        if (!precheck.ok) {
+          return { type: "error", errorMessage: `resume-precheck:${precheck.reason}: ${precheck.detail}` };
+        }
+        const launch = buildResumeLaunch(
+          { id: happySessionId, active: true, metadata },
+          { startedBy: "daemon", claudeStartingMode: "remote" }
+        );
+        const model = sanitizeResumeModel(options?.model);
+        if (model) launch.args.push("--model", model);
+        else if (options?.model !== void 0) logger.debug(`[DAEMON RUN] resume: ignoring invalid model ${JSON.stringify(options.model)}`);
+        const permissionMode = sanitizeSpawnPermissionMode(options?.permissionMode);
+        if (permissionMode) launch.args.push("--permission-mode", permissionMode);
+        else if (options?.permissionMode !== void 0) logger.debug(`[DAEMON RUN] resume: ignoring invalid permission mode ${JSON.stringify(options.permissionMode)}`);
+        const result = await spawnTrackedHappyProcess({
+          args: launch.args,
+          cwd: launch.cwd,
+          env: {
+            ...process.env,
+            // B-297: the credentialStore=file shim must ride every spawn path,
+            // not just fresh sessions — a resumed/restarted wrapper that silently
+            // fell back to `auto` reads a different credential store than the
+            // fresh one next to it (B-276 D8).
+            ...claudeAuthServiceRef?.claudeProcessEnvOverrides() ?? {},
+            HAPPY_RECONNECT_SESSION_ID: happySessionId,
+            HAPPY_RECONNECT_ENCRYPTION_KEY: encodeBase64(tracked.encryption.encryptionKey),
+            HAPPY_RECONNECT_ENCRYPTION_VARIANT: tracked.encryption.encryptionVariant,
+            HAPPY_RECONNECT_SEQ: String(tracked.encryption.seq),
+            HAPPY_RECONNECT_METADATA_VERSION: String(tracked.encryption.metadataVersion),
+            HAPPY_RECONNECT_AGENT_STATE_VERSION: String(tracked.encryption.agentStateVersion)
           }
         });
-        const daemonState = await readDaemonState();
-        if (daemonState && daemonState.pid !== process.pid) {
-          logger.debug("[DAEMON RUN] Somehow a different daemon was started without killing us. We should kill ourselves.");
-          requestShutdown("exception", "A different daemon was started without killing us. We should kill ourselves.");
-        }
-        try {
-          fileState = withDaemonHeartbeat(fileState, (/* @__PURE__ */ new Date()).toLocaleString());
-          writeDaemonState(fileState);
-          if (process.env.DEBUG) {
-            logger.debug(`[DAEMON RUN] Health check completed at ${fileState.lastHeartbeat}`);
-          }
-        } catch (error) {
-          logger.debug("[DAEMON RUN] Failed to write heartbeat", error);
+        if (result.type === "success") {
+          persistRestoreRecord(happySessionId, tracked, metadata);
         }
+        return result;
       } catch (error) {
-        logger.debug("[DAEMON RUN] Heartbeat failed:", error);
-      }
-    }), heartbeatIntervalMs);
-    const cleanupAndShutdown = async (source, errorMessage) => {
-      logger.debug(`[DAEMON RUN] Starting proper cleanup (source: ${source}, errorMessage: ${errorMessage})...`);
-      if (restartOnStaleVersionAndHeartbeat) {
-        clearInterval(restartOnStaleVersionAndHeartbeat);
-        logger.debug("[DAEMON RUN] Health check interval cleared");
-      }
-      clearInterval(cliUpdateInterval);
-      await apiMachine.updateDaemonState((state) => ({
-        ...state,
-        status: "shutting-down",
-        shutdownRequestedAt: Date.now(),
-        shutdownSource: source
-      }));
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      try {
-        await mirrorManager.shutdown();
-      } catch (error) {
-        logger.debug("[DAEMON RUN] Mirror shutdown failed:", error);
+        const errorMessage = error instanceof Error ? error.message : error && typeof error === "object" ? JSON.stringify(error) : String(error);
+        logger.debug(`[DAEMON RUN] Failed to resume session: ${errorMessage}`, error instanceof Error ? error.stack : void 0);
+        return {
+          type: "error",
+          errorMessage: `Failed to resume session: ${errorMessage}`
+        };
       }
-      apiMachine.shutdown();
-      await stopControlServer();
-      await cleanupDaemonState();
-      await stopCaffeinate();
-      await releaseDaemonLock(daemonLockHandle);
-      logger.debug("[DAEMON RUN] Cleanup completed, exiting process");
-      process.exit(0);
     };
-    logger.debug("[DAEMON RUN] Daemon started successfully, waiting for shutdown request");
-    const shutdownRequest = await resolvesWhenShutdownRequested;
-    await cleanupAndShutdown(shutdownRequest.source, shutdownRequest.errorMessage);
-  } catch (error) {
-    logger.debug("[DAEMON RUN][FATAL] Failed somewhere unexpectedly - exiting with code 1", error);
-    process.exit(1);
-  }
-}
-
-const MAX_LINE_CHARS = 500;
-const MAX_ARGS_CHARS = 160;
-function truncateText(text, max = MAX_LINE_CHARS) {
-  const chars = Array.from(text);
-  if (chars.length <= max) return text;
-  return chars.slice(0, max).join("") + ` \u2026[+${chars.length - max} chars]`;
-}
-function squash(text) {
-  return text.replace(/\s+/g, " ").trim();
-}
-function safeJson(value, max) {
-  try {
-    return truncateText(JSON.stringify(value) ?? "", max);
-  } catch {
-    return "[unserializable]";
-  }
-}
-function formatMessageBody(body) {
-  if (!body || typeof body !== "object") return null;
-  const b = body;
-  if (b.role === "user" && b.content?.type === "text" && typeof b.content.text === "string") {
-    const text = squash(b.content.text);
-    return text.length > 0 ? `user: ${truncateText(text)}` : null;
-  }
-  if (b.role === "session" && b.content && typeof b.content === "object") {
-    const env = b.content;
-    const ev = env.ev;
-    if (!ev || typeof ev.t !== "string") return null;
-    switch (ev.t) {
-      case "text": {
-        if (ev.thinking) return null;
-        const text = squash(String(ev.text ?? ""));
-        if (text.length === 0) return null;
-        const role = env.role === "user" ? "user" : "assistant";
-        return `${role}: ${truncateText(text)}`;
-      }
-      case "tool-call-start": {
-        const name = String(ev.name ?? "tool");
-        const title = squash(String(ev.title ?? ""));
-        const args = ev.args ? safeJson(ev.args, MAX_ARGS_CHARS) : "";
-        const detail = title || args;
-        return `[tool] ${name}${detail ? `: ${truncateText(detail, MAX_ARGS_CHARS)}` : ""}`;
-      }
-      case "service": {
-        const text = squash(String(ev.text ?? ""));
-        return text.length > 0 ? `[service] ${truncateText(text, MAX_ARGS_CHARS)}` : null;
-      }
-      case "turn-end": {
-        if (ev.status && ev.status !== "completed") return `[turn ${ev.status}]`;
-        return null;
-      }
-      default:
-        return null;
-    }
-  }
-  if (b.role === "agent" && b.content?.type === "acp" && b.content.data && typeof b.content.data === "object") {
-    const d = b.content.data;
-    switch (d.type) {
-      case "message": {
-        const text = squash(String(d.message ?? ""));
-        return text.length > 0 ? `assistant: ${truncateText(text)}` : null;
+    const restartCounts = /* @__PURE__ */ new Map();
+    const stopSessionAndWait = async (happySessionId, timeoutMs = 8e3) => {
+      const targets = /* @__PURE__ */ new Set();
+      for (const [pid, s] of pidToTrackedSession.entries()) {
+        if (s.happySessionId === happySessionId && isPidAlive(pid)) targets.add(pid);
       }
-      case "tool-call":
-        return `[tool] ${String(d.name ?? "tool")}: ${safeJson(d.input, MAX_ARGS_CHARS)}`;
-      case "permission-request":
-        return `[permission] ${String(d.toolName ?? "")}: ${truncateText(squash(String(d.description ?? "")), MAX_ARGS_CHARS)}`;
-      default:
-        return null;
-    }
-  }
-  if (b.role === "agent" && b.content?.type === "output") {
-    const msg = b.content.data?.message;
-    if (msg && Array.isArray(msg.content)) {
-      const texts = msg.content.filter((c) => c?.type === "text" && typeof c.text === "string").map((c) => squash(c.text)).filter((t) => t.length > 0);
-      if (texts.length > 0) {
-        const role = msg.role === "user" ? "user" : "assistant";
-        return `${role}: ${truncateText(texts.join(" "))}`;
+      const known = findTrackedSessionById(happySessionId)?.happySessionMetadataFromLocalWebhook;
+      for (const pid of findSessionWrapperPids(known, await findAllHappyProcesses(), { excludePid: process.pid, lockPid: readSessionLock(happySessionId)?.pid })) {
+        if (isPidAlive(pid)) targets.add(pid);
       }
-    }
-    return null;
-  }
-  return null;
-}
-function formatTranscript(bodies) {
-  const lines = [];
-  for (const body of bodies) {
-    const line = formatMessageBody(body);
-    if (line !== null) lines.push(line);
-  }
-  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 RPC_RATE_LIMIT_ERROR = "RPC rate limit reached";
-const RPC_ACCOUNT_RATE_LIMIT_ERROR = "RPC account rate limit reached";
-const RPC_RATE_RETRY_MIN_DELAY_MS = 2e3;
-const RPC_RATE_RETRY_MAX_DELAY_MS = 6e4;
-const RPC_RATE_MAX_RETRIES = 2;
-function isRpcRateLimitAck(ack) {
-  if (!ack || typeof ack !== "object") return false;
-  const a = ack;
-  if (a.ok !== false) return false;
-  if (a.code === "rpc_rate_limited" || a.code === "rpc_account_rate_limited") return true;
-  return a.error === RPC_RATE_LIMIT_ERROR || a.error === RPC_ACCOUNT_RATE_LIMIT_ERROR;
-}
-function rpcRateRetryDelayMs(attempt, retryAfterMs, random = Math.random()) {
-  if (typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs > 0) {
-    return Math.min(RPC_RATE_RETRY_MAX_DELAY_MS, Math.round(retryAfterMs * (1 + random * 0.5)));
-  }
-  const exponent = Math.max(0, Math.min(attempt, 32) - 1);
-  const ceiling = Math.min(RPC_RATE_RETRY_MIN_DELAY_MS * 2 ** exponent, RPC_RATE_RETRY_MAX_DELAY_MS);
-  return Math.round(RPC_RATE_RETRY_MIN_DELAY_MS + random * (ceiling - RPC_RATE_RETRY_MIN_DELAY_MS));
-}
-
-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"
+      if (targets.size === 0) return;
+      logger.debug(`[DAEMON RUN] restart ${happySessionId}: stopping live wrapper(s) ${[...targets].join(", ")}`);
+      await Promise.all([...targets].map((pid) => new Promise((resolve) => {
+        let settled = false;
+        const done = () => {
+          if (!settled) {
+            settled = true;
+            resolve();
+          }
+        };
+        const requested = terminateProcess(pid, () => {
+          const tracked = pidToTrackedSession.get(pid);
+          if (tracked) {
+            if (tracked.happySessionId && tracked.encryption) {
+              sessionIdToFinishedSession.set(tracked.happySessionId, tracked);
+            }
+            pidToTrackedSession.delete(pid);
+          }
+          done();
+        });
+        if (!requested) done();
+        setTimeout(done, timeoutMs).unref?.();
+      })));
     };
-  }
-  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 };
-    }
-    if (isRpcRateLimitAck(ack)) {
-      return { status: "rate-limited", message, retryAfterMs: rpcRateRetryDelayMs(1, ack.retryAfterMs, 0) };
-    }
-    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);
+    const restartSession = async (happySessionId, options) => {
+      let gate = resumeGates.get(happySessionId);
+      if (!gate) {
+        gate = createSpawnGate();
+        resumeGates.set(happySessionId, gate);
       }
-    );
-  });
-}
-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;
-  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-  let ack;
-  try {
-    for (let attempt = 1; ; attempt++) {
       try {
-        ack = await withDeadline(
-          transport.rpcCall({ method: `${sessionId}:permission`, params }, rpcTimeoutMs),
-          rpcTimeoutMs + RPC_DEADLINE_GRACE_MS,
-          `permission RPC did not settle within ${rpcTimeoutMs}ms`
-        );
+        return await gate.replace(() => restartSessionImpl(happySessionId, options));
+      } finally {
+        if (!gate.inFlight()) resumeGates.delete(happySessionId);
+      }
+    };
+    const restartSessionImpl = async (happySessionId, options) => {
+      try {
+        const prior = restartCounts.get(happySessionId) ?? 0;
+        const decision = decideRestart(prior, DEFAULT_MAX_RESTARTS);
+        if (!decision.allowed) {
+          return { type: "error", errorMessage: `restart:${decision.reason}` };
+        }
+        await stopSessionAndWait(happySessionId);
+        const tracked = findTrackedSessionById(happySessionId);
+        if (!tracked) {
+          return { type: "error", errorMessage: `restart-precheck:not-tracked: Session ${happySessionId} is not tracked by this daemon.` };
+        }
+        if (!tracked.happySessionMetadataFromLocalWebhook) {
+          return { type: "error", errorMessage: `restart-precheck:no-metadata: Session ${happySessionId} has no metadata. Cannot restart.` };
+        }
+        if (!tracked.encryption) {
+          return { type: "error", errorMessage: `restart-precheck:no-encryption: Session ${happySessionId} has no stored encryption data. Restart the daemon and start a new session.` };
+        }
+        let metadata = tracked.happySessionMetadataFromLocalWebhook;
+        const needsFetch = !metadata.claudeSessionId && (!metadata.flavor || metadata.flavor === "claude") || !metadata.codexThreadId && metadata.flavor === "codex";
+        if (needsFetch) {
+          const serverMetadata = await fetchServerSessionMetadata(happySessionId, tracked.encryption.encryptionKey, tracked.encryption.encryptionVariant);
+          if (serverMetadata) {
+            metadata = serverMetadata;
+            tracked.happySessionMetadataFromLocalWebhook = serverMetadata;
+          }
+        }
+        const precheck = resumePrecheck(metadata, {
+          cwdExists: (p) => existsSync$1(p),
+          conversationExists: (cwd2, claudeSessionId) => existsSync$1(join$1(getProjectPath(cwd2), `${claudeSessionId}.jsonl`))
+        });
+        let args;
+        let cwd;
+        if (precheck.ok) {
+          const launch = buildResumeLaunch(
+            { id: happySessionId, active: true, metadata },
+            { startedBy: "daemon", claudeStartingMode: "remote" }
+          );
+          args = launch.args;
+          cwd = launch.cwd;
+        } else if ((metadata.flavor ?? "claude") === "claude" && typeof metadata.path === "string" && metadata.path.length > 0) {
+          cwd = metadata.path;
+          if (!existsSync$1(cwd)) {
+            return { type: "error", errorMessage: `restart-precheck:cwd-missing: ${cwd}` };
+          }
+          args = ["claude", "--happy-starting-mode", "remote", "--started-by", "daemon"];
+        } else {
+          return { type: "error", errorMessage: `restart-precheck:${precheck.ok ? "unknown" : precheck.reason}: ${precheck.ok ? "" : precheck.detail}` };
+        }
+        const model = sanitizeResumeModel(options?.model);
+        if (model) args.push("--model", model);
+        const permissionMode = sanitizeSpawnPermissionMode(options?.permissionMode);
+        if (permissionMode) args.push("--permission-mode", permissionMode);
+        restartCounts.set(happySessionId, recordRestartAttempt(prior));
+        const result = await spawnTrackedHappyProcess({
+          args,
+          cwd,
+          env: {
+            ...process.env,
+            // B-297: the credentialStore=file shim must ride every spawn path,
+            // not just fresh sessions — a resumed/restarted wrapper that silently
+            // fell back to `auto` reads a different credential store than the
+            // fresh one next to it (B-276 D8).
+            ...claudeAuthServiceRef?.claudeProcessEnvOverrides() ?? {},
+            HAPPY_RECONNECT_SESSION_ID: happySessionId,
+            HAPPY_RECONNECT_ENCRYPTION_KEY: encodeBase64(tracked.encryption.encryptionKey),
+            HAPPY_RECONNECT_ENCRYPTION_VARIANT: tracked.encryption.encryptionVariant,
+            HAPPY_RECONNECT_SEQ: String(tracked.encryption.seq),
+            HAPPY_RECONNECT_METADATA_VERSION: String(tracked.encryption.metadataVersion),
+            HAPPY_RECONNECT_AGENT_STATE_VERSION: String(tracked.encryption.agentStateVersion)
+          }
+        });
+        if (result.type === "success") {
+          persistRestoreRecord(happySessionId, tracked, metadata);
+        }
+        return result;
       } catch (error) {
-        ack = { ok: false, error: error instanceof Error ? error.message : "RPC call failed" };
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.debug(`[DAEMON RUN] Failed to restart session: ${errorMessage}`, error instanceof Error ? error.stack : void 0);
+        return { type: "error", errorMessage: `Failed to restart session: ${errorMessage}` };
       }
-      if (!isRpcRateLimitAck(ack) || attempt > RPC_RATE_MAX_RETRIES) break;
-      const waitMs = rpcRateRetryDelayMs(attempt, ack.retryAfterMs, (deps.random ?? Math.random)());
-      deps.onRateLimited?.({ attempt, waitMs, serverError: ack.error ?? "RPC rate limit reached" });
-      await sleep(waitMs);
-    }
-  } finally {
-    transport.close();
-  }
-  const outcome = interpretPermissionAck(ack, (encrypted) => decrypt(key, persisted.encryptionVariant, decodeBase64(encrypted)));
-  if (outcome.status !== "acknowledged") {
-    return { sessionId, requestId, payload, outcome };
-  }
-  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}`
+    };
+    const stopSession = (sessionId) => {
+      logger.debug(`[DAEMON RUN] Attempting to stop session ${sessionId}`);
+      for (const [pid, session] of pidToTrackedSession.entries()) {
+        if (session.happySessionId === sessionId || sessionId.startsWith("PID-") && pid === parseInt(sessionId.replace("PID-", ""))) {
+          const requested = terminateProcess(pid, (stopped) => {
+            if (!stopped) {
+              logger.debug(`[DAEMON RUN] Session ${sessionId} survived SIGTERM and SIGKILL attempts`);
+              return;
+            }
+            const tracked = pidToTrackedSession.get(pid);
+            if (!tracked) return;
+            if (tracked.happySessionId && tracked.encryption) {
+              sessionIdToFinishedSession.set(tracked.happySessionId, tracked);
+            }
+            pidToTrackedSession.delete(pid);
+            logger.debug(`[DAEMON RUN] Verified session ${sessionId} stopped and removed it from tracking`);
+          });
+          if (requested) {
+            logger.debug(`[DAEMON RUN] Requested verified termination for session ${sessionId} (PID ${pid})`);
+          } else {
+            logger.debug(`[DAEMON RUN] Failed to signal session ${sessionId} (PID ${pid})`);
+          }
+          return requested;
+        }
+      }
+      logger.debug(`[DAEMON RUN] Session ${sessionId} not found`);
+      return false;
+    };
+    const onChildExited = (pid) => {
+      const session = pidToTrackedSession.get(pid);
+      if (session?.happySessionId && (session.spawnedBy === "teams" || teamWorker?.hasSession(session.happySessionId))) teamWorker?.report(session.happySessionId, "exited");
+      if (session?.happySessionId && session.encryption) {
+        sessionIdToFinishedSession.set(session.happySessionId, session);
+        logger.debug(`[DAEMON RUN] Process PID ${pid} exited, preserved session ${session.happySessionId} for resume`);
+      } else {
+        logger.debug(`[DAEMON RUN] Removing exited process PID ${pid} from tracking`);
+      }
+      pidToTrackedSession.delete(pid);
+    };
+    const assistantReportLastSentAt = /* @__PURE__ */ new Map();
+    const isPidAlive = (pid) => {
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    const onSessionStateEvent = (sessionId, event, spawnedByFromSession) => {
+      if (spawnedByFromSession === "teams" || teamWorker?.hasSession(sessionId) || [...pidToTrackedSession.values()].some((s) => s.happySessionId === sessionId && s.spawnedBy === "teams")) {
+        teamWorker?.report(sessionId, event === "completed" ? "idle" : "blocked");
+        return;
+      }
+      void (async () => {
+        try {
+          let tracked;
+          for (const s of pidToTrackedSession.values()) {
+            if (s.happySessionId === sessionId) {
+              tracked = s;
+              break;
+            }
+          }
+          const liveAssistant = findLiveAssistant(pidToTrackedSession.values(), isPidAlive);
+          const decision = decideAssistantReport({
+            // The tracked tag is authoritative; the session's own echo covers
+            // a daemon restart that lost the in-memory tracking.
+            spawnedBy: tracked?.spawnedBy ?? spawnedByFromSession,
+            isAssistantSession: tracked ? isAssistantTracked(tracked) : false,
+            sessionId,
+            assistantSessionId: liveAssistant?.happySessionId,
+            lastReportAt: assistantReportLastSentAt.get(sessionId),
+            now: Date.now()
+          });
+          if (!decision.send) {
+            logger.debug(`[DAEMON RUN] Assistant report skipped for ${sessionId} (${event}): ${decision.reason}`);
+            return;
+          }
+          const persisted2 = readPersistedSessions();
+          const assistantEntry = persisted2[decision.assistantSessionId];
+          if (!assistantEntry) {
+            logger.debug(`[DAEMON RUN] Assistant report skipped for ${sessionId} (${event}): no session key for assistant ${decision.assistantSessionId}`);
+            return;
+          }
+          const title = resolveReportSessionTitle(
+            tracked?.happySessionMetadataFromLocalWebhook ?? persisted2[sessionId]?.metadata,
+            sessionId
+          );
+          assistantReportLastSentAt.set(sessionId, Date.now());
+          await sendUserMessage(
+            decision.assistantSessionId,
+            assistantEntry,
+            formatAssistantReportMessage(title, sessionId, event),
+            "assistant-report"
+          );
+          logger.debug(`[DAEMON RUN] Assistant report sent: session ${sessionId} ${event} \u2192 assistant ${decision.assistantSessionId}`);
+        } catch (error) {
+          logger.debug(`[DAEMON RUN] Assistant report failed for ${sessionId} (${event}):`, error);
+        }
+      })();
+    };
+    let apiMachineRef = null;
+    let mirrorManagerRef = null;
+    const controlToken = createDaemonControlToken();
+    const { port: controlPort, stop: stopControlServer } = await startDaemonControlServer({
+      controlToken,
+      getChildren: getCurrentChildren,
+      stopSession,
+      spawnSession,
+      requestShutdown: () => requestShutdown("happy-cli"),
+      onHappySessionWebhook,
+      onSessionStateEvent,
+      onClaudeAuthFailed: (sessionId) => claudeAuthServiceRef?.signalAuthFailed(sessionId),
+      pushClipboard: (text) => {
+        if (!apiMachineRef) {
+          return { delivered: false, truncated: false, totalBytes: 0, error: "daemon is still starting up" };
+        }
+        return apiMachineRef.pushClipboard(text);
       },
-      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;
-function mergeSessionSummaries(live, persisted, options = {}) {
-  const recentLimit = Math.max(0, options.recentLimit ?? DEFAULT_RECENT_LIMIT);
-  const seen = /* @__PURE__ */ new Set();
-  const summaries = [];
-  for (const child of live) {
-    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], 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) {
-    summaries.push(toSummary(id, entry, { live: false }));
-  }
-  if (!options.tag) return summaries;
-  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 {
-    id,
-    live: extra.live,
-    ...extra.pid !== void 0 ? { pid: extra.pid } : {},
-    ...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 } : {},
-    url: sessionWebUrl(id),
-    ...persisted?.savedAt !== void 0 ? { savedAt: persisted.savedAt } : {}
-  };
-}
-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)");
-  return credentials.token;
-}
-async function readSessionTranscript(sessionId, limit) {
-  const persisted = readPersistedSessions()[sessionId];
-  if (!persisted) {
-    throw new Error(
-      `No local key for session ${sessionId} \u2014 it was not spawned by this machine's daemon (or is older than 14 days).`
-    );
-  }
-  const bounded = Math.max(1, Math.min(MAX_READ_LIMIT, Math.floor(limit)));
-  const token = await bearerToken();
-  const response = await axios.get(
-    `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(sessionId)}/messages`,
-    {
-      params: { before_seq: 2147483647, limit: bounded },
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.currentCliVersion}`
+      onTerminalHook: (body) => {
+        mirrorManagerRef?.handleHookPayload(body);
       },
-      timeout: 15e3
-    }
-  );
-  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;
+      setTerminalTitle: (terminalId, title, ifAbsent) => {
+        if (!apiMachineRef) return "starting";
+        return apiMachineRef.setTerminalTitle(terminalId, title, ifAbsent);
+      }
+    });
+    const daemonClaudeCredentials = resolveClaudeCredentialReadiness();
+    let fileState = {
+      pid: process.pid,
+      httpPort: controlPort,
+      controlToken,
+      startTime: (/* @__PURE__ */ new Date()).toLocaleString(),
+      startedWithCliVersion: packageJson.version,
+      serverUrl: configuration.serverUrl,
+      webappUrl: configuration.webappUrl,
+      daemonLogPath: logger.logFilePath,
+      claudeCredentialSource: daemonClaudeCredentials.source
+    };
+    writeDaemonState(fileState);
+    logger.debug("[DAEMON RUN] Daemon state written");
+    const bundlePath = join$1(projectPath(), "dist", "index.mjs");
+    let initialBundleMtimeMs = 0;
     try {
-      return decrypt(key, persisted.encryptionVariant, decodeBase64(message.content.c));
+      initialBundleMtimeMs = statSync$1(bundlePath).mtimeMs;
     } catch {
-      return null;
+      logger.debug(`[DAEMON RUN] Bundle at ${bundlePath} not found; self-restart on upgrade disabled`);
     }
-  });
-  return {
-    summary: toSummary(sessionId, persisted, sessionLiveness(live, sessionId)),
-    messageCount: messages.length,
-    transcript: formatTranscript(bodies)
-  };
-}
-async function stopSession(sessionId) {
-  return await stopDaemonSession(sessionId);
-}
-async function archiveSession(sessionId) {
-  const token = await bearerToken();
-  await axios.post(
-    `${configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}/archive`,
-    {},
-    {
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.currentCliVersion}`
+    const initialDaemonState = {
+      status: "offline",
+      pid: process.pid,
+      httpPort: controlPort,
+      startedAt: Date.now()
+    };
+    const api = await ApiClient.create(credentials);
+    const machine = await api.getOrCreateMachine({
+      machineId,
+      metadata: initialMachineMetadata,
+      daemonState: initialDaemonState
+    });
+    logger.debug(`[DAEMON RUN] Machine registered: ${machine.id}`);
+    const identityConflict = detectMachineIdentityConflict(machine.metadata, {
+      host: initialMachineMetadata.host,
+      platform: initialMachineMetadata.platform,
+      homeDir: initialMachineMetadata.homeDir
+    });
+    if (identityConflict) {
+      logger.warn(`[DAEMON RUN] machine identity conflict (${identityConflict.confidence}): ${describeMachineIdentityConflict(identityConflict)}`);
+    }
+    const apiMachine = api.machineSyncClient(machine);
+    apiMachineRef = apiMachine;
+    const mirrorManager = createMirrorManager({
+      api,
+      machineId,
+      onBindingsChanged: () => apiMachine.requestTerminalListRefresh()
+    });
+    mirrorManagerRef = mirrorManager;
+    apiMachine.setMirrorIntegration({
+      resolveMirrorSessionId: (terminalId) => mirrorManager.resolveMirrorSessionId(terminalId),
+      onTerminalClosed: (terminalId) => mirrorManager.onTerminalClosed(terminalId),
+      onTerminalList: (terminals) => mirrorManager.observeTerminalList(terminals),
+      onTerminalListTick: (terminals) => mirrorManager.reconcile(terminals),
+      isMirrorInputAllowed: (terminalId) => mirrorManager.isMirrorInputAllowed(terminalId)
+    });
+    mirrorManager.restore().catch((error) => {
+      logger.debug("[DAEMON RUN] Mirror restore failed:", error);
+    });
+    apiMachine.setRPCHandlers({
+      spawnSession,
+      resumeSession,
+      restartSession,
+      stopSession,
+      listTrackedSessionIds: () => [...pidToTrackedSession.values()].map((session) => session.happySessionId).filter((sessionId) => typeof sessionId === "string"),
+      requestShutdown: () => requestShutdown("happy-app")
+    });
+    const claudeAuthService = new ClaudeAuthService({
+      happyHomeDir: configuration.happyHomeDir,
+      happyLibDir: projectPath(),
+      credentialSource: daemonClaudeCredentials.source,
+      getCredentialStore: () => claudeCredentialStoreSetting,
+      setCredentialStore: async (store) => {
+        const settings = await readSettings();
+        await writeSettings({ ...settings, claudeCredentialStore: store });
+        claudeCredentialStoreSetting = store;
       },
-      timeout: 1e4
+      publish: (state) => apiMachine.setClaudeAuthState(state)
+    });
+    claudeAuthServiceRef = claudeAuthService;
+    apiMachine.setClaudeAuthHandlers({
+      probe: () => claudeAuthService.probe("rpc", true),
+      repair: (action) => claudeAuthService.repair(action),
+      setStore: (store) => claudeAuthService.setStore(store)
+    });
+    claudeAuthService.start();
+    apiMachine.connect();
+    if (identityConflict?.confidence === "weak") {
+      void apiMachine.updateMachineMetadata((current) => ({
+        ...current ?? initialMachineMetadata,
+        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 lastUpdateLog = "";
+    const updateController = createUpdateController({
+      policy: () => fetchCliUpdateState(configuration.serverUrl, packageJson.version),
+      enabled: async () => ((await readSettings()).cliAutoUpdate ?? "idle") !== "off",
+      idle: () => pidToTrackedSession.size === 0 && !apiMachine.hasLiveTerminals(),
+      install: installCliSafely,
+      publish: (state) => {
+        cliUpdateStateRef = state;
+        fileState = { ...fileState, cliUpdate: state };
+        writeDaemonState(fileState);
+        apiMachine.setCliUpdateState(state);
+        const logKey = JSON.stringify([state.autoUpdate?.state, state.autoUpdate?.version, state.autoUpdate?.detail]);
+        if (logKey !== lastUpdateLog) {
+          lastUpdateLog = logKey;
+          logger.warn(`[DAEMON RUN] CLI update: ${state.autoUpdate?.state} target=${state.autoUpdate?.version ?? "none"} detail=${state.autoUpdate?.detail ?? "none"}`);
+        } else {
+          logger.debug("[DAEMON RUN] CLI update policy refreshed");
+        }
+      }
+    });
+    apiMachine.setCliUpdateRetryHandler(updateController.retry);
+    const refreshCliUpdate = () => updateController.refresh().catch((error) => {
+      logger.debug("[DAEMON RUN] CLI update policy check failed:", error);
+    });
+    void refreshCliUpdate();
+    const cliUpdateIntervalMs = resolveCliUpdateCheckInterval(process.env.HAPPY_CLI_UPDATE_CHECK_INTERVAL);
+    if (process.env.HAPPY_CLI_UPDATE_CHECK_INTERVAL && cliUpdateIntervalMs === DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS && process.env.HAPPY_CLI_UPDATE_CHECK_INTERVAL.trim() !== String(DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS)) {
+      logger.warn(`[DAEMON RUN] Ignoring invalid HAPPY_CLI_UPDATE_CHECK_INTERVAL; using ${DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS}ms`);
+    }
+    const cliUpdateInterval = setInterval(() => void refreshCliUpdate(), cliUpdateIntervalMs);
+    const heartbeatIntervalMs = parseInt(process.env.HAPPY_DAEMON_HEARTBEAT_INTERVAL || "60000");
+    const restartOnStaleVersionAndHeartbeat = setInterval(serialTask(async () => {
+      try {
+        if (process.env.DEBUG) {
+          logger.debug(`[DAEMON RUN] Health check started at ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
+        }
+        for (const [pid, _] of pidToTrackedSession.entries()) {
+          try {
+            process.kill(pid, 0);
+          } catch (error) {
+            logger.debug(`[DAEMON RUN] Finalizing stale session with PID ${pid} (process no longer exists)`);
+            onChildExited(pid);
+          }
+        }
+        await updateController.tick();
+        await updateController.withHandover(async () => {
+          let bundleReplaced = false;
+          if (initialBundleMtimeMs > 0) {
+            try {
+              const currentMtimeMs = statSync$1(bundlePath).mtimeMs;
+              bundleReplaced = currentMtimeMs !== initialBundleMtimeMs;
+            } catch {
+            }
+          }
+          if (bundleReplaced && !teamWorker?.busy && !updateController.isRunning() && pidToTrackedSession.size === 0 && !apiMachine.hasLiveTerminals()) {
+            const preflight = await preflightNewBundle(bundlePath);
+            if (preflight.action === "hold") {
+              if (lastHandoverHold !== preflight.reason) {
+                lastHandoverHold = preflight.reason;
+                logger.warn(`[DAEMON RUN] holding handover: ${preflight.reason}`);
+              }
+              updateController.holdHandover(preflight.reason);
+              return;
+            }
+            if (teamWorker?.busy || updateController.isRunning() || pidToTrackedSession.size > 0 || apiMachine.hasLiveTerminals()) return;
+            lastHandoverHold = null;
+            logger.debug("[DAEMON RUN] Daemon bundle replaced on disk and verified, handing off to new daemon");
+            teamWorker?.stop();
+            clearInterval(restartOnStaleVersionAndHeartbeat);
+            clearInterval(cliUpdateInterval);
+            claudeAuthService.stop();
+            apiMachine.shutdown();
+            await stopControlServer();
+            await cleanupDaemonState();
+            await releaseDaemonLock(daemonLockHandle);
+            await stopCaffeinate();
+            try {
+              spawnHappyCLI(["daemon", "start"], {
+                detached: true,
+                stdio: "ignore"
+              });
+            } catch (error) {
+              logger.debug("[DAEMON RUN] Failed to spawn new daemon, this is quite likely to happen during integration tests as we are cleaning out dist/ directory", error);
+            }
+            process.exit(0);
+          }
+        });
+        const daemonState = await readDaemonState();
+        if (daemonState && daemonState.pid !== process.pid) {
+          logger.debug("[DAEMON RUN] Somehow a different daemon was started without killing us. We should kill ourselves.");
+          requestShutdown("exception", "A different daemon was started without killing us. We should kill ourselves.");
+        }
+        try {
+          fileState = withDaemonHeartbeat(fileState, (/* @__PURE__ */ new Date()).toLocaleString());
+          writeDaemonState(fileState);
+          if (process.env.DEBUG) {
+            logger.debug(`[DAEMON RUN] Health check completed at ${fileState.lastHeartbeat}`);
+          }
+        } catch (error) {
+          logger.debug("[DAEMON RUN] Failed to write heartbeat", error);
+        }
+      } catch (error) {
+        logger.debug("[DAEMON RUN] Heartbeat failed:", error);
+      }
+    }), heartbeatIntervalMs);
+    teamWorker = createTeamWorker({
+      machineId,
+      token: credentials.token,
+      spawn: spawnSession,
+      stopAndWait: async (id) => {
+        await stopSessionAndWait(id);
+        const metadata = findTrackedSessionById(id)?.happySessionMetadataFromLocalWebhook ?? readPersistedSessions()[id]?.metadata;
+        const remaining = findSessionWrapperPids(metadata, await findAllHappyProcesses(), { excludePid: process.pid, lockPid: readSessionLock(id)?.pid });
+        if (remaining.some(isPidAlive)) throw new Error("Worker still running; cleanup retained");
+      },
+      live: (id) => [...pidToTrackedSession.values()].some((s) => s.happySessionId === id && isPidAlive(s.pid)),
+      log: (message) => logger.debug(`[DAEMON RUN] ${message}`)
+    });
+    void apiMachine.updateMachineMetadata((current) => ({
+      ...current ?? initialMachineMetadata,
+      teamsVersion: 1
+    })).catch(() => logger.debug("[DAEMON RUN] Teams capability publication will retry on reconnect"));
+    const cleanupAndShutdown = async (source, errorMessage) => {
+      logger.debug(`[DAEMON RUN] Starting proper cleanup (source: ${source}, errorMessage: ${errorMessage})...`);
+      teamWorker?.stop();
+      if (restartOnStaleVersionAndHeartbeat) {
+        clearInterval(restartOnStaleVersionAndHeartbeat);
+        logger.debug("[DAEMON RUN] Health check interval cleared");
+      }
+      clearInterval(cliUpdateInterval);
+      await apiMachine.updateDaemonState((state) => ({
+        ...state,
+        status: "shutting-down",
+        shutdownRequestedAt: Date.now(),
+        shutdownSource: source
+      }));
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      try {
+        await mirrorManager.shutdown();
+      } catch (error) {
+        logger.debug("[DAEMON RUN] Mirror shutdown failed:", error);
+      }
+      apiMachine.shutdown();
+      await stopControlServer();
+      await cleanupDaemonState();
+      await stopCaffeinate();
+      await releaseDaemonLock(daemonLockHandle);
+      logger.debug("[DAEMON RUN] Cleanup completed, exiting process");
+      process.exit(0);
+    };
+    logger.debug("[DAEMON RUN] Daemon started successfully, waiting for shutdown request");
+    const shutdownRequest = await resolvesWhenShutdownRequested;
+    await cleanupAndShutdown(shutdownRequest.source, shutdownRequest.errorMessage);
+  } catch (error) {
+    logger.debug("[DAEMON RUN][FATAL] Failed somewhere unexpectedly - exiting with code 1", error);
+    process.exit(1);
+  }
 }
 
 const PERSONAL_MEMORY_SOFT_LIMIT_CHARS = 2e3;
@@ -11019,11 +11333,12 @@ function checkPreviewPath(input, opts) {
   return { resolved, deniedReason: null };
 }
 
-function createMcpServer(handlers, options) {
+function createMcpServer(handlers, options, sessionId) {
   const mcp = new McpServer({
     name: "Very Happy Tools",
     version: "1.0.0"
   });
+  registerTeamsTools(mcp, sessionId);
   mcp.registerTool("change_title", {
     description: "Change the title of the current chat session",
     title: "Change Chat Title",
@@ -11125,7 +11440,7 @@ function createMcpServer(handlers, options) {
       isError: false
     };
   });
-  if (options?.assistant) {
+  if (options?.assistant && !process.env.VH_TEAM_SCOPE_FILE) {
     registerAssistantTools(mcp);
   }
   return mcp;
@@ -11203,7 +11518,7 @@ async function startHappyServer(client, options) {
     }
   };
   const server = createServer(async (req, res) => {
-    const mcp = createMcpServer(handlers, options);
+    const mcp = createMcpServer(handlers, options, client.sessionId);
     try {
       const transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: void 0
@@ -11236,7 +11551,8 @@ async function startHappyServer(client, options) {
       CLIPBOARD_TOOL_NAME,
       PREVIEW_TOOL_NAME,
       REPORT_PROGRESS_TOOL_NAME,
-      ...options?.assistant ? ASSISTANT_TOOL_NAMES : []
+      ...TEAM_TOOL_NAMES,
+      ...options?.assistant && !process.env.VH_TEAM_SCOPE_FILE ? ASSISTANT_TOOL_NAMES : []
     ],
     stop: () => {
       logger.debug(`[happyMCP] server:stop sessionId=${client.sessionId}`);
@@ -11496,7 +11812,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-vyYHKKk6.mjs');
+    const { query } = await import('./index-D-BgvQi5.mjs');
     return runSideQuestion(query, input);
   });
   const slots = /* @__PURE__ */ new Map();
@@ -12054,6 +12370,7 @@ async function runClaude(credentials, options = {}) {
     lifecycleState: "running",
     lifecycleStateSince: Date.now(),
     flavor: "claude",
+    ...process.env.VH_TEAM_OPERATION_ID ? { teamOperationId: process.env.VH_TEAM_OPERATION_ID } : {},
     // Advertise composer support before the first SDK response. Otherwise
     // a brand-new session cannot pick a PDF until after sending once.
     attachmentKinds: [...CLAUDE_ATTACHMENT_KINDS],
@@ -13306,7 +13623,7 @@ async function authenticateClaude() {
   }
 }
 
-const execAsync = promisify(exec);
+const execAsync = promisify$1(exec$1);
 const CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com";
 const CLIENT_SECRET = "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";
 const AUTHORIZE_URL = "https://accounts.google.com/o/oauth2/v2/auth";
@@ -15643,6 +15960,7 @@ async function runCodex(opts) {
   const forkedFromMessageId = process.env.HAPPY_FORKED_FROM_MESSAGE_ID;
   const { state, metadata } = createSessionMetadata({
     flavor: "codex",
+    ...process.env.VH_TEAM_OPERATION_ID ? { teamOperationId: process.env.VH_TEAM_OPERATION_ID } : {},
     machineId,
     startedBy: opts.startedBy,
     sandbox: sandboxConfig,
@@ -16089,7 +16407,7 @@ async function runCodex(opts) {
     }
   });
   const happyServer = await startHappyServer(session);
-  const bridgeEntrypoint = join(projectPath(), "bin", "happy-mcp.mjs");
+  const bridgeEntrypoint = join(projectPath(), "bin", "very-happy-mcp.mjs");
   const mcpServers = {
     happy: {
       command: process.execPath,
@@ -16447,7 +16765,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-DqUPkh0l.mjs');
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-Z1Jb6yjb.mjs');
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -16464,7 +16782,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-D2egvPgO.mjs');
+      const { handleSpawnCommand } = await import('./spawn-j9KBfj4e.mjs');
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -16476,7 +16794,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-DemgtCkr.mjs');
+      const { handleSessionsCommand } = await import('./sessions-Ba2oRTmw.mjs');
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -16488,7 +16806,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-CT22-8Tp.mjs');
+      const { handleSendCommand } = await import('./send-BevgS1mf.mjs');
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -16594,9 +16912,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-alG86PDN.mjs');
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./types-BqW7nEN_.mjs').then(function (n) { return n.av; });
-        const { ApiClient: ApiClient2 } = await import('./types-BqW7nEN_.mjs').then(function (n) { return n.aw; });
+        const { saveGoogleCloudProjectToConfig } = await import('./config-CZNIz3W0.mjs');
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./limits-FjbPJPsF.mjs').then(function (n) { return n.W; });
+        const { ApiClient: ApiClient2 } = await import('./types-DLDkfrTC.mjs').then(function (n) { return n.X; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -16627,7 +16945,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-alG86PDN.mjs');
+        const { readGeminiLocalConfig } = await import('./config-CZNIz3W0.mjs');
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -16667,7 +16985,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await import('./runGemini-BQa2eF3i.mjs');
+      const { runGemini } = await import('./runGemini-Bu49s_bN.mjs');
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -16697,7 +17015,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       }
     };
     try {
-      const { runAcp, resolveAcpAgentConfig } = await import('./index-Cg3Vfc00.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-Jrk6ud3g.mjs');
       const parsed = parsePiRunnerArgs(args.slice(1));
       const resolved = resolveAcpAgentConfig(["pi", ...parsed.passthrough]);
       const { credentials } = await authAndSetupMachineIfNeeded();
@@ -16724,7 +17042,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "acp") {
     try {
-      const { runAcp, resolveAcpAgentConfig } = await import('./index-Cg3Vfc00.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-Jrk6ud3g.mjs');
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -16764,7 +17082,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-362eg04u.mjs');
+      const { runOpenClaw } = await import('./runOpenClaw-CznAYPCh.mjs');
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -16813,9 +17131,18 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(1);
     }
     return;
+  } else if (subcommand === "teams") {
+    try {
+      const { handleTeamsCommand } = await import('./teams-C0ggJTJ-.mjs');
+      await handleTeamsCommand(args.slice(1));
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : "Teams command failed");
+      process.exitCode = 1;
+    }
+    return;
   } else if (subcommand === "mcp" && args.length === 1) {
     try {
-      const { handleMcpCommand } = await import('./mcp-DZIdcsJp.mjs');
+      const { handleMcpCommand } = await import('./mcp-zqPJ94Bk.mjs');
       await handleMcpCommand();
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}
@@ -17176,4 +17503,4 @@ ${chalk.bold("Examples:")}
   }
 }
 
-export { ALLOWED_SPAWN_PERMISSION_MODES as A, startHappyServer as B, registerKillSessionHandler as C, DEFAULT_RECENT_LIMIT as D, BasePermissionHandler as E, writeSessionModeFile as F, GEMINI_MODEL_ENV as G, normalizeAcpPermissionMode as H, removeSessionModeFile as I, GEMINI_API_KEY_ENV as J, GOOGLE_API_KEY_ENV as K, BaseReasoningProcessor as L, MAX_READ_LIMIT as M, MessageBuffer as N, CHANGE_TITLE_INSTRUCTION as O, 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, StreamRelay as x, MessageQueue2 as y, hashObject as z };
+export { ALLOWED_SPAWN_PERMISSION_MODES as A, hashObject as B, startHappyServer as C, DEFAULT_RECENT_LIMIT as D, BasePermissionHandler as E, writeSessionModeFile as F, GEMINI_MODEL_ENV as G, normalizeAcpPermissionMode as H, removeSessionModeFile as I, GEMINI_API_KEY_ENV as J, GOOGLE_API_KEY_ENV as K, BaseReasoningProcessor as L, MAX_READ_LIMIT as M, MessageBuffer as N, CHANGE_TITLE_INSTRUCTION as O, 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, registerKillSessionHandler as y, StreamRelay as z };