very-happy-cli 0.2.155 → 0.2.157

package/dist/{index-D_fYUxVg.cjs → index-C9QzZsUQ.cjs}

@@ -3,14 +3,14 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var index = require('./types-a2xsH2UI.cjs');
-var persistence = require('./limits-DkfHJ3nS.cjs');
+var index = require('./types-B0sSi6eM.cjs');
+var persistence = require('./limits-CyuIt-Vl.cjs');
 var spawn = require('cross-spawn');
 var path = require('node:path');
 var node_readline = require('node:readline');
 var node_fs = require('node:fs');
 var terminalTitleSuggest = require('./terminalTitleSuggest-Dji8I0Jy.cjs');
-var agentGuidance = require('./agentGuidance-un7YPryB.cjs');
+var agentGuidance = require('./agentGuidance-Db76O1kw.cjs');
 var promises = require('node:fs/promises');
 var fs = require('fs/promises');
 var ink = require('ink');
@@ -137,6 +137,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,
@@ -198,11 +203,21 @@ class Session {
       persistence.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 (persistence.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)
    */
@@ -237,7 +252,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.
@@ -304,7 +319,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 = () => {
@@ -3948,6 +3963,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 = persistence.createBackgroundTaskTracker();
   async function abort() {
     if (abortController && !abortController.signal.aborted) {
       abortController.abort();
@@ -4033,6 +4049,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);
@@ -4257,6 +4275,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) => {
@@ -4353,6 +4373,8 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
         }
       } finally {
         runtimeControls.setQuery(null);
+        backgroundTasks.reset();
+        session.setBackgroundTasks([]);
         turnSteering.reset();
         session.setSteerHandler(null);
         session.setSideQuestionLive(null);
@@ -5402,8 +5424,8 @@ ${typeLabels[type] || type}:`));
   }
   console.log(chalk.gray("  An external claude command is only needed for native terminal/mirror use."));
   try {
-    const { resolveAgentHomesForCli } = await Promise.resolve().then(function () { return require('./agentHome-aucT8BHw.cjs'); });
-    const { describeAgentHome } = await Promise.resolve().then(function () { return require('./types-a2xsH2UI.cjs'); }).then(function (n) { return n.index; });
+    const { resolveAgentHomesForCli } = await Promise.resolve().then(function () { return require('./agentHome-B0CLy0Qx.cjs'); });
+    const { describeAgentHome } = await Promise.resolve().then(function () { return require('./types-B0sSi6eM.cjs'); }).then(function (n) { return n.index; });
     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)}`));
@@ -6226,6 +6248,18 @@ function checkPreviewPath(input, opts) {
   return { resolved, deniedReason: null };
 }
 
+const BackgroundTaskInfoSchema = z.z.object({
+  id: z.z.string().min(1).max(200),
+  type: z.z.string().max(64),
+  description: z.z.string().max(persistence.BACKGROUND_TASK_DESCRIPTION_MAX + 1),
+  startedAt: z.z.number()
+});
+const BackgroundTasksReportSchema = z.z.object({
+  count: z.z.number().int().nonnegative(),
+  tasks: z.z.array(BackgroundTaskInfoSchema),
+  reportedAt: z.z.number().optional(),
+  stale: z.z.boolean().optional()
+});
 function startDaemonControlServer({
   controlToken,
   getChildren,
@@ -6237,12 +6271,15 @@ function startDaemonControlServer({
   onSessionStateEvent,
   onClaudeAuthFailed,
   onSessionTurnEvent,
+  onSessionBackgroundTasks,
+  getBackgroundTasks,
   pushClipboard,
   pushFilePreview,
   onTerminalHook,
   setTerminalTitle,
   onSessionEdit,
-  listPeers
+  listPeers,
+  isTurnActive
 }) {
   return new Promise((resolve) => {
     const app = fastify({
@@ -6296,8 +6333,10 @@ function startDaemonControlServer({
       schema: {
         body: z.z.object({
           sessionId: z.z.string(),
-          event: z.z.enum(["completed", "needs_input", "auth_failed", "turn_started", "turn_ended"]),
-          spawnedBy: z.z.string().optional()
+          event: z.z.enum(["completed", "needs_input", "auth_failed", "turn_started", "turn_ended", "background_tasks"]),
+          spawnedBy: z.z.string().optional(),
+          // B-507: only with event 'background_tasks' — the wrapper's full set.
+          backgroundTasks: z.z.array(BackgroundTaskInfoSchema).max(persistence.BACKGROUND_TASKS_MAX).optional()
         }),
         response: {
           200: z.z.object({
@@ -6308,6 +6347,10 @@ function startDaemonControlServer({
     }, async (request) => {
       const { sessionId, event, spawnedBy } = request.body;
       persistence.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" };
@@ -6326,7 +6369,10 @@ function startDaemonControlServer({
             children: z.z.array(z.z.object({
               startedBy: z.z.string(),
               happySessionId: z.z.string(),
-              pid: z.z.number()
+              pid: z.z.number(),
+              turnActive: z.z.boolean(),
+              // B-507: in-flight background tasks per the wrapper's last report (lease-expired = count 0).
+              backgroundTasks: BackgroundTasksReportSchema.optional()
             }))
           })
         }
@@ -6338,7 +6384,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) } : {}
         }))
       };
     });
@@ -6906,6 +6954,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: os.hostname(),
+    enabled: async () => (await persistence.readSettings()).remoteSessionOps !== "off",
+    readPersisted: persistence.readPersistedSessions,
+    listLocal: (options) => agentGuidance.listSessions(options),
+    listAccount: (options) => agentGuidance.listAccountSessions(options),
+    readTranscript: (sessionId, limit, options) => agentGuidance.readSessionTranscript(sessionId, limit, options),
+    deliver: (sessionId, persisted, text, client, options, deps) => agentGuidance.deliverToSession(sessionId, persisted, text, client, options, deps),
+    listPeers: (context, scope) => agentGuidance.listPeerSessions(context, scope),
+    sendPeer: (context, args) => agentGuidance.sendPeerMessage(context, args),
+    log: (line) => persistence.logger.info(line),
+    now: () => Date.now()
+  };
+}
+function createRemoteSessionOpsHandlers(machineId, overrides = {}) {
+  const deps = { ...defaultDeps(machineId), ...overrides };
+  const readBudget = deps.budget ?? new agentGuidance.RemoteCallBudget(void 0, deps.now);
+  const writeBudget = deps.writeBudget ?? new agentGuidance.RemoteCallBudget(agentGuidance.REMOTE_WRITE_CALLS_PER_MINUTE, deps.now);
+  const deadlineMs = deps.deadlineMs ?? agentGuidance.REMOTE_OP_DEADLINE_MS;
+  const sendCommitDeadlineMs = deps.sendCommitDeadlineMs ?? agentGuidance.REMOTE_SEND_COMMIT_DEADLINE_MS;
+  const resumeWaitMs = deps.resumeWaitMs ?? agentGuidance.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(agentGuidance.formatRemoteAuditLine({ method, from, sessionId, outcome, durationMs: deps.now() - started }));
+      return response;
+    };
+    let enabled = false;
+    try {
+      enabled = await deps.enabled();
+    } catch {
+      enabled = false;
+    }
+    const guard = agentGuidance.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(agentGuidance.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(agentGuidance.remoteError(error.code, message));
+      return finish(agentGuidance.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(agentGuidance.MAX_READ_LIMIT, args.limit ?? 20));
+      const transcript = await deps.readTranscript(args.sessionId, limit, { full: args.full === true });
+      const capped = agentGuidance.capRemoteTranscript(transcript.transcript);
+      const result = {
+        ...transcript,
+        summary: {
+          ...transcript.summary,
+          ...transcript.summary.title !== void 0 ? { title: agentGuidance.capRemoteText(transcript.summary.title, agentGuidance.REMOTE_TITLE_MAX_BYTES) } : {}
+        },
+        turn: { ...transcript.turn, answer: agentGuidance.capRemoteText(transcript.turn.answer, agentGuidance.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 agentGuidance.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 ?? agentGuidance.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: agentGuidance.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
@@ -8442,7 +8654,7 @@ function parseJsonObject(text) {
     return null;
   }
 }
-function resolveSdkClaudeBinary(platform = process.platform, arch = process.arch, resolver = (s) => node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-D_fYUxVg.cjs', document.baseURI).href))).resolve(s)) {
+function resolveSdkClaudeBinary(platform = process.platform, arch = process.arch, resolver = (s) => node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-C9QzZsUQ.cjs', document.baseURI).href))).resolve(s)) {
   const platformArch = `${platform}-${arch}`;
   const candidates = [
     `@anthropic-ai/claude-agent-sdk-${platformArch}/claude`,
@@ -9132,9 +9344,9 @@ function createMirrorManager(deps) {
       archiveReason: reason
     });
     try {
-      await deps.api.deactivateSession(binding.happySessionId);
+      await deps.api.archiveSession(binding.happySessionId);
     } catch (error) {
-      persistence.logger.debug(`[MIRROR] deactivateSession failed for ${binding.happySessionId}:`, error);
+      persistence.logger.debug(`[MIRROR] archiveSession failed for ${binding.happySessionId}:`, error);
     }
     deps.onBindingsChanged?.();
   };
@@ -10614,6 +10826,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, persistence.AUTOMATION_SUMMARY_MAX_CHARS) });
     }
@@ -10743,6 +10962,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) {
@@ -10898,6 +11127,7 @@ async function startDaemon() {
     persistence.logger.debug("[DAEMON RUN] Auth and machine setup complete");
     const pidToTrackedSession = /* @__PURE__ */ new Map();
     const turnActivity = new index.TurnActivityTracker();
+    const backgroundTasks = new persistence.BackgroundTaskTracker();
     const peerCoordinator = createPeerCoordinator({ getChildren: () => Array.from(pidToTrackedSession.values()) });
     const sessionIdToFinishedSession = /* @__PURE__ */ new Map();
     let teamWorker;
@@ -11758,6 +11988,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);
@@ -11844,10 +12075,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" };
@@ -11867,6 +12103,8 @@ async function startDaemon() {
       }
     });
     const daemonClaudeCredentials = resolveClaudeCredentialReadiness();
+    const daemonSupervisor = detectDaemonSupervisor(process.env);
+    persistence.logger.debug(`[DAEMON RUN] Supervisor: ${daemonSupervisor}`);
     let fileState = {
       pid: process.pid,
       httpPort: controlPort,
@@ -11876,7 +12114,8 @@ async function startDaemon() {
       serverUrl: persistence.configuration.serverUrl,
       webappUrl: persistence.configuration.webappUrl,
       daemonLogPath: persistence.logger.logFilePath,
-      claudeCredentialSource: daemonClaudeCredentials.source
+      claudeCredentialSource: daemonClaudeCredentials.source,
+      supervisor: daemonSupervisor
     };
     persistence.writeDaemonState(fileState);
     persistence.logger.debug("[DAEMON RUN] Daemon state written");
@@ -11937,6 +12176,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: persistence.configuration.happyHomeDir,
       happyLibDir: terminalTitleSuggest.projectPath(),
@@ -11969,8 +12209,9 @@ async function startDaemon() {
       enabled: async () => ((await persistence.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;
@@ -12025,7 +12266,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) {
@@ -12035,7 +12276,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;
             persistence.logger.debug("[DAEMON RUN] Daemon bundle replaced on disk and verified, handing off to new daemon");
             teamWorker?.stop();
@@ -12049,6 +12290,10 @@ async function startDaemon() {
             await persistence.cleanupDaemonState();
             await persistence.releaseDaemonLock(daemonLockHandle);
             await stopCaffeinate();
+            if (daemonSupervisor === "systemd") {
+              persistence.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,
@@ -12097,6 +12342,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) => persistence.logger.debug(`[DAEMON RUN] ${message}`)
     });
     void apiMachine.updateMachineMetadata((current) => ({
@@ -12390,36 +12636,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.z.string().describe("The Happy session id to read"),
-      limit: z.z.number().optional().describe("How many recent messages to fetch (default 20, max 100)")
+      limit: z.z.number().optional().describe("How many recent messages to fetch (default 20, max 100)"),
+      machineId: z.z.string().optional().describe("Machine id the session runs on, when known (skips the lookup across the account's machines)")
     }
   }, async (args) => {
     if (!persistence.isValidSessionId(args.sessionId)) return fail("Invalid sessionId");
     try {
-      const result = await agentGuidance.readSessionTranscript(args.sessionId, args.limit ?? 20);
+      const local = persistence.readPersistedSessions()[args.sessionId];
+      if (local && !args.machineId) {
+        const result2 = await agentGuidance.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 agentGuidance.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.z.string().describe("The Happy session id to message"),
       text: z.z.string().describe("The message text to send"),
-      resume: z.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.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.z.string().optional().describe("Machine id the session runs on, when known (skips the lookup across the account's machines)")
     }
   }, async (args) => {
     if (!persistence.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 (!persistence.readPersistedSessions()[args.sessionId] || args.machineId) {
+        const remote = await agentGuidance.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}) ${agentGuidance.sessionWebUrl(args.sessionId)}`);
+      }
       const persisted = await agentGuidance.waitForSessionKey(args.sessionId, 0);
       const result = await agentGuidance.deliverToSession(args.sessionId, persisted, args.text, MCP_CLIENT_TAG, {
         resume: args.resume === true,
@@ -12431,6 +12695,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 agentGuidance.RemoteSessionOpsError) return fail(`Failed to send (${error.code}): ${error.message}`);
       return fail(`Failed to send: ${error instanceof Error ? error.message : String(error)}`);
     }
   });
@@ -13028,6 +13293,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);
@@ -13204,7 +13503,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 Promise.resolve().then(function () { return require('./index--KCpVs1c.cjs'); });
+    const { query } = await Promise.resolve().then(function () { return require('./index-Cz-uqnJk.cjs'); });
     return runSideQuestion(query, input);
   });
   const run = async (input, live) => {
@@ -13323,7 +13622,7 @@ const MAX_TITLE_CHARS = 60;
 const GENERATION_TIMEOUT_MS = 3e4;
 function resolveClaudeBinary() {
   try {
-    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-D_fYUxVg.cjs', document.baseURI).href)));
+    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-C9QzZsUQ.cjs', document.baseURI).href)));
     const utilsPath = path.resolve(path.join(terminalTitleSuggest.projectPath(), "scripts", "claude_version_utils.cjs"));
     const { getClaudeCliPath } = require$1(utilsPath);
     const path$1 = getClaudeCliPath();
@@ -14341,26 +14640,24 @@ async function runClaude(credentials, options = {}) {
       hasMetadata: Boolean(message.meta)
     });
   });
+  const exitGate = new SessionExitGate();
   const cleanup = async (opts = { archive: true }) => {
-    persistence.logger.debug(`[START] Received termination signal, cleaning up (archive=${opts.archive ?? true})...`);
+    const intent = exitGate.claim(exitIntentFromArchiveFlag(opts.archive));
+    if (intent === null) {
+      persistence.logger.debug(`[START] Termination (archive=${opts.archive ?? true}) ignored: cleanup already running as ${exitGate.current}`);
+      return;
+    }
+    persistence.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) {
-          persistence.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) => persistence.logger.debug(message, ...args)
+        });
         await session.flush();
         await session.close();
       }
@@ -15569,9 +15866,9 @@ function resolveLocalSignupBootstrap(configuredMode, configuredInviteCodes, gene
   };
 }
 
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-D_fYUxVg.cjs', document.baseURI).href)));
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-C9QzZsUQ.cjs', document.baseURI).href)));
 const __dirname$1 = path.dirname(__filename$1);
-const require_ = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-D_fYUxVg.cjs', document.baseURI).href)));
+const require_ = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-C9QzZsUQ.cjs', document.baseURI).href)));
 const PRISMA_QUERY_ENGINE_FILES = {
   "arm64-darwin": "libquery_engine-darwin-arm64.dylib.node",
   "x64-darwin": "libquery_engine-darwin.dylib.node",
@@ -18514,7 +18811,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 Promise.resolve().then(function () { return require('./installTerminalHooks-XrcPvfBs.cjs'); });
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await Promise.resolve().then(function () { return require('./installTerminalHooks-BVVOEGhG.cjs'); });
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -18531,7 +18828,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 Promise.resolve().then(function () { return require('./agentHome-aucT8BHw.cjs'); });
+      const { parseAgentHomeArgs, runAgentHomeCommand } = await Promise.resolve().then(function () { return require('./agentHome-B0CLy0Qx.cjs'); });
       await runAgentHomeCommand(parseAgentHomeArgs(args.slice(1)));
       process.exit(0);
     } catch (error) {
@@ -18540,7 +18837,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "spawn") {
     try {
-      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-cIoglKVf.cjs'); });
+      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-HV345RN-.cjs'); });
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18552,7 +18849,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "sessions") {
     try {
-      const { handleSessionsCommand } = await Promise.resolve().then(function () { return require('./sessions-MX21NJXd.cjs'); });
+      const { handleSessionsCommand } = await Promise.resolve().then(function () { return require('./sessions-BFlIrKCY.cjs'); });
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18564,7 +18861,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "send") {
     try {
-      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-CwrYXTPr.cjs'); });
+      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-CHxobaoI.cjs'); });
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18670,9 +18967,9 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     if (geminiSubcommand === "project" && args[2] === "set" && args[3]) {
       const projectId = args[3];
       try {
-        const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return require('./config-BoePh9PX.cjs'); });
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./limits-DkfHJ3nS.cjs'); }).then(function (n) { return n.persistence; });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-a2xsH2UI.cjs'); }).then(function (n) { return n.api; });
+        const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return require('./config-CzkBjZnV.cjs'); });
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./limits-CyuIt-Vl.cjs'); }).then(function (n) { return n.persistence; });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-B0sSi6eM.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -18703,7 +19000,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
     if (geminiSubcommand === "project" && args[2] === "get") {
       try {
-        const { readGeminiLocalConfig } = await Promise.resolve().then(function () { return require('./config-BoePh9PX.cjs'); });
+        const { readGeminiLocalConfig } = await Promise.resolve().then(function () { return require('./config-CzkBjZnV.cjs'); });
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -18743,7 +19040,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-8Pxh94Fm.cjs'); });
+      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-DS-0qm0L.cjs'); });
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -18766,7 +19063,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 Promise.resolve().then(function () { return require('./piTerminal-DYzRcwgb.cjs'); });
+        const { runPiTerminal } = await Promise.resolve().then(function () { return require('./piTerminal-CpU3hzrX.cjs'); });
         process.exitCode = await runPiTerminal(args.slice(2));
       } catch (error) {
         console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18783,7 +19080,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       }
     };
     try {
-      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-DRrLaljt.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-CTbGqVFY.cjs'); });
       const parsed = parsePiRunnerArgs(args.slice(1));
       const resolved = resolveAcpAgentConfig(["pi", ...parsed.passthrough]);
       const { credentials } = await authAndSetupMachineIfNeeded();
@@ -18811,7 +19108,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 Promise.resolve().then(function () { return require('./index-DRrLaljt.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-CTbGqVFY.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -18851,7 +19148,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "openclaw") {
     try {
-      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-B5FSZIbK.cjs'); });
+      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-CvSm8oTc.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -18902,7 +19199,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "todo") {
     try {
-      const { handleTodoCommand } = await Promise.resolve().then(function () { return require('./todo-Buuqn9gm.cjs'); });
+      const { handleTodoCommand } = await Promise.resolve().then(function () { return require('./todo-CMMQ6yhU.cjs'); });
       await handleTodoCommand(args.slice(1));
     } catch (error) {
       console.error(JSON.stringify({ error: error instanceof Error ? error.message : "Todo command failed" }));
@@ -18911,7 +19208,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "teams") {
     try {
-      const { handleTeamsCommand } = await Promise.resolve().then(function () { return require('./teams-Dqk7F3D-.cjs'); });
+      const { handleTeamsCommand } = await Promise.resolve().then(function () { return require('./teams-BahinMnH.cjs'); });
       await handleTeamsCommand(args.slice(1));
     } catch (error) {
       console.error(error instanceof Error ? error.message : "Teams command failed");
@@ -18920,7 +19217,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "auto") {
     try {
-      const { handleAutoCommand } = await Promise.resolve().then(function () { return require('./auto-P9RoJaY0.cjs'); });
+      const { handleAutoCommand } = await Promise.resolve().then(function () { return require('./auto-DqKGFq8U.cjs'); });
       await handleAutoCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Automation command failed");
@@ -18932,7 +19229,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 Promise.resolve().then(function () { return require('./mcp-BqlXl10F.cjs'); });
+      const { handleMcpCommand } = await Promise.resolve().then(function () { return require('./mcp-CXkvnztT.cjs'); });
       await handleMcpCommand(args[1] === "--terminal-tools");
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}
@@ -18961,6 +19258,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");
@@ -18989,13 +19290,19 @@ Conversation history is preserved on the server, but in-flight tool calls are in
         persistence.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 persistence.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;