very-happy-cli 0.2.155 → 0.2.157

package/dist/{index-B4oXnbYw.mjs → index-BYU1e81k.mjs}

@@ -1,14 +1,14 @@
 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 os, { homedir, hostname, userInfo, tmpdir } from 'node:os';
 import { randomUUID, randomInt, randomBytes, createHash as createHash$1, timingSafeEqual } from 'node:crypto';
-import { g as getProjectPath, k as initializeSandbox, w as wrapCommand, j as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, l as AsyncLock, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, m as commandOnPath, n as deriveLocalCliUpdateSummary, o as isClaudeSessionId, q as getLocalHappyAgentCredentialPath, s as readLocalHappyAgentCredentials, t as parseExactVersion, u as compareExactVersions, v as extractCompleteLines, x as decideBackfill, y as parseTerminalHookPayload, z as tmuxArgs, B as scrubTmuxClientEnv, D as decideMirrorBinding, E as MIRROR_BACKFILL_LINES_DEFAULT, G as mirrorLineKey, H as mirrorLocalId, J as detectCLIAvailability, K as detectResumeSupport, L as refreshAgentHomes, d as describeAgentHome, T as TurnActivityTracker, N as summarizeSpawnSessionForLog, O as locateClaudeConversation, P as agentHomeSpawnEnv, Q as shellescape, A as ApiClient, S as fetchCliUpdateState, U as resolveCliUpdateCheckInterval, V as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, W as listVhTerminals, X as readVhTerminal, Y as sendToVhTerminal, Z as TITLE_PROMPT_PREFIX, _ as BOARD_ANALYZER_PROMPT_PREFIX, h as connectionState, $ as startOfflineReconnection, C as CodexAppServerClient } from './types-CkbfdRzq.mjs';
-import { l as logger, a7 as notifyDaemonSessionEvent, x as BUILTIN_TODO_DISCOVERY, g as delay, a8 as STREAM_DELTA_MAX_CHARS, a9 as ensurePrivateDirectory, aa as hardenPrivateFile, c as configuration, ab as notifyDaemonClaudeAuthFailed, F as packageJson, r as readSettings, ac as readCredentials, Z as credentialRelayProblem, k as checkIfDaemonRunningAndCleanupStaleState, ad as readDaemonState, ae as AGENT_VERSION_SOURCES, w as encodeBase64, af as readSettingsOutcome, u as updateSettings, ag as encodeBase64Url, M as decodeBase64, ah as writeCredentialsLegacy, ai as writeCredentialsDataKey, d as readPersistedSessions, E as writePrivateFileSync, aj as decryptWithDataKey, ak as decryptLegacy, al as persistSession, z as ensurePrivateDirectorySync, am as getAgentCodeDefaults, an as normalizeAgentKey, ao as isClaudeOpus55Model, ap as supportsClaudeOpus55, aq as AUTOMATION_SUMMARY_MAX_CHARS, ar as AUTOMATION_CLAIM_MAX_RUNS, as as AUTOMATION_DEFAULT_LEASE_MS, f as isAutomationRunTerminal, at as isDaemonRunningCurrentlyInstalledHappyVersion, au as stopDaemon, av as acquireDaemonLock, aw as deletePersistedSessions, N as decrypt, ax as writeDaemonState, ay as writeSettings, az as cleanupDaemonState, aA as releaseDaemonLock, i as isValidSessionId, m as spawnDaemonSession, a1 as isValidTerminalId, aB as ContextUsageSchema, C as CLIPBOARD_TOOL_NAME, a as CLIPBOARD_TOOL_TITLE, b as CLIPBOARD_TOOL_DESCRIPTION, o as CLIPBOARD_MAX_BYTES, v as notifyDaemonSessionStarted, y as reportSessionEditToDaemon, aC as clearCredentials, aD as clearMachineId, h as readCredentialsForConfiguredRelay, aE as SandboxConfigSchema, e as createEnvelope, O as listDaemonSessions, n as stopDaemonSession, aF as getLatestDaemonLog } from './limits-C_DW0M0q.mjs';
+import { g as getProjectPath, k as initializeSandbox, w as wrapCommand, j as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, l as AsyncLock, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, m as commandOnPath, n as deriveLocalCliUpdateSummary, o as isClaudeSessionId, q as getLocalHappyAgentCredentialPath, s as readLocalHappyAgentCredentials, t as parseExactVersion, u as compareExactVersions, v as extractCompleteLines, x as decideBackfill, y as parseTerminalHookPayload, z as tmuxArgs, B as scrubTmuxClientEnv, D as decideMirrorBinding, E as MIRROR_BACKFILL_LINES_DEFAULT, G as mirrorLineKey, H as mirrorLocalId, J as detectCLIAvailability, K as detectResumeSupport, L as refreshAgentHomes, d as describeAgentHome, T as TurnActivityTracker, N as summarizeSpawnSessionForLog, O as locateClaudeConversation, P as agentHomeSpawnEnv, Q as shellescape, A as ApiClient, S as fetchCliUpdateState, U as resolveCliUpdateCheckInterval, V as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, W as listVhTerminals, X as readVhTerminal, Y as sendToVhTerminal, Z as TITLE_PROMPT_PREFIX, _ as BOARD_ANALYZER_PROMPT_PREFIX, h as connectionState, $ as startOfflineReconnection, C as CodexAppServerClient } from './types-BrGJ7PJz.mjs';
+import { l as logger, aa as sameBackgroundTasks, ab as notifyDaemonSessionEvent, x as BUILTIN_TODO_DISCOVERY, g as delay, ac as STREAM_DELTA_MAX_CHARS, ad as ensurePrivateDirectory, ae as hardenPrivateFile, c as configuration, af as notifyDaemonClaudeAuthFailed, ag as createBackgroundTaskTracker, F as packageJson, r as readSettings, ah as readCredentials, a0 as credentialRelayProblem, k as checkIfDaemonRunningAndCleanupStaleState, ai as readDaemonState, aj as AGENT_VERSION_SOURCES, w as encodeBase64, ak as readSettingsOutcome, u as updateSettings, al as encodeBase64Url, M as decodeBase64, am as writeCredentialsLegacy, an as writeCredentialsDataKey, ao as BACKGROUND_TASK_DESCRIPTION_MAX, ap as BACKGROUND_TASKS_MAX, d as readPersistedSessions, E as writePrivateFileSync, aq as decryptWithDataKey, ar as decryptLegacy, as as persistSession, z as ensurePrivateDirectorySync, at as getAgentCodeDefaults, au as normalizeAgentKey, av as isClaudeOpus55Model, aw as supportsClaudeOpus55, ax as AUTOMATION_SUMMARY_MAX_CHARS, ay as AUTOMATION_CLAIM_MAX_RUNS, az as AUTOMATION_DEFAULT_LEASE_MS, f as isAutomationRunTerminal, aA as isDaemonRunningCurrentlyInstalledHappyVersion, aB as stopDaemon, aC as acquireDaemonLock, aD as BackgroundTaskTracker, aE as deletePersistedSessions, N as decrypt, aF as writeDaemonState, aG as writeSettings, aH as cleanupDaemonState, aI as releaseDaemonLock, i as isValidSessionId, m as spawnDaemonSession, a4 as isValidTerminalId, aJ as ContextUsageSchema, C as CLIPBOARD_TOOL_NAME, a as CLIPBOARD_TOOL_TITLE, b as CLIPBOARD_TOOL_DESCRIPTION, o as CLIPBOARD_MAX_BYTES, v as notifyDaemonSessionStarted, y as reportSessionEditToDaemon, aK as clearCredentials, aL as clearMachineId, h as readCredentialsForConfiguredRelay, aM as SandboxConfigSchema, e as createEnvelope, O as listDaemonSessions, n as stopDaemonSession, aN as getLatestDaemonLog } from './limits-A2c-3M-_.mjs';
 import spawn$1, { spawn } from 'cross-spawn';
 import path, { join, resolve, basename, delimiter, isAbsolute, dirname, sep, normalize } from 'node:path';
 import { createInterface } from 'node:readline';
 import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, realpathSync, unlinkSync, renameSync, writeFileSync, accessSync, constants as constants$1, openSync, fsyncSync, closeSync, rmSync as rmSync$1, chmodSync as chmodSync$1 } from 'node:fs';
 import { p as projectPath } from './terminalTitleSuggest-DKgX3osW.mjs';
-import { E as trimIdent, F as AGENT_GUIDANCE, G as formatEditConflictNotice, z as sendUserMessage, S as SESSION_PEER_SENT_FROM, x as readSessionMetadata, y as waitForSessionKey, k as archiveSession, H as createAutomationsClient, t as isAutomationsUnavailable, I as AutomationsRequestError, J as analyzeLatestTurn, K as readSessionLog$1, L as TURN_WINDOW, N as userPromptText, v as teamScopePath, O as TeamConnectionPreflightError, C as createTeamsClient, e as listSessions, h as readSessionTranscript, n as deliverToSession, o as sessionWebUrl, i as stopSession, P as PREVIEW_TOOL_NAME, R as REPORT_PROGRESS_TOOL_NAME, Q as TEAM_TOOL_NAMES, U as AUTOMATION_TOOL_NAMES, V as SESSION_PEER_TOOL_NAMES, r as registerTeamsTools, c as registerAutomationTools, d as registerSessionPeerTools, W as createSessionPeerToolExecutor, a as PREVIEW_TOOL_TITLE, b as PREVIEW_TOOL_DESCRIPTION, X as REPORT_PROGRESS_TOOL_TITLE, Y as REPORT_PROGRESS_TOOL_DESCRIPTION } from './agentGuidance-BWxFC6UL.mjs';
+import { K as trimIdent, L as AGENT_GUIDANCE, N as formatEditConflictNotice, H as sendUserMessage, S as SESSION_PEER_SENT_FROM, F as readSessionMetadata, R as RemoteCallBudget, O as REMOTE_WRITE_CALLS_PER_MINUTE, s as sendPeerMessage, j as listPeerSessions, u as deliverToSession, k as readSessionTranscript, l as listAccountSessions, g as listSessions, Q as guardRemoteSessionOpsRequest, U as remoteError, V as REMOTE_OP_DEADLINE_MS, W as formatRemoteAuditLine, X as REMOTE_SEND_COMMIT_DEADLINE_MS, Y as REMOTE_RESUME_WAIT_MS, Z as CLI_PEER_SENDER_ID, M as MAX_READ_LIMIT, _ as capRemoteTranscript, $ as capRemoteText, x as sessionWebUrl, a0 as REMOTE_ANSWER_MAX_BYTES, a1 as REMOTE_TITLE_MAX_BYTES, G as waitForSessionKey, q as archiveSession, a2 as createAutomationsClient, A as isAutomationsUnavailable, a3 as AutomationsRequestError, a4 as analyzeLatestTurn, a5 as readSessionLog$1, a6 as TURN_WINDOW, a7 as userPromptText, E as teamScopePath, a8 as TeamConnectionPreflightError, J as createTeamsClient, n as readRemoteTranscript, v as sendRemoteMessage, a9 as RemoteSessionOpsError, o as stopSession, P as PREVIEW_TOOL_NAME, aa as REPORT_PROGRESS_TOOL_NAME, ab as TEAM_TOOL_NAMES, ac as AUTOMATION_TOOL_NAMES, ad as SESSION_PEER_TOOL_NAMES, r as registerTeamsTools, c as registerAutomationTools, d as registerSessionPeerTools, ae as createSessionPeerToolExecutor, a as PREVIEW_TOOL_TITLE, b as PREVIEW_TOOL_DESCRIPTION, af as REPORT_PROGRESS_TOOL_TITLE, ag as REPORT_PROGRESS_TOOL_DESCRIPTION } from './agentGuidance-CU6YD_Ms.mjs';
 import { readFile, writeFile, rename, unlink, mkdir, access as access$1, symlink, rm, readlink, lstat, constants, 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';
@@ -115,6 +115,11 @@ class Session {
   sessionId;
   mode = "local";
   thinking = false;
+  /** B-507: background tasks still in flight (async sub-agents, backgrounded
+   *  commands, monitors) — published with every keepAlive. Always an array
+   *  for the Claude runner: an empty one says "nothing running", which is a
+   *  different statement from a runner that has no such notion (undefined). */
+  backgroundTasks = [];
   /**
    * Window after a user-initiated abort during which stray promise rejections
    * from tearing down the SDK query (MCP transports, in-flight tool calls,
@@ -176,11 +181,21 @@ class Session {
       logger.debug("[Session] Failed to create notification producer:", err);
       this.notificationProducer = null;
     }
-    this.client.keepAlive(this.thinking, this.mode);
+    this.client.keepAlive(this.thinking, this.mode, this.backgroundTasks);
     this.keepAliveInterval = setInterval(() => {
-      this.client.keepAlive(this.thinking, this.mode);
+      this.client.keepAlive(this.thinking, this.mode, this.backgroundTasks);
     }, 2e3);
   }
+  /**
+   * B-507: the tracker's current set (`claude/backgroundTasks.ts`). A change
+   * beats at once so the daemon, agentState and the web see the edge without
+   * waiting for the 2s tick; an unchanged set is left to the interval.
+   */
+  setBackgroundTasks = (tasks) => {
+    if (sameBackgroundTasks(this.backgroundTasks, tasks)) return;
+    this.backgroundTasks = tasks;
+    this.client.keepAlive(this.thinking, this.mode, this.backgroundTasks);
+  };
   /**
    * Cleanup resources (call when session is no longer needed)
    */
@@ -215,7 +230,7 @@ class Session {
       this.lastAssistantSnippet = void 0;
     }
     this.thinking = thinking;
-    this.client.keepAlive(thinking, this.mode);
+    this.client.keepAlive(thinking, this.mode, this.backgroundTasks);
   };
   /**
    * Record that Claude emitted an assistant text reply during this turn.
@@ -282,7 +297,7 @@ class Session {
   };
   onModeChange = (mode) => {
     this.mode = mode;
-    this.client.keepAlive(this.thinking, mode);
+    this.client.keepAlive(this.thinking, mode, this.backgroundTasks);
     this._onModeChange(mode);
   };
   onAbort = () => {
@@ -3926,6 +3941,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
   const turnSteering = createTurnSteeringController();
   const runtimeControls = createRuntimeControls(() => session.thinking);
   session.client.rpcHandlerManager.registerHandler("claude-runtime-control", async (input) => runtimeControls.request(input));
+  const backgroundTasks = createBackgroundTaskTracker();
   async function abort() {
     if (abortController && !abortController.signal.aborted) {
       abortController.abort();
@@ -4011,6 +4027,8 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
   let notifiedQuestionToolCalls = /* @__PURE__ */ new Set();
   function onMessage(message) {
     runtimeControls.observe(message);
+    backgroundTasks.observe(message);
+    session.setBackgroundTasks(backgroundTasks.list());
     if (isRuntimeCheckpointReplay(message)) return;
     if (message.type === "user" && isClaudeInterruptSentinelContent(message.message.content)) {
       sdkToLogConverter.convert(message);
@@ -4235,6 +4253,8 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
           },
           onQueryReady: (q) => {
             runtimeControls.setQuery(q);
+            backgroundTasks.reset();
+            session.setBackgroundTasks([]);
             turnSteering.setInterrupt(q.interrupt);
             session.setSideQuestionLive({ ask: q.sideQuestion, canControl: q.canControl });
             session.setSteerHandler(async (input) => {
@@ -4331,6 +4351,8 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
         }
       } finally {
         runtimeControls.setQuery(null);
+        backgroundTasks.reset();
+        session.setBackgroundTasks([]);
         turnSteering.reset();
         session.setSteerHandler(null);
         session.setSideQuestionLive(null);
@@ -5380,8 +5402,8 @@ ${typeLabels[type] || type}:`));
   }
   console.log(chalk.gray("  An external claude command is only needed for native terminal/mirror use."));
   try {
-    const { resolveAgentHomesForCli } = await import('./agentHome-ByLb2HFg.mjs');
-    const { describeAgentHome } = await import('./types-CkbfdRzq.mjs').then(function (n) { return n.a0; });
+    const { resolveAgentHomesForCli } = await import('./agentHome-BaJ9xtxB.mjs');
+    const { describeAgentHome } = await import('./types-BrGJ7PJz.mjs').then(function (n) { return n.a0; });
     const homes = await resolveAgentHomesForCli();
     console.log(chalk.green(`\u2713 Claude config dir: ${describeAgentHome(homes.claudeConfigDir)}`));
     console.log(chalk.green(`\u2713 Codex home: ${describeAgentHome(homes.codexHome)}`));
@@ -6204,6 +6226,18 @@ function checkPreviewPath(input, opts) {
   return { resolved, deniedReason: null };
 }
 
+const BackgroundTaskInfoSchema = z.object({
+  id: z.string().min(1).max(200),
+  type: z.string().max(64),
+  description: z.string().max(BACKGROUND_TASK_DESCRIPTION_MAX + 1),
+  startedAt: z.number()
+});
+const BackgroundTasksReportSchema = z.object({
+  count: z.number().int().nonnegative(),
+  tasks: z.array(BackgroundTaskInfoSchema),
+  reportedAt: z.number().optional(),
+  stale: z.boolean().optional()
+});
 function startDaemonControlServer({
   controlToken,
   getChildren,
@@ -6215,12 +6249,15 @@ function startDaemonControlServer({
   onSessionStateEvent,
   onClaudeAuthFailed,
   onSessionTurnEvent,
+  onSessionBackgroundTasks,
+  getBackgroundTasks,
   pushClipboard,
   pushFilePreview,
   onTerminalHook,
   setTerminalTitle,
   onSessionEdit,
-  listPeers
+  listPeers,
+  isTurnActive
 }) {
   return new Promise((resolve) => {
     const app = fastify({
@@ -6274,8 +6311,10 @@ function startDaemonControlServer({
       schema: {
         body: z.object({
           sessionId: z.string(),
-          event: z.enum(["completed", "needs_input", "auth_failed", "turn_started", "turn_ended"]),
-          spawnedBy: z.string().optional()
+          event: z.enum(["completed", "needs_input", "auth_failed", "turn_started", "turn_ended", "background_tasks"]),
+          spawnedBy: z.string().optional(),
+          // B-507: only with event 'background_tasks' — the wrapper's full set.
+          backgroundTasks: z.array(BackgroundTaskInfoSchema).max(BACKGROUND_TASKS_MAX).optional()
         }),
         response: {
           200: z.object({
@@ -6286,6 +6325,10 @@ function startDaemonControlServer({
     }, async (request) => {
       const { sessionId, event, spawnedBy } = request.body;
       logger.debug(`[CONTROL SERVER] Session event: ${sessionId} ${event} (spawnedBy=${spawnedBy ?? "unset"})`);
+      if (event === "background_tasks") {
+        onSessionBackgroundTasks?.(sessionId, request.body.backgroundTasks ?? []);
+        return { status: "ok" };
+      }
       if (event === "auth_failed") {
         onClaudeAuthFailed?.(sessionId);
         return { status: "ok" };
@@ -6304,7 +6347,10 @@ function startDaemonControlServer({
             children: z.array(z.object({
               startedBy: z.string(),
               happySessionId: z.string(),
-              pid: z.number()
+              pid: z.number(),
+              turnActive: z.boolean(),
+              // B-507: in-flight background tasks per the wrapper's last report (lease-expired = count 0).
+              backgroundTasks: BackgroundTasksReportSchema.optional()
             }))
           })
         }
@@ -6316,7 +6362,9 @@ function startDaemonControlServer({
         children: children.filter((child) => child.happySessionId !== void 0).map((child) => ({
           startedBy: child.startedBy,
           happySessionId: child.happySessionId,
-          pid: child.pid
+          pid: child.pid,
+          turnActive: isTurnActive ? isTurnActive(child.happySessionId) : false,
+          ...getBackgroundTasks ? { backgroundTasks: getBackgroundTasks(child.happySessionId) } : {}
         }))
       };
     });
@@ -6884,6 +6932,170 @@ function createPeerCoordinator(deps) {
   };
 }
 
+const WRITE_METHODS = /* @__PURE__ */ new Set(["sessions.send", "sessions.message"]);
+const REMOTE_CLIENT_TAG = "cli-send-remote";
+function defaultDeps(machineId) {
+  return {
+    machineId,
+    host: hostname(),
+    enabled: async () => (await readSettings()).remoteSessionOps !== "off",
+    readPersisted: readPersistedSessions,
+    listLocal: (options) => listSessions(options),
+    listAccount: (options) => listAccountSessions(options),
+    readTranscript: (sessionId, limit, options) => readSessionTranscript(sessionId, limit, options),
+    deliver: (sessionId, persisted, text, client, options, deps) => deliverToSession(sessionId, persisted, text, client, options, deps),
+    listPeers: (context, scope) => listPeerSessions(context, scope),
+    sendPeer: (context, args) => sendPeerMessage(context, args),
+    log: (line) => logger.info(line),
+    now: () => Date.now()
+  };
+}
+function createRemoteSessionOpsHandlers(machineId, overrides = {}) {
+  const deps = { ...defaultDeps(machineId), ...overrides };
+  const readBudget = deps.budget ?? new RemoteCallBudget(void 0, deps.now);
+  const writeBudget = deps.writeBudget ?? new RemoteCallBudget(REMOTE_WRITE_CALLS_PER_MINUTE, deps.now);
+  const deadlineMs = deps.deadlineMs ?? REMOTE_OP_DEADLINE_MS;
+  const sendCommitDeadlineMs = deps.sendCommitDeadlineMs ?? REMOTE_SEND_COMMIT_DEADLINE_MS;
+  const resumeWaitMs = deps.resumeWaitMs ?? REMOTE_RESUME_WAIT_MS;
+  const run = (method, op, targetOf) => async (params) => {
+    const started = deps.now();
+    let from = null;
+    let sessionId;
+    const finish = (response) => {
+      const outcome = response.ok ? "ok" : response.error.code;
+      deps.log(formatRemoteAuditLine({ method, from, sessionId, outcome, durationMs: deps.now() - started }));
+      return response;
+    };
+    let enabled = false;
+    try {
+      enabled = await deps.enabled();
+    } catch {
+      enabled = false;
+    }
+    const guard = guardRemoteSessionOpsRequest(method, params, { enabled });
+    if (!guard.ok) return finish(guard);
+    from = guard.request.from;
+    sessionId = targetOf(guard.request.args);
+    const budget = WRITE_METHODS.has(method) ? writeBudget : readBudget;
+    const token = budget.take();
+    if (!token.ok) {
+      return finish(remoteError("rate_limited", `This machine accepts at most ${budget.perMinute} remote ${WRITE_METHODS.has(method) ? "send/message" : "list/read/peers"} calls per minute; retry in ${Math.ceil(token.retryAfterMs / 1e3)}s`));
+    }
+    let timer;
+    const deadline = new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new RemoteOpFailure("timeout", `${method} did not finish within ${Math.round(deadlineMs / 1e3)}s on ${deps.host}`)), deadlineMs);
+      timer.unref?.();
+    });
+    try {
+      return finish({ ok: true, result: await Promise.race([op(guard.request.args, from, started), deadline]) });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Remote session operation failed";
+      if (error instanceof RemoteOpFailure) return finish(remoteError(error.code, message));
+      return finish(remoteError("internal", message));
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  };
+  const requirePersisted = (id) => {
+    const persisted = deps.readPersisted()[id];
+    if (!persisted) throw new RemoteOpFailure("no_local_key", `Session ${id} is not on ${deps.host} (no local key there either)`);
+    return persisted;
+  };
+  return {
+    "sessions.list": run("sessions.list", async (args) => {
+      const wanted = args.ids ? new Set(args.ids) : null;
+      let sessions;
+      if (args.all) {
+        sessions = (await deps.listAccount({ tag: args.tag, recentLimit: wanted ? 1e4 : args.limit, includeArchived: true })).filter((row) => row.decryptable);
+      } else if (wanted) {
+        const persisted = deps.readPersisted();
+        const live = await deps.listLocal({ recentLimit: 1e4 });
+        const liveById = new Map(live.map((row) => [row.id, row]));
+        sessions = [...wanted].filter((id) => persisted[id] !== void 0 || liveById.has(id)).map((id) => liveById.get(id) ?? summaryFromPersisted(id, persisted[id]));
+      } else {
+        sessions = await deps.listLocal({ tag: args.tag, recentLimit: args.limit });
+      }
+      if (wanted) sessions = sessions.filter((row) => wanted.has(row.id));
+      const result = { machineId: deps.machineId, host: deps.host, sessions };
+      return result;
+    }, () => void 0),
+    "sessions.read": run("sessions.read", async (args) => {
+      requirePersisted(args.sessionId);
+      const limit = Math.max(1, Math.min(MAX_READ_LIMIT, args.limit ?? 20));
+      const transcript = await deps.readTranscript(args.sessionId, limit, { full: args.full === true });
+      const capped = capRemoteTranscript(transcript.transcript);
+      const result = {
+        ...transcript,
+        summary: {
+          ...transcript.summary,
+          ...transcript.summary.title !== void 0 ? { title: capRemoteText(transcript.summary.title, REMOTE_TITLE_MAX_BYTES) } : {}
+        },
+        turn: { ...transcript.turn, answer: capRemoteText(transcript.turn.answer, REMOTE_ANSWER_MAX_BYTES, "tail") },
+        transcript: capped.transcript,
+        ...capped.truncated ? { truncated: true } : {},
+        machineId: deps.machineId,
+        host: deps.host
+      };
+      return result;
+    }, (args) => args.sessionId),
+    "sessions.send": run("sessions.send", async (args, _from, started) => {
+      const persisted = requirePersisted(args.sessionId);
+      const send = (sessionId, key, text, client, options) => {
+        if (deps.now() - started > sendCommitDeadlineMs) {
+          throw new RemoteOpFailure("timeout", `Session ${sessionId} was not live within ${Math.round(sendCommitDeadlineMs / 1e3)}s on ${deps.host}; nothing was sent \u2014 retry (the same localId cannot double-deliver)`);
+        }
+        return sendUserMessage(sessionId, key, text, client, { ...options, ...args.localId ? { localId: args.localId } : {} });
+      };
+      return deps.deliver(args.sessionId, persisted, args.text, REMOTE_CLIENT_TAG, {
+        resume: args.resume === true,
+        waitMs: resumeWaitMs,
+        pollMs: 1e3,
+        ...args.model !== void 0 ? { model: args.model } : {},
+        ...args.sentFrom !== void 0 ? { sentFrom: args.sentFrom } : {}
+      }, { send });
+    }, (args) => args.sessionId),
+    "sessions.peers": run("sessions.peers", async (args, from) => {
+      const scope = args.cwd ? args.scope ?? "machine" : "machine";
+      const context = {
+        self: () => ({ sessionId: from.sessionId ?? CLI_PEER_SENDER_ID, cwd: args.cwd ?? "/", machine: from.host }),
+        readPersisted: deps.readPersisted
+      };
+      const listing = await deps.listPeers(context, scope);
+      return { ...listing, machineId: deps.machineId, host: deps.host };
+    }, () => void 0),
+    "sessions.message": run("sessions.message", async (args) => {
+      requirePersisted(args.to);
+      const context = {
+        self: () => ({ ...args.from, cwd: args.from.cwd ?? "/" }),
+        readPersisted: deps.readPersisted,
+        // The target must be HERE; never bounce a remote request onward.
+        remoteMessage: null
+      };
+      return deps.sendPeer(context, { to: args.to, body: args.body, ...args.replyTo ? { replyTo: args.replyTo } : {} });
+    }, (args) => args.to)
+  };
+}
+class RemoteOpFailure extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+function summaryFromPersisted(id, persisted) {
+  const meta = persisted?.metadata;
+  return {
+    id,
+    live: false,
+    ...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 } : {},
+    ...persisted?.savedAt !== void 0 ? { savedAt: persisted.savedAt } : {},
+    url: sessionWebUrl(id)
+  };
+}
+
 const ASSISTANT_CLAUDE_MD = `# very-happy \u8C03\u5EA6\u4E2D\u5FC3\uFF08\u8BED\u97F3\u52A9\u624B\uFF09
 
 \u4F60\u662F very-happy \u7684\u8C03\u5EA6\u4E2D\u5FC3\uFF0C\u8DD1\u5728\u7528\u6237\u81EA\u5DF1\u7684\u673A\u5668\u4E0A\u3002\u7528\u6237\u4E3B\u8981\u901A\u8FC7\u8BED\u97F3\u8DDF\u4F60\u8BF4\u8BDD\uFF0C
@@ -9110,9 +9322,9 @@ function createMirrorManager(deps) {
       archiveReason: reason
     });
     try {
-      await deps.api.deactivateSession(binding.happySessionId);
+      await deps.api.archiveSession(binding.happySessionId);
     } catch (error) {
-      logger.debug(`[MIRROR] deactivateSession failed for ${binding.happySessionId}:`, error);
+      logger.debug(`[MIRROR] archiveSession failed for ${binding.happySessionId}:`, error);
     }
     deps.onBindingsChanged?.();
   };
@@ -10592,6 +10804,13 @@ ${action.prompt}`, { localId: `automation-${run.id}`, ...meta });
       if (edgeFell) item.sawTurn = false;
       const turn = await readTurn(sessionId, item.runId).catch(() => null);
       if (!turn?.ended) continue;
+      const background = deps.backgroundTasks?.(sessionId) ?? 0;
+      if (background > 0 && turn.status !== "failed" && turn.status !== "cancelled") {
+        if (!item.waitingOnBackground) deps.log(`Automation run ${item.runId}: turn ended but ${background} background task(s) still running; not done yet`);
+        item.waitingOnBackground = true;
+        continue;
+      }
+      item.waitingOnBackground = false;
       if (turn.status === "failed" || turn.status === "cancelled") await finish(item, { claimId: item.claimId, status: "failed", sessionId, error: turn.error ?? `Turn ${turn.status}`, needsAttention: true, attentionReason: `turn_${turn.status}` });
       else await finish(item, { claimId: item.claimId, status: "done", sessionId, summary: clipText(turn.answer, AUTOMATION_SUMMARY_MAX_CHARS) });
     }
@@ -10721,6 +10940,16 @@ ${action.prompt}`, { localId: `automation-${run.id}`, ...meta });
 function daemonExitCode(source) {
   return source === "exception" ? 1 : 0;
 }
+const HANDOVER_EXIT_CODE = 75;
+
+function detectDaemonSupervisor(env, platform = process.platform) {
+  const explicit = env.HAPPY_DAEMON_SUPERVISOR?.trim().toLowerCase();
+  if (explicit === "systemd") return "systemd";
+  if (explicit === "none") return "none";
+  if (platform === "linux" && typeof env.INVOCATION_ID === "string" && env.INVOCATION_ID.trim() !== "") return "systemd";
+  return "none";
+}
+const SYSTEMD_RESTART_HINT = "systemctl --user restart very-happy-daemon";
 
 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) {
@@ -10876,6 +11105,7 @@ async function startDaemon() {
     logger.debug("[DAEMON RUN] Auth and machine setup complete");
     const pidToTrackedSession = /* @__PURE__ */ new Map();
     const turnActivity = new TurnActivityTracker();
+    const backgroundTasks = new BackgroundTaskTracker();
     const peerCoordinator = createPeerCoordinator({ getChildren: () => Array.from(pidToTrackedSession.values()) });
     const sessionIdToFinishedSession = /* @__PURE__ */ new Map();
     let teamWorker;
@@ -11736,6 +11966,7 @@ async function startDaemon() {
       if (session?.happySessionId && (session.spawnedBy === "teams" || teamWorker?.hasSession(session.happySessionId))) teamWorker?.report(session.happySessionId, "exited");
       if (session?.happySessionId && automationRunner?.hasSession(session.happySessionId)) automationRunner.report(session.happySessionId, "exited");
       if (session?.happySessionId) turnActivity.forget(session.happySessionId);
+      if (session?.happySessionId) backgroundTasks.forget(session.happySessionId);
       if (session?.happySessionId) peerCoordinator.forget(session.happySessionId);
       if (session?.happySessionId && session.encryption) {
         sessionIdToFinishedSession.set(session.happySessionId, session);
@@ -11822,10 +12053,15 @@ async function startDaemon() {
       onSessionStateEvent,
       onClaudeAuthFailed: (sessionId) => claudeAuthServiceRef?.signalAuthFailed(sessionId),
       onSessionTurnEvent: (sessionId, event) => turnActivity.apply(sessionId, event),
+      onSessionBackgroundTasks: (sessionId, tasks) => backgroundTasks.apply(sessionId, tasks),
+      getBackgroundTasks: (sessionId) => backgroundTasks.report(sessionId),
       onSessionEdit: (edit) => {
         peerCoordinator.onEdit(edit);
       },
       listPeers: () => peerCoordinator.list(),
+      // B-505: `daemon list` shows which sessions have a turn in flight, so an
+      // operator can check the WHOLE machine before a supervised restart.
+      isTurnActive: (sessionId) => turnActivity.activeSessions().includes(sessionId),
       pushClipboard: (text, terminalId) => {
         if (!apiMachineRef) {
           return { delivered: false, truncated: false, totalBytes: 0, error: "daemon is still starting up" };
@@ -11845,6 +12081,8 @@ async function startDaemon() {
       }
     });
     const daemonClaudeCredentials = resolveClaudeCredentialReadiness();
+    const daemonSupervisor = detectDaemonSupervisor(process.env);
+    logger.debug(`[DAEMON RUN] Supervisor: ${daemonSupervisor}`);
     let fileState = {
       pid: process.pid,
       httpPort: controlPort,
@@ -11854,7 +12092,8 @@ async function startDaemon() {
       serverUrl: configuration.serverUrl,
       webappUrl: configuration.webappUrl,
       daemonLogPath: logger.logFilePath,
-      claudeCredentialSource: daemonClaudeCredentials.source
+      claudeCredentialSource: daemonClaudeCredentials.source,
+      supervisor: daemonSupervisor
     };
     writeDaemonState(fileState);
     logger.debug("[DAEMON RUN] Daemon state written");
@@ -11915,6 +12154,7 @@ async function startDaemon() {
       listTrackedSessionIds: () => [...pidToTrackedSession.values()].map((session) => session.happySessionId).filter((sessionId) => typeof sessionId === "string"),
       requestShutdown: () => requestShutdown("happy-app")
     });
+    apiMachine.setRemoteSessionOpsHandlers(createRemoteSessionOpsHandlers(machineId));
     const claudeAuthService = new ClaudeAuthService({
       happyHomeDir: configuration.happyHomeDir,
       happyLibDir: projectPath(),
@@ -11947,8 +12187,9 @@ async function startDaemon() {
       enabled: async () => ((await readSettings()).cliAutoUpdate ?? "idle") !== "off",
       // B-466: "idle" = no agent turn in flight. Idle wrappers survive a
       // handover (they talk to the server themselves) and web terminals live
-      // in tmux, so neither is a reason to hold an update.
-      idle: () => !turnActivity.hasActiveTurn(),
+      // in tmux, so neither is a reason to hold an update. B-507: a session
+      // whose turn ended but still has background tasks is busy too.
+      idle: () => !turnActivity.hasActiveTurn() && !backgroundTasks.hasAny(),
       install: installCliSafely,
       publish: (state) => {
         cliUpdateStateRef = state;
@@ -12003,7 +12244,7 @@ async function startDaemon() {
             } catch {
             }
           }
-          if (bundleReplaced && !teamWorker?.busy && !automationRunner?.busy && !updateController.isRunning() && !turnActivity.hasActiveTurn()) {
+          if (bundleReplaced && !teamWorker?.busy && !automationRunner?.busy && !updateController.isRunning() && !turnActivity.hasActiveTurn() && !backgroundTasks.hasAny()) {
             const preflight = await preflightNewBundle(bundlePath);
             if (preflight.action === "hold") {
               if (lastHandoverHold !== preflight.reason) {
@@ -12013,7 +12254,7 @@ async function startDaemon() {
               updateController.holdHandover(preflight.reason);
               return;
             }
-            if (teamWorker?.busy || automationRunner?.busy || updateController.isRunning() || turnActivity.hasActiveTurn()) return;
+            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");
             teamWorker?.stop();
@@ -12027,6 +12268,10 @@ async function startDaemon() {
             await cleanupDaemonState();
             await releaseDaemonLock(daemonLockHandle);
             await stopCaffeinate();
+            if (daemonSupervisor === "systemd") {
+              logger.debug(`[DAEMON RUN] systemd-supervised: exiting ${HANDOVER_EXIT_CODE} for the unit to restart on the new bundle`);
+              process.exit(HANDOVER_EXIT_CODE);
+            }
             try {
               spawnHappyCLI(["daemon", "start"], {
                 detached: true,
@@ -12075,6 +12320,7 @@ async function startDaemon() {
       spawn: spawnSession,
       live: (id) => [...pidToTrackedSession.values()].some((s) => s.happySessionId === id && isPidAlive(s.pid)),
       turnActive: (id) => turnActivity.activeSessions().includes(id),
+      backgroundTasks: (id) => backgroundTasks.count(id),
       log: (message) => logger.debug(`[DAEMON RUN] ${message}`)
     });
     void apiMachine.updateMachineMetadata((current) => ({
@@ -12368,36 +12614,54 @@ ${sessions.map(describeSummary).join("\n")}`);
     }
   });
   mcp.registerTool("session_read", {
-    description: "Read the latest messages of a session as a compact role-tagged transcript (user / assistant / tool summaries; large payloads truncated). Only works for sessions spawned by this machine (their keys live in ~/.happy/sessions.json).",
+    description: "Read the latest messages of a session as a compact role-tagged transcript (user / assistant / tool summaries; large payloads truncated). Sessions spawned by this machine are read directly; a session spawned by another machine of this account is read through that machine's daemon (it must be online).",
     title: "Read Session Transcript",
     inputSchema: {
       sessionId: z.string().describe("The Happy session id to read"),
-      limit: z.number().optional().describe("How many recent messages to fetch (default 20, max 100)")
+      limit: z.number().optional().describe("How many recent messages to fetch (default 20, max 100)"),
+      machineId: z.string().optional().describe("Machine id the session runs on, when known (skips the lookup across the account's machines)")
     }
   }, async (args) => {
     if (!isValidSessionId(args.sessionId)) return fail("Invalid sessionId");
     try {
-      const result = await readSessionTranscript(args.sessionId, args.limit ?? 20);
+      const local = readPersistedSessions()[args.sessionId];
+      if (local && !args.machineId) {
+        const result2 = await readSessionTranscript(args.sessionId, args.limit ?? 20);
+        const body2 = result2.transcript.length > 0 ? result2.transcript : "(no readable conversation content in this range)";
+        return ok(`${describeSummary(result2.summary)}
+--- last ${result2.messageCount} message(s) ---
+${body2}`);
+      }
+      const result = await readRemoteTranscript(args.sessionId, { limit: args.limit ?? 20, ...args.machineId ? { machineId: args.machineId } : {} });
       const body = result.transcript.length > 0 ? result.transcript : "(no readable conversation content in this range)";
-      return ok(`${describeSummary(result.summary)}
---- last ${result.messageCount} message(s) ---
+      return ok(`${describeSummary(result.summary)} machine=${result.host} (${result.machineId})
+--- last ${result.messageCount} message(s)${result.truncated ? ", truncated to fit" : ""} ---
 ${body}`);
     } catch (error) {
       return fail(`Failed to read session: ${error instanceof Error ? error.message : String(error)}`);
     }
   });
   mcp.registerTool("session_send", {
-    description: "Send a user message into an existing session on this machine. Only delivers when a live wrapper will read it: an archived / offline session is refused (the server would store the message unread) unless resume:true brings it back on this machine first. Returns immediately after delivery \u2014 it does NOT wait for the session to respond; use session_read later to check progress.",
+    description: "Send a user message into an existing session. Only delivers when a live wrapper will read it: an archived / offline session is refused (the server would store the message unread) unless resume:true brings it back on its machine first. A session spawned by another machine of this account is delivered through that machine's daemon (it must be online). Returns immediately after delivery \u2014 it does NOT wait for the session to respond; use session_read later to check progress.",
     title: "Send Message to Session",
     inputSchema: {
       sessionId: z.string().describe("The Happy session id to message"),
       text: z.string().describe("The message text to send"),
-      resume: z.boolean().optional().describe("If the session is archived or offline, resume it on this machine (like the web Restore button) and wait until it is live before sending")
+      resume: z.boolean().optional().describe("If the session is archived or offline, resume it on its machine (like the web Restore button) and wait until it is live before sending"),
+      machineId: z.string().optional().describe("Machine id the session runs on, when known (skips the lookup across the account's machines)")
     }
   }, async (args) => {
     if (!isValidSessionId(args.sessionId)) return fail("Invalid sessionId");
     if (typeof args.text !== "string" || args.text.trim().length === 0) return fail("text must be non-empty");
     try {
+      if (!readPersistedSessions()[args.sessionId] || args.machineId) {
+        const remote = await sendRemoteMessage(args.sessionId, args.text, { resume: args.resume === true, sentFrom: "assistant", ...args.machineId ? { machineId: args.machineId } : {} });
+        if (!remote.delivered) {
+          const detail = remote.error ?? `session is ${remote.status}`;
+          return fail(remote.stored ? `Not delivered (via ${remote.machine.host}): ${detail}` : `Session ${args.sessionId} on ${remote.machine.host} is ${remote.status}: ${detail}`);
+        }
+        return ok(`Message delivered${remote.resumed ? ` (session resumed on ${remote.machine.host})` : ""} to ${args.sessionId} on machine ${remote.machine.host} (${remote.machine.id}) ${sessionWebUrl(args.sessionId)}`);
+      }
       const persisted = await waitForSessionKey(args.sessionId, 0);
       const result = await deliverToSession(args.sessionId, persisted, args.text, MCP_CLIENT_TAG, {
         resume: args.resume === true,
@@ -12409,6 +12673,7 @@ ${body}`);
       }
       return ok(`Message delivered${result.resumed ? " (session resumed on this machine)" : ""} to ${describeSession(args.sessionId, persisted, { live: true })}`);
     } catch (error) {
+      if (error instanceof RemoteSessionOpsError) return fail(`Failed to send (${error.code}): ${error.message}`);
       return fail(`Failed to send: ${error instanceof Error ? error.message : String(error)}`);
     }
   });
@@ -13006,6 +13271,40 @@ function registerKillSessionHandler(rpcHandlerManager, killThisHappy, archiveEve
   };
 }
 
+async function settleSessionOnExit(sessionId, intent, deps) {
+  if (intent === "archive") {
+    deps.updateMetadata((currentMetadata) => ({
+      ...currentMetadata,
+      lifecycleState: "archived",
+      lifecycleStateSince: Date.now(),
+      archivedBy: "cli",
+      archiveReason: "User terminated"
+    }));
+  }
+  deps.sendSessionDeath();
+  try {
+    if (intent === "archive") await deps.archiveSession(sessionId);
+    else await deps.deactivateSession(sessionId);
+  } catch (error) {
+    deps.log?.(`[START] ${intent === "archive" ? "archiveSession" : "deactivateSession"} during cleanup failed:`, error);
+  }
+}
+class SessionExitGate {
+  decided = null;
+  /** Returns the intent to act on, or null when cleanup already started. */
+  claim(intent) {
+    if (this.decided !== null) return null;
+    this.decided = intent;
+    return intent;
+  }
+  get current() {
+    return this.decided;
+  }
+}
+function exitIntentFromArchiveFlag(archive) {
+  return archive ?? true ? "archive" : "offline";
+}
+
 function isUnsupportedSideQuestionError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return /unknown|unsupported|not supported|unrecognized|invalid.*subtype/i.test(message);
@@ -13182,7 +13481,7 @@ function registerSideQuestionHandler(rpc, deps) {
   const retainMs = deps.retainMs ?? SIDE_QUESTION_RETAIN_MS;
   const maxRunMs = deps.maxRunMs ?? SIDE_QUESTION_MAX_RUN_MS;
   const fork = deps.run ?? (async (input) => {
-    const { query } = await import('./index-DVVRqaVG.mjs');
+    const { query } = await import('./index-DQcRkI9r.mjs');
     return runSideQuestion(query, input);
   });
   const run = async (input, live) => {
@@ -14319,26 +14618,24 @@ async function runClaude(credentials, options = {}) {
       hasMetadata: Boolean(message.meta)
     });
   });
+  const exitGate = new SessionExitGate();
   const cleanup = async (opts = { archive: true }) => {
-    logger.debug(`[START] Received termination signal, cleaning up (archive=${opts.archive ?? true})...`);
+    const intent = exitGate.claim(exitIntentFromArchiveFlag(opts.archive));
+    if (intent === null) {
+      logger.debug(`[START] Termination (archive=${opts.archive ?? true}) ignored: cleanup already running as ${exitGate.current}`);
+      return;
+    }
+    logger.debug(`[START] Received termination signal, cleaning up (archive=${intent === "archive"})...`);
     try {
       if (session) {
-        if (opts.archive ?? true) {
-          session.updateMetadata((currentMetadata) => ({
-            ...currentMetadata,
-            lifecycleState: "archived",
-            lifecycleStateSince: Date.now(),
-            archivedBy: "cli",
-            archiveReason: "User terminated"
-          }));
-        }
         currentSession?.cleanup();
-        session.sendSessionDeath();
-        try {
-          await api.deactivateSession(session.sessionId);
-        } catch (err) {
-          logger.debug("[START] deactivateSession during cleanup failed:", err);
-        }
+        await settleSessionOnExit(session.sessionId, intent, {
+          updateMetadata: (handler) => session.updateMetadata(handler),
+          sendSessionDeath: () => session.sendSessionDeath(),
+          archiveSession: (id) => api.archiveSession(id),
+          deactivateSession: (id) => api.deactivateSession(id),
+          log: (message, ...args) => logger.debug(message, ...args)
+        });
         await session.flush();
         await session.close();
       }
@@ -18492,7 +18789,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "install-terminal-hooks") {
     try {
-      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-tIg7mANc.mjs');
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-ELDoqh0A.mjs');
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -18509,7 +18806,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "agent-home") {
     try {
-      const { parseAgentHomeArgs, runAgentHomeCommand } = await import('./agentHome-ByLb2HFg.mjs');
+      const { parseAgentHomeArgs, runAgentHomeCommand } = await import('./agentHome-BaJ9xtxB.mjs');
       await runAgentHomeCommand(parseAgentHomeArgs(args.slice(1)));
       process.exit(0);
     } catch (error) {
@@ -18518,7 +18815,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-BaPnjClT.mjs');
+      const { handleSpawnCommand } = await import('./spawn-CdihhwHs.mjs');
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18530,7 +18827,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-JaVXlSqj.mjs');
+      const { handleSessionsCommand } = await import('./sessions-DsE01xKc.mjs');
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18542,7 +18839,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-DJStmLBv.mjs');
+      const { handleSendCommand } = await import('./send-D5CyRyZ_.mjs');
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18648,9 +18945,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-BPZ2Y6o8.mjs');
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./limits-C_DW0M0q.mjs').then(function (n) { return n.aG; });
-        const { ApiClient: ApiClient2 } = await import('./types-CkbfdRzq.mjs').then(function (n) { return n.a1; });
+        const { saveGoogleCloudProjectToConfig } = await import('./config-aAbhJllb.mjs');
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./limits-A2c-3M-_.mjs').then(function (n) { return n.aO; });
+        const { ApiClient: ApiClient2 } = await import('./types-BrGJ7PJz.mjs').then(function (n) { return n.a1; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -18681,7 +18978,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-BPZ2Y6o8.mjs');
+        const { readGeminiLocalConfig } = await import('./config-aAbhJllb.mjs');
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -18721,7 +19018,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await import('./runGemini-CDlcQ-OA.mjs');
+      const { runGemini } = await import('./runGemini-Cj6oJQ-I.mjs');
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -18744,7 +19041,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
   } else if (subcommand === "pi") {
     if (args[1] === "--terminal") {
       try {
-        const { runPiTerminal } = await import('./piTerminal-Dpq6yqKU.mjs');
+        const { runPiTerminal } = await import('./piTerminal-DwWmgumi.mjs');
         process.exitCode = await runPiTerminal(args.slice(2));
       } catch (error) {
         console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18761,7 +19058,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       }
     };
     try {
-      const { runAcp, resolveAcpAgentConfig } = await import('./index-BjzdXb9x.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-BVu8Cufk.mjs');
       const parsed = parsePiRunnerArgs(args.slice(1));
       const resolved = resolveAcpAgentConfig(["pi", ...parsed.passthrough]);
       const { credentials } = await authAndSetupMachineIfNeeded();
@@ -18789,7 +19086,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-BjzdXb9x.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-BVu8Cufk.mjs');
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -18829,7 +19126,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-YkhsgPs0.mjs');
+      const { runOpenClaw } = await import('./runOpenClaw-DUCQxkI-.mjs');
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -18880,7 +19177,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "todo") {
     try {
-      const { handleTodoCommand } = await import('./todo-2Z1REhfx.mjs');
+      const { handleTodoCommand } = await import('./todo-CuQAkSp2.mjs');
       await handleTodoCommand(args.slice(1));
     } catch (error) {
       console.error(JSON.stringify({ error: error instanceof Error ? error.message : "Todo command failed" }));
@@ -18889,7 +19186,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "teams") {
     try {
-      const { handleTeamsCommand } = await import('./teams-DXV5Pwwt.mjs');
+      const { handleTeamsCommand } = await import('./teams-BE8nMB6O.mjs');
       await handleTeamsCommand(args.slice(1));
     } catch (error) {
       console.error(error instanceof Error ? error.message : "Teams command failed");
@@ -18898,7 +19195,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "auto") {
     try {
-      const { handleAutoCommand } = await import('./auto-BQnD6gVx.mjs');
+      const { handleAutoCommand } = await import('./auto-B1YAwaeU.mjs');
       await handleAutoCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Automation command failed");
@@ -18910,7 +19207,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "mcp" && (args.length === 1 || args.length === 2 && args[1] === "--terminal-tools")) {
     try {
-      const { handleMcpCommand } = await import('./mcp-o7QglAQM.mjs');
+      const { handleMcpCommand } = await import('./mcp-Bo934Kpy.mjs');
       await handleMcpCommand(args[1] === "--terminal-tools");
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}
@@ -18939,6 +19236,10 @@ Conversation history is preserved on the server, but in-flight tool calls are in
         } else {
           console.log("Active sessions:");
           console.log(JSON.stringify(sessions, null, 2));
+          const busy = sessions.filter((s) => s.turnActive === true);
+          console.log(busy.length === 0 ? "No turn in flight on this machine (wrappers older than 0.2.139 do not report turns)." : `${busy.length} session(s) with a turn in flight: ${busy.map((s) => s.happySessionId).join(", ")}`);
+          const background = sessions.filter((s) => (s.backgroundTasks?.count ?? 0) > 0);
+          console.log(background.length === 0 ? "No background tasks in flight (wrappers older than 0.2.157 do not report them)." : `${background.length} session(s) with background tasks in flight: ${background.map((s) => `${s.happySessionId} (${s.backgroundTasks?.count})`).join(", ")}`);
         }
       } catch (error) {
         console.log("No daemon running");
@@ -18967,13 +19268,19 @@ Conversation history is preserved on the server, but in-flight tool calls are in
         configuration.webappUrl
       );
       if (running && !currentDaemonMatches) {
+        if (currentState?.supervisor === "systemd") {
+          console.error(`The running daemon is supervised by systemd; hand over through the unit instead:
+  ${SYSTEMD_RESTART_HINT}`);
+          process.exit(1);
+        }
         console.log("Configured relay or CLI version changed; restarting the existing daemon");
         await stopDaemon();
       }
+      const { HAPPY_DAEMON_SUPERVISOR: _supervisor, INVOCATION_ID: _invocation, ...detachedEnv } = process.env;
       const child = spawnHappyCLI(["daemon", "start-sync"], {
         detached: true,
         stdio: "ignore",
-        env: process.env
+        env: detachedEnv
       });
       child.unref();
       let started = false;