very-happy-cli 0.2.177 → 0.2.179

package/dist/{run-DX4Zs3Ug.mjs → run-BM4TxiyN.mjs}

@@ -1,83 +1,86 @@
-import { i as isClaudeSessionId, g as extractCompleteLines, h as decideBackfill, j as parseTerminalHookPayload, k as decideMirrorBinding, M as MIRROR_BACKFILL_LINES_DEFAULT, m as mirrorLineKey, n as mirrorLocalId, o as initializeOwnedWorktree, e as summarizeSpawnSessionForLog, q as startAgentVersionChecks, W as WORKTREE_CAPABILITY_VERSION, t as currentWorktreeService } from './mirrorProtocol-Bz8tEabR.mjs';
-import { P as PI_ADAPTER_INSTALL_HINT, s as sanitizeSpawnModel } from './piRunnerArgs-BpHc-JZl.mjs';
+import { i as isClaudeSessionId, g as extractCompleteLines, h as decideBackfill, j as parseTerminalHookPayload, k as decideMirrorBinding, M as MIRROR_BACKFILL_LINES_DEFAULT, m as mirrorLineKey, n as mirrorLocalId, o as initializeOwnedWorktree, e as summarizeSpawnSessionForLog, q as startAgentVersionChecks, W as WORKTREE_CAPABILITY_VERSION, t as currentWorktreeService } from './mirrorProtocol-BwYibqry.mjs';
+import { P as PI_ADAPTER_INSTALL_HINT, s as sanitizeSpawnModel } from './piRunnerArgs-DwvM_yWA.mjs';
 import fs from 'fs/promises';
 import * as tmp from 'tmp';
 import axios from 'axios';
-import { T as TurnActivityTracker, A as ApiClient } from './api-CKBViqI3.mjs';
-import { S as SPAWN_AGENTS, i as isSpawnAgent, s as sanitizeSpawnPermissionMode, r as resolveSpawnPermissionMode, a as resolveFirstMessageMeta } from './spawnAgents-BjtmjBvP.mjs';
-import { l as logger } from './logger-13cBr_ew.mjs';
+import { T as TurnActivityTracker, A as ApiClient } from './api-CzwFpJQc.mjs';
+import { S as SPAWN_AGENTS, i as isSpawnAgent, s as sanitizeSpawnPermissionMode, r as resolveSpawnPermissionMode, a as resolveFirstMessageMeta, j as joinProject } from './spawnAgents-P006Hqio.mjs';
+import { l as logger } from './logger-BtVhHnD8.mjs';
 import { readdirSync, statSync, unlinkSync, realpathSync, mkdirSync, writeFileSync, accessSync, constants as constants$1, existsSync, readFileSync, openSync, fsyncSync, closeSync, renameSync } from 'node:fs';
 import { join, isAbsolute, resolve, dirname, sep, basename, delimiter } from 'node:path';
-import { p as pruneStaleCompileCaches } from './index-CEm0MYiS.mjs';
-import { a as authAndSetupMachineIfNeeded } from './auth-BmESeKuM.mjs';
-import { c as configuration, f as ensurePrivateDirectorySync, w as writePrivateFileSync } from './configuration-D55F0t16.mjs';
+import { p as pruneStaleCompileCaches } from './index-D3bidoG8.mjs';
+import { a as authAndSetupMachineIfNeeded } from './auth-BS6PaOOG.mjs';
+import { c as configuration, f as ensurePrivateDirectorySync, w as writePrivateFileSync } from './configuration-WMi4idBB.mjs';
 import { spawn, execSync } from 'child_process';
-import { p as packageJson } from './package-CjlsAaRe.mjs';
-import { g as globalPrefixForPackage, a as getEnvironmentInfo } from './doctor-B9c2C9dF.mjs';
-import { s as spawnHappyCLI } from './spawnHappyCLI-B_0RWxD4.mjs';
-import { b as readPersistedSessions, r as readSettings, l as latchKeepAwake, q as reportSignature, s as decideDaemonHibernation, t as nextCheckDelay, v as persistSession, d as readDaemonState, x as acquireDaemonLock, a as resolveCheckMs, y as resolveIdleMs, z as deletePersistedSessions, A as writeDaemonState, B as writeSettings, C as settingIdleMs, u as updateSettings, D as releaseDaemonLock } from './persistence-C_tYtOqK.mjs';
-import { i as isDaemonRunningCurrentlyInstalledHappyVersion, b as stopDaemon, o as cleanupDaemonState } from './controlClient-C4xB5J6O.mjs';
-import { e as sendUserMessage, f as readSessionMetadata, r as readSessionTranscript, l as listAccountSessions, a as listSessions, M as MAX_READ_LIMIT, s as sessionWebUrl, g as waitForSessionKey, d as archiveSession, j as analyzeLatestTurn, k as readSessionLog, m as TURN_WINDOW, n as userPromptText } from './sessionOps-CdgbEJgf.mjs';
+import { p as packageJson } from './package-BPPebGQF.mjs';
+import { g as globalPrefixForPackage, a as getEnvironmentInfo } from './doctor-CmtSsR2-.mjs';
+import { s as spawnHappyCLI } from './spawnHappyCLI-CCOrEtf9.mjs';
+import { c as readPersistedSessions, r as readSettings, l as latchKeepAwake, q as reportSignature, s as decideDaemonHibernation, t as nextCheckDelay, v as persistSession, d as readDaemonState, x as acquireDaemonLock, a as resolveCheckMs, y as resolveIdleMs, z as deletePersistedSessions, A as writeDaemonState, B as writeSettings, C as settingIdleMs, u as updateSettings, D as rewriteCredentialsForRelay, g as readCredentials, E as releaseDaemonLock } from './persistence-Cr-wutZ4.mjs';
+import { i as isDaemonRunningCurrentlyInstalledHappyVersion, b as stopDaemon, o as cleanupDaemonState } from './controlClient-BWUJrj3t.mjs';
+import { e as sendUserMessage, f as readSessionMetadata, r as readSessionTranscript, l as listAccountSessions, a as listSessions, M as MAX_READ_LIMIT, s as sessionWebUrl, g as waitForSessionKey, d as archiveSession, j as analyzeLatestTurn, k as readSessionLog, m as TURN_WINDOW, n as userPromptText } from './sessionOps-BIGgRube.mjs';
 import fastify from 'fastify';
 import { z } from 'zod';
 import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
-import { d as decodeBase64, e as encodeBase64, h as decrypt } from './authRelay-DSAvg1uv.mjs';
+import { d as decodeBase64, s as sameRelay, e as encodeBase64, h as decrypt } from './authRelay-DhQhkBvX.mjs';
 import { randomBytes, createHash, timingSafeEqual, randomUUID } from 'node:crypto';
 import { c as checkPreviewPath } from './previewPath-CXN4Vag0.mjs';
 import { a as BACKGROUND_TASKS_MAX, c as BACKGROUND_TASK_DESCRIPTION_MAX, d as BackgroundTaskTracker } from './backgroundTaskActivity-BVwJBl02.mjs';
-import { b as sanitizeRateLimitReport } from './rateLimitWindows-DYHDGuzQ.mjs';
-import { f as formatEditConflictNotice, b as SESSION_PEER_SENT_FROM, s as sendPeerMessage, l as listPeerSessions, C as CLI_PEER_SENDER_ID } from './peerTools-CxmrKnfV.mjs';
+import { b as sanitizeRateLimitReport } from './rateLimitWindows-CuEqk_0g.mjs';
+import { f as formatEditConflictNotice, b as SESSION_PEER_SENT_FROM, s as sendPeerMessage, l as listPeerSessions, C as CLI_PEER_SENDER_ID } from './peerTools-CWKzcQ7u.mjs';
 import os, { hostname, homedir, userInfo, tmpdir } from 'node:os';
-import { c as RemoteCallBudget, e as REMOTE_WRITE_CALLS_PER_MINUTE, d as deliverToSession, g as guardRemoteSessionOpsRequest, h as remoteError, i as REMOTE_OP_DEADLINE_MS, j as formatRemoteAuditLine, k as REMOTE_SEND_COMMIT_DEADLINE_MS, m as REMOTE_RESUME_WAIT_MS, n as capRemoteTranscript, o as capRemoteText, p as REMOTE_ANSWER_MAX_BYTES, q as REMOTE_TITLE_MAX_BYTES } from './remoteSessionClient-D01Hso2-.mjs';
-import { assistantHome, bootstrapAssistantHome } from './bootstrap-C0s2bPFQ.mjs';
-import { refreshAgentHomes, locateClaudeConversation, agentHomeSpawnEnv } from './index-Dhl6_bw7.mjs';
+import { c as RemoteCallBudget, e as REMOTE_WRITE_CALLS_PER_MINUTE, d as deliverToSession, g as guardRemoteSessionOpsRequest, h as remoteError, i as REMOTE_OP_DEADLINE_MS, j as formatRemoteAuditLine, k as REMOTE_SEND_COMMIT_DEADLINE_MS, m as REMOTE_RESUME_WAIT_MS, n as capRemoteTranscript, o as capRemoteText, p as REMOTE_ANSWER_MAX_BYTES, q as REMOTE_TITLE_MAX_BYTES } from './remoteSessionClient-Bn2qu5C5.mjs';
+import { assistantHome, bootstrapAssistantHome } from './bootstrap-iuyufnp3.mjs';
+import { refreshAgentHomes, locateClaudeConversation, agentHomeSpawnEnv } from './index-CdQI0C9p.mjs';
 import { existsSync as existsSync$1, statSync as statSync$1, mkdtempSync, rmSync } from 'fs';
 import { join as join$1 } from 'path';
 import { spawn as spawn$1, execFile, spawnSync } from 'node:child_process';
 import { p as projectPath } from './projectPath-BTBIMB57.mjs';
 import { d as daemonEndpointsMatch, r as resolveClaudeCredentialReadiness } from './doctorReadiness-C208SMN9.mjs';
-import { g as getInitialMachineMetadata, a as getStartupCliAvailability } from './machineMetadata-dMida2qq.mjs';
-import { buildResumeLaunch } from './handleResumeCommand-DHddBkNJ.mjs';
+import { g as getInitialMachineMetadata, a as getStartupCliAvailability } from './machineMetadata-D-g--oU_.mjs';
+import { buildResumeLaunch } from './handleResumeCommand-C8thKjqf.mjs';
+import { n as normalizeWebPanels } from './webPanels-B2_C2-3g.mjs';
+import { w as ServerMigrateNoticeSchema, x as AUTOMATION_SUMMARY_MAX_CHARS, y as AUTOMATION_PRECHECK_OUTPUT_MAX_CHARS, z as AUTOMATION_PRECHECK_DEFAULT_TIMEOUT_MS, b as AUTOMATION_PRECHECK_MAX_TIMEOUT_MS, D as AUTOMATION_CLAIM_MAX_RUNS, E as AUTOMATION_DAEMON_CAPABILITY_PRECHECK, F as AUTOMATION_DEFAULT_LEASE_MS, i as isAutomationRunTerminal } from './index-DPOa4NhL.mjs';
 import { access, symlink, readFile, rm, unlink, readlink, lstat, constants, stat, open } from 'node:fs/promises';
 import { p as parseExactVersion, c as compareExactVersions, f as fetchCliUpdateState, r as resolveCliUpdateCheckInterval, D as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS } from './cliUpdate-Y34VGe9Y.mjs';
-import { c as createAutomationsClient, i as isAutomationsUnavailable, d as AutomationsRequestError } from './client-DG5ndWLw.mjs';
+import { P as ProjectsUnsupportedError, c as createProjectsClient } from './client-BhoEBnuN.mjs';
+import { c as createAutomationsClient, i as isAutomationsUnavailable, d as AutomationsRequestError } from './client-wo9nbxuf.mjs';
 import { createRequire } from 'node:module';
 import { g as getProjectPath } from './path-D2wdaNSk.mjs';
 import { b as extractClaudeEditPaths } from './editPaths-BVfS_FFL.mjs';
-import { s as startFileWatcher } from './startFileWatcher-UQyTSRAP.mjs';
-import { I as InvalidateSync } from './sync-C3p7-KLn.mjs';
+import { s as startFileWatcher } from './startFileWatcher-DghDOCO4.mjs';
+import { I as InvalidateSync } from './sync-CSe0Rf45.mjs';
 import { R as RawJSONLinesSchema } from './types-CkqAACXx.mjs';
 import { t as tmuxArgs, a as scrubTmuxClientEnv, s as shellescape } from './tmuxSocket-B8Yx20sT.mjs';
-import { p as processIdentityFields, r as readSessionLock, t as terminateProcess } from './sessionLock-ZfvFVdUi.mjs';
+import { p as processIdentityFields, r as readSessionLock, t as terminateProcess, d as terminateProcessTree } from './sessionLock-WYIyaVO4.mjs';
 import { findAllHappyProcesses } from './doctor-BPkYWSuq.mjs';
-import { T as TEAM_SKILL } from './resources-BdFBQi8r.mjs';
+import { T as TEAM_SKILL } from './resources-y9jfyO-_.mjs';
 import { promisify } from 'node:util';
-import { u as AUTOMATION_SUMMARY_MAX_CHARS, v as AUTOMATION_PRECHECK_OUTPUT_MAX_CHARS, w as AUTOMATION_PRECHECK_DEFAULT_TIMEOUT_MS, a as AUTOMATION_PRECHECK_MAX_TIMEOUT_MS, x as AUTOMATION_CLAIM_MAX_RUNS, y as AUTOMATION_DAEMON_CAPABILITY_PRECHECK, z as AUTOMATION_DEFAULT_LEASE_MS, i as isAutomationRunTerminal } from './index-DMy3OCBe.mjs';
 import { c as clipText, r as renderAction, b as renderTemplate } from './template-CiOPa2rd.mjs';
 import { d as detectDaemonSupervisor } from './daemonSupervisor-C6urv3_8.mjs';
 import { d as describeAgentHome } from './loginShellEnv-Dw8M7tkI.mjs';
-import './sessionModeFile-CWVq8AT9.mjs';
-import './lidState-BqVsw7H1.mjs';
+import './acpSessionResume-DTGmAPLt.mjs';
+import './lidState-Bb8fgXg3.mjs';
 import 'os';
 import 'node:events';
 import 'socket.io-client';
-import './attachmentLimits-Di1Z93lN.mjs';
+import './pushNotifications-BdFjDjQe.mjs';
+import './contentLogMetadata-BlWI0egu.mjs';
 import './limits-DIo7rEBR.mjs';
-import './time-yEL6wHUF.mjs';
-import './registerCommonHandlers-D8OMpBbQ.mjs';
+import './time-65DcU6Jx.mjs';
+import './registerCommonHandlers-BAlP7SGc.mjs';
 import 'util';
 import 'crypto';
 import 'cross-spawn';
 import '@paralleldrive/cuid2';
-import './contentLogMetadata-BlWI0egu.mjs';
 import 'chalk';
 import 'tweetnacl';
-import './browser-BlLWZUMx.mjs';
+import './browser-CSYum7xH.mjs';
 import 'open';
 import './ids-DU6sLx4C.mjs';
 import 'url';
 import './detectCLI-CSGMlV51.mjs';
-import './localHappyAgentAuth-Ce8kO2yc.mjs';
+import './localHappyAgentAuth-NEU7fax7.mjs';
+import './processTreeSnapshot-CuLJDNC-.mjs';
 import 'ps-list';
 
 async function resolveRelaunchMetadata(snapshot, fetchServer) {
@@ -165,7 +168,7 @@ function startCaffeinate() {
   }
   killOrphanedCaffeinateProcesses();
   try {
-    caffeinateProcess = spawn("caffeinate", ["-im"], {
+    caffeinateProcess = spawn("caffeinate", caffeinateArgs(process.pid), {
       stdio: "ignore",
       detached: false
     });
@@ -232,12 +235,36 @@ function setupCleanupHandlers() {
     cleanup();
   });
 }
+function caffeinateArgs(daemonPid) {
+  return ["-im", "-w", String(daemonPid)];
+}
+function orphanedLegacyCaffeinatePids(psOutput) {
+  const pids = [];
+  for (const line of psOutput.split("\n")) {
+    const m = /^\s*(\d+)\s+(\d+)\s+(.*?)\s*$/.exec(line);
+    if (!m) continue;
+    const [, pid, ppid, command] = m;
+    if (ppid !== "1") continue;
+    if (!/^(?:\/usr\/bin\/)?caffeinate -im$/.test(command)) continue;
+    pids.push(Number(pid));
+  }
+  return pids;
+}
 function killOrphanedCaffeinateProcesses() {
   if (process.platform !== "darwin") return;
+  let ps;
   try {
-    execSync('pkill -f "caffeinate -im"', { timeout: 5e3, stdio: "ignore" });
-    logger.debug("[caffeinate] Killed orphaned caffeinate processes");
-  } catch {
+    ps = execSync("ps -A -o pid=,ppid=,command=", { timeout: 5e3, encoding: "utf8" });
+  } catch (error) {
+    logger.debug("[caffeinate] Could not list processes; skipping orphan cleanup:", error);
+    return;
+  }
+  for (const pid of orphanedLegacyCaffeinatePids(ps)) {
+    try {
+      process.kill(pid, "SIGTERM");
+      logger.debug(`[caffeinate] Killed orphaned legacy caffeinate PID ${pid}`);
+    } catch {
+    }
   }
 }
 
@@ -347,6 +374,12 @@ function formatAssistantReportMessage(title, sessionId, event) {
 
 function resumePrecheck(metadata, fs) {
   const flavor = metadata.flavor ?? "claude";
+  if (flavor === "acp" && metadata.piSessionId) {
+    if (!metadata.path || !fs.cwdExists(metadata.path)) {
+      return { ok: false, reason: "missing-cwd", detail: `working directory ${metadata.path ?? "(none)"} does not exist` };
+    }
+    return { ok: true };
+  }
   if (flavor !== "claude" && flavor !== "codex") {
     return { ok: false, reason: "unsupported-flavor", detail: `flavor "${flavor}" cannot be resumed` };
   }
@@ -2030,6 +2063,89 @@ function spawnAgentUnavailableError(agent, availability) {
   return null;
 }
 
+function startWebPanelsSync(deps) {
+  let lastMtime;
+  let lastProblems = "";
+  let stopped = false;
+  let inflight = null;
+  const run = async () => {
+    try {
+      const mtime = await deps.statMtime();
+      if (mtime === lastMtime) return;
+      lastMtime = mtime;
+      const { panels, problems } = normalizeWebPanels(mtime === null ? void 0 : await deps.readRaw());
+      const key = JSON.stringify(problems);
+      if (problems.length > 0 && key !== lastProblems) deps.logProblems(problems);
+      lastProblems = key;
+      await deps.publish(panels);
+    } catch {
+      lastMtime = void 0;
+    }
+  };
+  const tick = () => {
+    if (stopped) return Promise.resolve();
+    inflight ??= run().finally(() => {
+      inflight = null;
+    });
+    return inflight;
+  };
+  void tick();
+  const timer = setInterval(() => {
+    void tick();
+  }, deps.intervalMs ?? 2e3);
+  timer.unref?.();
+  return { stop: () => {
+    stopped = true;
+    clearInterval(timer);
+  }, tick };
+}
+
+function isAcceptableRelayUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const loopback = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]";
+    return parsed.protocol === "https:" || parsed.protocol === "http:" && loopback;
+  } catch {
+    return false;
+  }
+}
+async function applyServerMigration(raw, deps) {
+  const parsed = ServerMigrateNoticeSchema.safeParse(raw);
+  if (!parsed.success) return { action: "ignored", reason: "malformed notice" };
+  const notice = parsed.data;
+  if (sameRelay(notice.url, deps.configuredServerUrl)) return { action: "ignored", reason: "already on that relay" };
+  if (!isAcceptableRelayUrl(notice.url) || !isAcceptableRelayUrl(notice.webappUrl)) {
+    return refuse(deps, `relay URL must be https: ${notice.url}`);
+  }
+  if (deps.env.HAPPY_SERVER_URL?.trim()) {
+    return refuse(deps, `HAPPY_SERVER_URL is set in this daemon's environment; unset it (or point it at ${notice.url}) and restart the daemon`);
+  }
+  const credentials = await deps.readCredentials();
+  if (!credentials) return refuse(deps, "no credentials on disk");
+  let token;
+  try {
+    const response = await deps.fetch(`${notice.url}/v1/auth/migrate/complete`, {
+      method: "POST",
+      headers: { "content-type": "application/json", "X-Happy-Client": deps.clientId },
+      body: JSON.stringify({ handoff: notice.handoff })
+    });
+    if (!response.ok) return refuse(deps, `${notice.url} refused the handoff (HTTP ${response.status})`);
+    const body = await response.json();
+    if (body.kind !== "daemon" || typeof body.token !== "string" || !body.token) return refuse(deps, `${notice.url} answered without a daemon token`);
+    token = body.token;
+  } catch (error) {
+    return refuse(deps, `${notice.url} unreachable: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  await deps.updateSettings((current) => ({ ...current, serverUrl: notice.url, webappUrl: notice.webappUrl }));
+  await deps.rewriteCredentials(credentials, { token, authServerUrl: notice.url });
+  deps.log(`[RELAY MOVE] Moved this machine from ${deps.configuredServerUrl} to ${notice.url}; handing over to a new daemon`);
+  return { action: "moved", serverUrl: notice.url, webappUrl: notice.webappUrl };
+}
+function refuse(deps, reason) {
+  deps.log(`[RELAY MOVE] Not moving this machine: ${reason}`);
+  return { action: "refused", reason };
+}
+
 function str(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
@@ -2439,6 +2555,44 @@ function createUpdateController(deps) {
   return { refresh, retry, request, tick, withHandover, holdHandover, isRunning: () => running };
 }
 
+function buildPresenceBatch(live, previous) {
+  const current = new Set(live.map((s) => s.sessionId));
+  const sessions = live.slice(0, 200).map((s) => ({
+    sessionId: s.sessionId,
+    state: s.running ? "running" : "idle",
+    ...s.flavor ? { agent: s.flavor } : {},
+    ...s.branch ? { branch: s.branch.slice(0, 200) } : {}
+  }));
+  const gone = [...previous].filter((id) => !current.has(id)).slice(0, 200);
+  return { sessions, gone, current };
+}
+function createProjectPresenceReporter(deps) {
+  let previous = /* @__PURE__ */ new Set();
+  let running = false;
+  async function tick() {
+    if (running || deps.client.isDisabled()) return;
+    running = true;
+    try {
+      const batch = buildPresenceBatch(deps.live(), previous);
+      if (batch.sessions.length === 0 && batch.gone.length === 0) {
+        previous = batch.current;
+        return;
+      }
+      await deps.client.presence(deps.machineId, batch.sessions, batch.gone);
+      previous = batch.current;
+    } catch (error) {
+      if (!(error instanceof ProjectsUnsupportedError)) deps.log(`project presence tick failed: ${String(error)}`);
+    } finally {
+      running = false;
+    }
+  }
+  const timer = setInterval(() => {
+    void tick();
+  }, deps.intervalMs ?? 6e4);
+  timer.unref?.();
+  return { tick, stop: () => clearInterval(timer) };
+}
+
 const AUTOMATION_BINDINGS_TTL_MS = 10 * 60 * 1e3;
 const HIBERNATION_IN_FLIGHT_MS = 6e4;
 const HIBERNATION_EXIT_WAIT_MS = 15e3;
@@ -4505,6 +4659,7 @@ ${action.prompt}`, { localId: `automation-${run.id}` });
     }
     persist({ runId: run.id, automationId: automation.id, kind: "spawn", phase: "running", claimId: run.claimId, sessionId: spawned.sessionId, stickyKey, ...action.worktree ? { directory } : {} });
     const item = track(claimed, "spawn", spawned.sessionId);
+    if (automation.projectId && deps.joinProject) await deps.joinProject(spawned.sessionId, automation.projectId).catch(() => void 0);
     try {
       const capabilities = readPersistedSessions()[spawned.sessionId]?.metadata?.capabilities ?? null;
       const meta = resolveFirstMessageMeta({ agent, permissionMode, explicitModel: action.model ?? void 0, capabilities });
@@ -4865,6 +5020,7 @@ async function startDaemon() {
     const sessionIdToFinishedSession = /* @__PURE__ */ new Map();
     let teamWorker;
     let automationRunner;
+    let projectPresence;
     const persisted = readPersistedSessions();
     const liveHappyProcesses = await findAllHappyProcesses();
     for (const [id, s] of Object.entries(persisted)) {
@@ -4954,6 +5110,7 @@ async function startDaemon() {
       }
     };
     const assistantSpawnGate = createSpawnGate();
+    const projectsClient = createProjectsClient({ token: async () => credentials.token });
     const spawnSession = async (options) => {
       const timer = createSpawnTimer();
       await refreshAgentHomes(Date.now(), { allowStale: true });
@@ -4965,6 +5122,10 @@ async function startDaemon() {
         result = await (options.forceNew ? assistantSpawnGate.replace(() => spawnSessionImpl(options, timer)) : assistantSpawnGate.join(() => spawnSessionImpl(options, timer)));
       }
       logger.debug(timer.format({ agent: options.agent ?? "claude", outcome: result.type }));
+      if (result.type === "success" && options.parentSessionId) {
+        const outcome = await joinProject(projectsClient, result.sessionId, { kind: "lineage", parentSessionId: options.parentSessionId });
+        if (outcome.joined) logger.debug(`[DAEMON RUN] fork ${result.sessionId} joined project ${outcome.projectId} (lineage)`);
+      }
       return result;
     };
     const currentCliAvailability = () => apiMachineRef?.getCLIAvailability() ?? startupCliAvailability;
@@ -5595,7 +5756,7 @@ async function startDaemon() {
             resolve();
           }
         };
-        const requested = terminateProcess(pid, () => {
+        const requested = terminateProcessTree(pid, () => {
           const tracked = pidToTrackedSession.get(pid);
           if (tracked) {
             if (tracked.happySessionId && tracked.encryption) {
@@ -5711,7 +5872,7 @@ async function startDaemon() {
       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) => {
+          const requested = terminateProcessTree(pid, (stopped) => {
             if (!stopped) {
               logger.debug(`[DAEMON RUN] Session ${sessionId} survived SIGTERM and SIGKILL attempts`);
               return;
@@ -5974,6 +6135,12 @@ async function startDaemon() {
       daemonHibernation.invalidateBindings();
       return resolveIdleMs(agentHibernationSetting);
     });
+    const webPanelsSync = startWebPanelsSync({
+      statMtime: async () => (await fs.stat(configuration.settingsFile).catch(() => null))?.mtimeMs ?? null,
+      readRaw: async () => (await readSettings()).webPanels,
+      publish: (panels) => apiMachine.setWebPanels(panels),
+      logProblems: (problems) => logger.warn(`[DAEMON RUN] settings.json webPanels: skipped ${problems.length} entr${problems.length === 1 ? "y" : "ies"}: ${problems.map((p) => `#${p.index}${p.id ? ` (${p.id})` : ""} ${p.reason}`).join("; ")}`)
+    });
     apiMachine.connect();
     if (identityConflict?.confidence === "weak") {
       void apiMachine.updateMachineMetadata((current) => ({
@@ -6007,6 +6174,27 @@ async function startDaemon() {
     });
     apiMachine.setCliUpdateRetryHandler(updateController.retry);
     apiMachine.setCliUpdateRequestHandler(updateController.request);
+    let pendingRelayMove = null;
+    let relayMoveInFlight = null;
+    apiMachine.setServerMigrateHandler((notice) => {
+      if (relayMoveInFlight || pendingRelayMove) return;
+      relayMoveInFlight = applyServerMigration(notice, {
+        configuredServerUrl: configuration.serverUrl,
+        env: process.env,
+        clientId: `cli-daemon/${configuration.currentCliVersion}`,
+        fetch,
+        readCredentials,
+        rewriteCredentials: rewriteCredentialsForRelay,
+        updateSettings,
+        log: (message) => logger.warn(message)
+      }).then((outcome) => {
+        if (outcome.action === "moved") pendingRelayMove = { serverUrl: outcome.serverUrl };
+      }).catch((error) => {
+        logger.warn("[RELAY MOVE] Failed:", error);
+      }).finally(() => {
+        relayMoveInFlight = null;
+      });
+    });
     const refreshCliUpdate = () => updateController.refresh().catch((error) => {
       logger.debug("[DAEMON RUN] CLI update policy check failed:", error);
     });
@@ -6044,8 +6232,9 @@ async function startDaemon() {
             } catch {
             }
           }
-          if (bundleReplaced && !teamWorker?.busy && !automationRunner?.busy && !updateController.isRunning() && !turnActivity.hasActiveTurn() && !backgroundTasks.hasAny()) {
-            const preflight = await preflightNewBundle(bundlePath);
+          const relayMove = pendingRelayMove;
+          if ((bundleReplaced || relayMove) && !teamWorker?.busy && !automationRunner?.busy && !updateController.isRunning() && !turnActivity.hasActiveTurn() && !backgroundTasks.hasAny()) {
+            const preflight = bundleReplaced ? await preflightNewBundle(bundlePath) : { action: "proceed" };
             if (preflight.action === "hold") {
               if (lastHandoverHold !== preflight.reason) {
                 lastHandoverHold = preflight.reason;
@@ -6056,9 +6245,10 @@ async function startDaemon() {
             }
             if (teamWorker?.busy || automationRunner?.busy || updateController.isRunning() || turnActivity.hasActiveTurn() || backgroundTasks.hasAny()) return;
             lastHandoverHold = null;
-            logger.debug("[DAEMON RUN] Daemon bundle replaced on disk and verified, handing off to new daemon");
+            logger.debug(relayMove ? `[DAEMON RUN] Relay moved to ${relayMove.serverUrl}; handing off to a new daemon on the new settings` : "[DAEMON RUN] Daemon bundle replaced on disk and verified, handing off to new daemon");
             teamWorker?.stop();
             automationRunner?.stop();
+            projectPresence?.stop();
             clearInterval(restartOnStaleVersionAndHeartbeat);
             clearInterval(cliUpdateInterval);
             stopAgentVersionChecks();
@@ -6132,6 +6322,18 @@ async function startDaemon() {
         if (result.type !== "success") return false;
         return waitForSessionLive(id, (sid) => [...pidToTrackedSession.values()].some((s) => s.happySessionId === sid && isPidAlive(s.pid)));
       },
+      joinProject: (sessionId, projectId) => joinProject(projectsClient, sessionId, { kind: "explicit", projectId }, { via: "automation" }),
+      log: (message) => logger.debug(`[DAEMON RUN] ${message}`)
+    });
+    projectPresence = createProjectPresenceReporter({
+      machineId,
+      client: projectsClient,
+      live: () => [...pidToTrackedSession.values()].filter((s) => s.happySessionId && isPidAlive(s.pid)).map((s) => ({
+        sessionId: s.happySessionId,
+        flavor: s.happySessionMetadataFromLocalWebhook?.flavor ?? null,
+        branch: s.happySessionMetadataFromLocalWebhook?.worktree?.branch ?? null,
+        running: turnActivity.activeSessions().includes(s.happySessionId)
+      })),
       log: (message) => logger.debug(`[DAEMON RUN] ${message}`)
     });
     void apiMachine.updateMachineMetadata((current) => ({
@@ -6142,10 +6344,12 @@ async function startDaemon() {
       worktreeVersion: WORKTREE_CAPABILITY_VERSION
     })).catch(() => logger.debug("[DAEMON RUN] Teams capability publication will retry on reconnect"));
     const cleanupAndShutdown = async (source, errorMessage) => {
+      webPanelsSync.stop();
       logger.debug(`[DAEMON RUN] Starting proper cleanup (source: ${source}, errorMessage: ${errorMessage})...`);
       const scrollbackFlush = apiMachine.flushTerminalScrollback();
       teamWorker?.stop();
       automationRunner?.stop({ killScripts: true });
+      projectPresence?.stop();
       currentWorktreeService()?.stopAll();
       if (restartOnStaleVersionAndHeartbeat) {
         clearInterval(restartOnStaleVersionAndHeartbeat);