very-happy-cli 0.2.154 → 0.2.156

package/dist/{index-eCjkm8Y2.cjs → index-BbtR-Qto.cjs}

@@ -3,14 +3,14 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var index = require('./types-Bd_TGr0F.cjs');
-var persistence = require('./limits-CmzISka2.cjs');
+var index = require('./types-CphWjqHc.cjs');
+var persistence = require('./limits-o29KXBgj.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-DUBXppv-.cjs');
+var agentGuidance = require('./agentGuidance-C-CmV03f.cjs');
 var promises = require('node:fs/promises');
 var fs = require('fs/promises');
 var ink = require('ink');
@@ -18,7 +18,7 @@ var React = require('react');
 var claudeAgentSdk = require('@anthropic-ai/claude-agent-sdk');
 var axios = require('axios');
 require('node:events');
-var socket_ioClient = require('socket.io-client');
+require('socket.io-client');
 var tweetnacl = require('tweetnacl');
 var os$1 = require('os');
 var child_process = require('child_process');
@@ -296,7 +296,7 @@ class Session {
   reportEventToDaemon = (event) => {
     const spawnedBy = process.env.HAPPY_SPAWNED_BY;
     if (!spawnedBy) return;
-    void index.notifyDaemonSessionEvent(this.client.sessionId, event, spawnedBy).catch((error) => persistence.logger.debug("[Session] Failed to report session event to daemon:", error));
+    void persistence.notifyDaemonSessionEvent(this.client.sessionId, event, spawnedBy).catch((error) => persistence.logger.debug("[Session] Failed to report session event to daemon:", error));
   };
   /** Produce an `error` notification for an unexpected session failure. */
   onSessionError = (message) => {
@@ -900,7 +900,7 @@ async function createSessionScanner(opts) {
   let processedMessageKeys = /* @__PURE__ */ new Set();
   let deadSessions = /* @__PURE__ */ new Set();
   if (opts.sessionId) {
-    let messages = await readSessionLog$1(projectDir, opts.sessionId);
+    let messages = await readSessionLog(projectDir, opts.sessionId);
     persistence.logger.debug(`[SESSION_SCANNER] Marking ${messages.length} existing messages as processed from session ${opts.sessionId}`);
     for (let m of messages) {
       processedMessageKeys.add(messageKey(m));
@@ -923,7 +923,7 @@ async function createSessionScanner(opts) {
       }
     }
     for (let session of sessions) {
-      const sessionMessages = await readSessionLog$1(projectDir, session);
+      const sessionMessages = await readSessionLog(projectDir, session);
       let skipped = 0;
       let sent = 0;
       for (let file of sessionMessages) {
@@ -1000,7 +1000,7 @@ async function createSessionScanner(opts) {
         return;
       }
       if (options?.treatExistingAsProcessed) {
-        const existing = await readSessionLog$1(projectDir, sessionId);
+        const existing = await readSessionLog(projectDir, sessionId);
         persistence.logger.debug(`[SESSION_SCANNER] Pre-marking ${existing.length} existing messages as processed for new session ${sessionId}`);
         for (const m of existing) {
           processedMessageKeys.add(messageKey(m));
@@ -1028,7 +1028,7 @@ function messageKey(message) {
     throw Error();
   }
 }
-async function readSessionLog$1(projectDir, sessionId) {
+async function readSessionLog(projectDir, sessionId) {
   const expectedSessionFile = path.join(projectDir, `${sessionId}.jsonl`);
   persistence.logger.debug(`[SESSION_SCANNER] Reading session file: ${expectedSessionFile}`);
   let file;
@@ -1928,7 +1928,7 @@ async function awaitFileExist(file, timeout = 1e4) {
       await fs.access(file);
       return true;
     } catch (e) {
-      await index.delay(1e3);
+      await persistence.delay(1e3);
     }
   }
   return false;
@@ -4295,7 +4295,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
           },
           onAuthFailure: (reason) => {
             session.client.sendSessionEvent({ type: "message", message: `Claude Code auth: ${reason}`, kind: "claude-auth-failed" });
-            void index.notifyDaemonClaudeAuthFailed(session.client.sessionId).catch((error) => persistence.logger.debug("[remote]: auth_failed report to daemon failed:", error));
+            void persistence.notifyDaemonClaudeAuthFailed(session.client.sessionId).catch((error) => persistence.logger.debug("[remote]: auth_failed report to daemon failed:", error));
           },
           onSessionReset: () => {
             persistence.logger.debug("[remote]: Session reset");
@@ -5231,7 +5231,7 @@ function getLogFiles(logDir) {
 async function runDoctorDaemon() {
   console.log(chalk.bold("\n\u{1F916} Daemon Status"));
   try {
-    const isRunning = await index.checkIfDaemonRunningAndCleanupStaleState();
+    const isRunning = await persistence.checkIfDaemonRunningAndCleanupStaleState();
     const state = await persistence.readDaemonState();
     if (isRunning && state) {
       console.log(chalk.green("\u2713 Daemon is running"));
@@ -5402,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 Promise.resolve().then(function () { return require('./agentHome-BUsLTZnz.cjs'); });
-    const { describeAgentHome } = await Promise.resolve().then(function () { return require('./types-Bd_TGr0F.cjs'); }).then(function (n) { return n.index; });
+    const { resolveAgentHomesForCli } = await Promise.resolve().then(function () { return require('./agentHome-CmIJNV7f.cjs'); });
+    const { describeAgentHome } = await Promise.resolve().then(function () { return require('./types-CphWjqHc.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)}`));
@@ -5444,7 +5444,7 @@ ${typeLabels[type] || type}:`));
   }
   console.log(chalk.bold("\n\u{1F916} Daemon Status"));
   try {
-    const isRunning = await index.checkIfDaemonRunningAndCleanupStaleState();
+    const isRunning = await persistence.checkIfDaemonRunningAndCleanupStaleState();
     const state = await persistence.readDaemonState();
     const summary = daemonReadiness(authenticated, isRunning, Boolean(state));
     if (summary.level === "ready" && state) {
@@ -5773,7 +5773,7 @@ async function waitForAuthentication(keypair, claimSecret) {
       }
       process.stdout.write("\rWaiting for authentication" + ".".repeat(dots % 3 + 1) + "   ");
       dots++;
-      await index.delay(1e3);
+      await persistence.delay(1e3);
     }
   } finally {
     process.off("SIGINT", handleInterrupt);
@@ -6085,59 +6085,6 @@ function formatAssistantReportMessage(title, sessionId, event) {
   return `[\u7CFB\u7EDF\u901A\u62A5] \u4F1A\u8BDD\u300C${title}\u300D${state}\uFF08${sessionId}\uFF09\u3002\u8BF7\u7528 session_read \u6838\u5B9E\u7ED3\u679C\uFF0C\u5E76\u5411\u7528\u6237\u53E3\u5934\u6C47\u62A5\u4E00\u53E5\u7ED3\u8BBA\uFF1B\u591A\u6761\u901A\u62A5\u63A5\u8FD1\u65F6\u5408\u5E76\u6C47\u62A5\u3002`;
 }
 
-function sessionWebUrl(sessionId) {
-  return `${persistence.configuration.webappUrl.replace(/\/+$/, "")}/session/${sessionId}`;
-}
-async function waitForSessionKey(sessionId, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (true) {
-    const entry = persistence.readPersistedSessions()[sessionId];
-    if (entry) return entry;
-    if (Date.now() >= deadline) {
-      throw new Error(
-        `Session ${sessionId} has no encryption key in ${persistence.configuration.sessionsFile}. Either it was not spawned by this machine's daemon, or the daemon is too old to persist session keys.`
-      );
-    }
-    await index.delay(200);
-  }
-}
-async function sendUserMessage(sessionId, persisted, text, client, options = {}) {
-  const credentials = await persistence.readCredentialsForConfiguredRelay();
-  if (!credentials) {
-    throw new Error("Not authenticated. Run `very-happy auth login` first.");
-  }
-  const envelope = {
-    role: "user",
-    content: {
-      type: "text",
-      text
-    },
-    meta: {
-      sentFrom: options.sentFrom ?? "cli",
-      ...options.model !== void 0 ? { model: options.model } : {},
-      ...options.permissionMode !== void 0 ? { permissionMode: options.permissionMode } : {},
-      ...options.effort !== void 0 ? { effort: options.effort } : {}
-    }
-  };
-  const encrypted = persistence.encodeBase64(persistence.encrypt(
-    persistence.decodeBase64(persisted.encryptionKey),
-    persisted.encryptionVariant,
-    envelope
-  ));
-  await axios.post(
-    `${persistence.configuration.serverUrl}/v3/sessions/${encodeURIComponent(sessionId)}/messages`,
-    { messages: [{ content: encrypted, localId: options.localId ?? node_crypto.randomUUID() }] },
-    {
-      headers: {
-        "Authorization": `Bearer ${credentials.token}`,
-        "Content-Type": "application/json",
-        "X-Happy-Client": `${client}/${persistence.configuration.currentCliVersion}`
-      },
-      timeout: 3e4
-    }
-  );
-}
-
 const ALLOWED_SPAWN_PERMISSION_MODES = [
   "default",
   "acceptEdits",
@@ -6293,7 +6240,10 @@ function startDaemonControlServer({
   pushClipboard,
   pushFilePreview,
   onTerminalHook,
-  setTerminalTitle
+  setTerminalTitle,
+  onSessionEdit,
+  listPeers,
+  isTurnActive
 }) {
   return new Promise((resolve) => {
     const app = fastify({
@@ -6377,7 +6327,8 @@ 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()
             }))
           })
         }
@@ -6389,7 +6340,8 @@ 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
         }))
       };
     });
@@ -6616,6 +6568,45 @@ function startDaemonControlServer({
       }
       return { status: "ok" };
     });
+    typed.post("/session-edit", {
+      schema: {
+        body: z.z.object({
+          sessionId: z.z.string().regex(/^[a-zA-Z0-9_-]{1,128}$/),
+          path: z.z.string().min(1).max(4096),
+          tool: z.z.string().min(1).max(64),
+          cwd: z.z.string().max(4096).optional(),
+          /** When the runner saw the call (ms). Clamped to now by the daemon;
+           *  older than the conflict window = ignored (replayed history). */
+          at: z.z.number().int().nonnegative().optional()
+        }),
+        response: { 200: z.z.object({ status: z.z.literal("ok") }) }
+      }
+    }, async (request) => {
+      try {
+        onSessionEdit?.(request.body);
+      } catch (error) {
+        persistence.logger.debug("[CONTROL SERVER] session-edit handler failed:", error);
+      }
+      return { status: "ok" };
+    });
+    typed.post("/peers", {
+      schema: {
+        response: {
+          200: z.z.object({
+            sessions: z.z.array(z.z.object({
+              sessionId: z.z.string(),
+              kind: z.z.enum(["managed", "mirror"]),
+              pid: z.z.number().optional(),
+              cwd: z.z.string().optional(),
+              flavor: z.z.string().optional(),
+              title: z.z.string().optional(),
+              variant: z.z.string().optional(),
+              edits: z.z.array(z.z.object({ path: z.z.string(), tool: z.z.string(), at: z.z.number() }))
+            }))
+          })
+        }
+      }
+    }, async () => ({ sessions: listPeers ? listPeers() : [] }));
     typed.post("/stop", {
       schema: {
         response: {
@@ -6651,6 +6642,273 @@ function startDaemonControlServer({
   });
 }
 
+const EDIT_CONFLICT_WINDOW_MS = 30 * 6e4;
+function pairKey$1(a, b, path) {
+  return a < b ? `${a}\0${b}\0${path}` : `${b}\0${a}\0${path}`;
+}
+class EditConflictTracker {
+  windowMs;
+  maxPaths;
+  /** real path → sessionId → latest edit */
+  byPath = /* @__PURE__ */ new Map();
+  /** (sorted pair, path) → when the notice went out */
+  notified = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.windowMs = options.windowMs ?? EDIT_CONFLICT_WINDOW_MS;
+    this.maxPaths = options.maxPaths ?? 5e3;
+  }
+  /**
+   * Remember an edit and return the peers to notify about it. `isLive`
+   * decides whether another session still counts (dead ones are dropped
+   * from the table on the spot).
+   */
+  record(edit, isLive) {
+    this.prune(edit.at);
+    let sessions = this.byPath.get(edit.path);
+    if (!sessions) {
+      sessions = /* @__PURE__ */ new Map();
+      this.byPath.set(edit.path, sessions);
+    }
+    const conflicts = [];
+    for (const [sessionId, peer] of sessions) {
+      if (sessionId === edit.sessionId) continue;
+      if (!isLive(sessionId)) {
+        sessions.delete(sessionId);
+        continue;
+      }
+      if (edit.at - peer.at > this.windowMs) continue;
+      const key = pairKey$1(edit.sessionId, sessionId, edit.path);
+      const notifiedAt = this.notified.get(key);
+      if (notifiedAt !== void 0 && edit.at - notifiedAt <= this.windowMs) continue;
+      this.notified.set(key, edit.at);
+      conflicts.push({ editor: edit, peer });
+    }
+    sessions.set(edit.sessionId, edit);
+    return conflicts;
+  }
+  /** Paths this session edited inside the window, newest first. */
+  editsOf(sessionId, now, limit = 20) {
+    const out = [];
+    for (const [path, sessions] of this.byPath) {
+      const edit = sessions.get(sessionId);
+      if (edit && now - edit.at <= this.windowMs) out.push({ path, tool: edit.tool, at: edit.at });
+    }
+    return out.sort((a, b) => b.at - a.at).slice(0, limit);
+  }
+  /** Session ended: nothing it did counts any more. */
+  forget(sessionId) {
+    for (const [path, sessions] of this.byPath) {
+      sessions.delete(sessionId);
+      if (sessions.size === 0) this.byPath.delete(path);
+    }
+    for (const key of this.notified.keys()) {
+      const [a, b] = key.split("\0");
+      if (a === sessionId || b === sessionId) this.notified.delete(key);
+    }
+  }
+  /** Drop everything older than the window (and cap the table size). */
+  prune(now) {
+    for (const [path, sessions] of this.byPath) {
+      for (const [sessionId, edit] of sessions) if (now - edit.at > this.windowMs) sessions.delete(sessionId);
+      if (sessions.size === 0) this.byPath.delete(path);
+    }
+    for (const [key, at] of this.notified) if (now - at > this.windowMs) this.notified.delete(key);
+    if (this.byPath.size > this.maxPaths) {
+      const oldest = [...this.byPath.entries()].map(([path, sessions]) => ({ path, at: Math.max(...[...sessions.values()].map((e) => e.at)) })).sort((a, b) => a.at - b.at);
+      for (const entry of oldest.slice(0, this.byPath.size - this.maxPaths)) this.byPath.delete(entry.path);
+    }
+  }
+  /** Test / diagnostics helper. */
+  size() {
+    return this.byPath.size;
+  }
+}
+function normalizeEditPath(path$1, cwd, realpath = node_fs.realpathSync.native ?? node_fs.realpathSync) {
+  const absolute = path.isAbsolute(path$1) ? path.resolve(path$1) : path.resolve(cwd, path$1);
+  let existing = absolute;
+  const tail = [];
+  for (let depth = 0; depth < 64; depth++) {
+    try {
+      const real = realpath(existing);
+      return tail.length ? path.join(real, ...tail) : real;
+    } catch {
+      const parent = path.dirname(existing);
+      if (parent === existing) break;
+      tail.unshift(existing.slice(parent.length).replace(new RegExp(`^\\${path.sep}`), ""));
+      existing = parent;
+    }
+  }
+  return absolute;
+}
+
+const CONFLICT_COALESCE_MS = 1e4;
+const MAX_NOTICES_PER_PAIR = 5;
+function pairKey(a, b) {
+  return a < b ? `${a}\0${b}` : `${b}\0${a}`;
+}
+function senderOf(info, sessionId) {
+  return { sessionId, title: info?.title, flavor: info?.flavor, cwd: info?.cwd };
+}
+function createPeerCoordinator(deps) {
+  const now = deps.now ?? (() => Date.now());
+  const windowMs = deps.windowMs ?? EDIT_CONFLICT_WINDOW_MS;
+  const coalesceMs = deps.coalesceMs ?? CONFLICT_COALESCE_MS;
+  const maxNoticesPerPair = deps.maxNoticesPerPair ?? MAX_NOTICES_PER_PAIR;
+  const tracker = new EditConflictTracker({ windowMs });
+  const readPersisted = deps.readPersisted ?? persistence.readPersistedSessions;
+  const send = deps.send ?? agentGuidance.sendUserMessage;
+  const normalize = deps.normalize ?? normalizeEditPath;
+  const liveTitle = deps.liveTitle ?? (async (sessionId, persisted) => (await agentGuidance.readSessionMetadata(sessionId, persisted))?.summary?.text);
+  const schedule = deps.schedule ?? ((fn, ms) => {
+    const t = setTimeout(fn, ms);
+    t.unref?.();
+    return t;
+  });
+  let getMirrors = deps.getMirrors ?? (() => []);
+  const pending = /* @__PURE__ */ new Map();
+  const noticesSent = /* @__PURE__ */ new Map();
+  let inflight = Promise.resolve();
+  const snapshot = () => {
+    const at = now();
+    const out = /* @__PURE__ */ new Map();
+    for (const child of deps.getChildren()) {
+      const id = child.happySessionId;
+      if (!id || out.has(id)) continue;
+      const meta = child.happySessionMetadataFromLocalWebhook;
+      out.set(id, {
+        sessionId: id,
+        kind: "managed",
+        pid: child.pid,
+        ...meta?.path ? { cwd: meta.path } : {},
+        ...meta?.flavor ? { flavor: meta.flavor } : {},
+        ...meta?.summary?.text ? { title: meta.summary.text } : {},
+        ...meta?.variant ?? child.variant ? { variant: meta?.variant ?? child.variant } : {},
+        edits: tracker.editsOf(id, at)
+      });
+    }
+    for (const mirror of getMirrors()) {
+      if (out.has(mirror.sessionId)) continue;
+      out.set(mirror.sessionId, {
+        sessionId: mirror.sessionId,
+        kind: "mirror",
+        flavor: "terminal-mirror",
+        ...mirror.cwd ? { cwd: mirror.cwd } : {},
+        ...mirror.title ? { title: mirror.title } : {},
+        edits: tracker.editsOf(mirror.sessionId, at)
+      });
+    }
+    return out;
+  };
+  const deliver = async (recipient, peer, peerId, paths, peerEditedAgoMs, noticeId) => {
+    if (recipient.kind === "mirror") return;
+    const persisted = readPersisted()[recipient.sessionId];
+    if (!persisted) {
+      persistence.logger.debug(`[PEERS] no key for ${recipient.sessionId}; conflict notice ${noticeId} not delivered`);
+      return;
+    }
+    const peerSender = senderOf(peer, peerId);
+    if (!peerSender.title && peer?.kind === "managed") {
+      const peerKey = readPersisted()[peer.sessionId];
+      if (peerKey) {
+        try {
+          peerSender.title = await liveTitle(peer.sessionId, peerKey);
+        } catch {
+        }
+      }
+    }
+    const text = agentGuidance.formatEditConflictNotice({ id: noticeId, path: paths[0], paths, peer: peerSender, peerEditedAgoMs, windowMs });
+    try {
+      await send(recipient.sessionId, persisted, text, "edit-conflict", {
+        sentFrom: agentGuidance.SESSION_PEER_SENT_FROM,
+        delivery: "steer",
+        localId: `edit-conflict-${noticeId}-${recipient.sessionId}`
+      });
+      persistence.logger.debug(`[PEERS] conflict notice ${noticeId} \u2192 ${recipient.sessionId} (${paths.length} file(s), first ${paths[0]}, peer ${peerId})`);
+    } catch (error) {
+      persistence.logger.debug(`[PEERS] conflict notice ${noticeId} \u2192 ${recipient.sessionId} failed:`, error);
+    }
+  };
+  const flushPair = async (key) => {
+    const pair = pending.get(key);
+    if (!pair) return;
+    pending.delete(key);
+    const at = now();
+    const sent = (noticesSent.get(key) ?? []).filter((t) => at - t <= windowMs);
+    if (sent.length >= maxNoticesPerPair) {
+      noticesSent.set(key, sent);
+      persistence.logger.debug(`[PEERS] pair ${pair.a}/${pair.b}: ${maxNoticesPerPair} notices already sent this window; ${pair.paths.size} conflicting path(s) not announced`);
+      return;
+    }
+    sent.push(at);
+    noticesSent.set(key, sent);
+    const sessions = snapshot();
+    const a = sessions.get(pair.a);
+    const b = sessions.get(pair.b);
+    const paths = [...pair.paths.keys()];
+    const noticeId = node_crypto.randomUUID().slice(0, 8);
+    const latestBy = (sessionId) => Math.max(...[...pair.paths.values()].map((c) => c.editor.sessionId === sessionId ? c.editor.at : c.peer.at));
+    const agoFor = (recipientId, otherId) => Math.max(0, latestBy(recipientId) - latestBy(otherId));
+    if (a) await deliver(a, b, pair.b, paths, agoFor(pair.a, pair.b), noticeId);
+    if (b) await deliver(b, a, pair.a, paths, agoFor(pair.b, pair.a), noticeId);
+  };
+  const enqueue = (conflict) => {
+    const key = pairKey(conflict.editor.sessionId, conflict.peer.sessionId);
+    let pair = pending.get(key);
+    if (!pair) {
+      pair = { a: conflict.editor.sessionId, b: conflict.peer.sessionId, paths: /* @__PURE__ */ new Map(), timer: null };
+      pair.timer = schedule(() => {
+        inflight = inflight.then(() => flushPair(key)).catch(() => {
+        });
+      }, coalesceMs);
+      pending.set(key, pair);
+    }
+    pair.paths.set(conflict.editor.path, conflict);
+  };
+  return {
+    list: () => [...snapshot().values()],
+    onEdit(edit) {
+      const sessions = snapshot();
+      const self = sessions.get(edit.sessionId);
+      if (!self) {
+        persistence.logger.debug(`[PEERS] edit from unknown/dead session ${edit.sessionId} ignored`);
+        return [];
+      }
+      const current = now();
+      const at = typeof edit.at === "number" && Number.isFinite(edit.at) ? Math.min(edit.at, current) : current;
+      if (current - at > windowMs) {
+        persistence.logger.debug(`[PEERS] edit from ${edit.sessionId} on ${edit.path} is ${Math.round((current - at) / 6e4)}m old (replayed history); ignored`);
+        return [];
+      }
+      const cwd = edit.cwd ?? self.cwd ?? process.cwd();
+      const path = normalize(edit.path, cwd);
+      const conflicts = tracker.record({ sessionId: edit.sessionId, path, tool: edit.tool, at }, (id) => sessions.has(id));
+      for (const conflict of conflicts) enqueue(conflict);
+      return conflicts;
+    },
+    async flush() {
+      for (const key of [...pending.keys()]) {
+        const pair = pending.get(key);
+        if (pair?.timer && typeof pair.timer === "object") clearTimeout(pair.timer);
+        inflight = inflight.then(() => flushPair(key)).catch(() => {
+        });
+      }
+      await inflight;
+    },
+    forget(sessionId) {
+      tracker.forget(sessionId);
+      for (const [key, pair] of pending) {
+        if (pair.a === sessionId || pair.b === sessionId) {
+          if (pair.timer && typeof pair.timer === "object") clearTimeout(pair.timer);
+          pending.delete(key);
+        }
+      }
+    },
+    setMirrorSource(source) {
+      getMirrors = source;
+    }
+  };
+}
+
 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
@@ -8187,7 +8445,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-eCjkm8Y2.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-BbtR-Qto.cjs', document.baseURI).href))).resolve(s)) {
   const platformArch = `${platform}-${arch}`;
   const candidates = [
     `@anthropic-ai/claude-agent-sdk-${platformArch}/claude`,
@@ -8570,6 +8828,73 @@ class ClaudeAuthService {
   }
 }
 
+const CLAUDE_EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+function pathOf(input) {
+  if (!input || typeof input !== "object") return null;
+  const record = input;
+  const candidate = record.file_path ?? record.notebook_path;
+  return typeof candidate === "string" && candidate.trim() !== "" ? candidate : null;
+}
+function extractClaudeEditPaths(body) {
+  if (!body || typeof body !== "object") return [];
+  const line = body;
+  if (line.type !== "assistant") return [];
+  const content = line.message?.content;
+  if (!Array.isArray(content)) return [];
+  const stamp = line.timestamp;
+  const at = typeof stamp === "string" ? Date.parse(stamp) : typeof stamp === "number" ? stamp : NaN;
+  const edits = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    if (b.type !== "tool_use" || typeof b.name !== "string" || !CLAUDE_EDIT_TOOLS.has(b.name)) continue;
+    const path = pathOf(b.input);
+    if (path) edits.push({ path, tool: b.name, ...Number.isFinite(at) ? { at } : {} });
+  }
+  return edits;
+}
+function extractCodexPatchPaths(changes) {
+  if (!changes || typeof changes !== "object" || Array.isArray(changes)) return [];
+  return Object.keys(changes).filter((path) => path.trim() !== "").map((path) => ({ path, tool: "CodexPatch" }));
+}
+function extractAcpEditPaths(toolKind, args) {
+  if (!args || typeof args !== "object") return [];
+  const a = args;
+  if (a.piTool === "write" || a.piTool === "edit") {
+    const raw = a.rawInput;
+    const path = raw && typeof raw.path === "string" && raw.path.trim() !== "" ? raw.path : null;
+    return path ? [{ path, tool: a.piTool }] : [];
+  }
+  if (typeof a.piTool === "string") return [];
+  if (toolKind !== "edit" || !Array.isArray(a.locations)) return [];
+  const edits = [];
+  for (const location of a.locations) {
+    const path = location && typeof location === "object" ? location.path : void 0;
+    if (typeof path === "string" && path.trim() !== "" && !edits.some((e) => e.path === path)) edits.push({ path, tool: "edit" });
+  }
+  return edits;
+}
+class EditReportThrottle {
+  constructor(intervalMs = 5e3) {
+    this.intervalMs = intervalMs;
+  }
+  lastReportedAt = /* @__PURE__ */ new Map();
+  /** Returns the edits that should be reported now and remembers them. */
+  take(edits, now = Date.now()) {
+    const due = [];
+    for (const edit of edits) {
+      const last = this.lastReportedAt.get(edit.path);
+      if (last !== void 0 && now - last < this.intervalMs) continue;
+      this.lastReportedAt.set(edit.path, now);
+      due.push(edit);
+    }
+    if (this.lastReportedAt.size > 512) {
+      for (const [path, at] of this.lastReportedAt) if (now - at > this.intervalMs * 10) this.lastReportedAt.delete(path);
+    }
+    return due;
+  }
+}
+
 const INTERNAL_CLAUDE_EVENT_TYPES = /* @__PURE__ */ new Set(["file-history-snapshot", "change", "queue-operation"]);
 function parseLines(lines) {
   const out = [];
@@ -8606,12 +8931,15 @@ function createMirrorScanner(opts) {
       }
       tail.offset = 0;
     }
+    let replaced = false;
     if (tail.offset > size) {
       persistence.logger.debug(`[MIRROR SCANNER] ${tail.path}: offset ${tail.offset} > size ${size} \u2014 file replaced, resetting (localId idempotency absorbs replays)`);
       tail.offset = 0;
+      replaced = true;
     }
     if (tail.offset === size) return;
     const isFirstBackfillRead = tail.mode === "backfill-tail" && tail.offset === 0;
+    const replay = isFirstBackfillRead || replaced;
     const handle = await promises.open(tail.path, "r");
     let buf;
     try {
@@ -8631,7 +8959,7 @@ function createMirrorScanner(opts) {
       if (decision.truncated) opts.events.onBackfillTruncated?.();
       tail.mode = "from-eof";
     }
-    if (messages.length > 0) opts.events.onMessages(messages);
+    if (messages.length > 0) opts.events.onMessages(messages, { replay });
   };
   const sync = new index.InvalidateSync(async () => {
     for (const tail of files.values()) {
@@ -8754,8 +9082,17 @@ function createMirrorManager(deps) {
     binding.client.updateMetadata((current) => ({ ...current, ...patch }));
     persistBinding(binding);
   };
-  const sendMessages = (binding, messages) => {
+  const sendMessages = (binding, messages, context = { replay: false }) => {
     for (const message of messages) {
+      if (deps.onEdit && binding.status === "active" && !context.replay) {
+        for (const edit of extractClaudeEditPaths(message)) {
+          try {
+            deps.onEdit({ sessionId: binding.happySessionId, path: edit.path, tool: edit.tool, cwd: binding.metadata.path, ...edit.at !== void 0 ? { at: edit.at } : {} });
+          } catch (error) {
+            persistence.logger.debug(`[MIRROR] edit tap failed for terminal ${binding.terminalId}:`, error);
+          }
+        }
+      }
       const key = index.mirrorLineKey(message);
       binding.client.sendClaudeSessionMessage(message, key ? { localIdFor: (envelopeIndex) => index.mirrorLocalId(key, envelopeIndex) } : void 0);
     }
@@ -8764,7 +9101,7 @@ function createMirrorManager(deps) {
     const scanner = createMirrorScanner({
       backfillLines,
       events: {
-        onMessages: (messages) => sendMessages(binding, messages),
+        onMessages: (messages, context) => sendMessages(binding, messages, context),
         onBackfillTruncated: opts.withTruncationNotice ? () => binding.client.sendSessionEvent({
           type: "message",
           message: `\u53EA\u8BFB\u955C\u50CF\u53EA\u56DE\u704C\u4E86\u6700\u8FD1 ${backfillLines} \u6761\uFF0C\u66F4\u65E9\u5185\u5BB9\u8BF7\u5728\u7EC8\u7AEF\u91CC\u56DE\u770B`
@@ -8787,6 +9124,10 @@ function createMirrorManager(deps) {
     await binding.scanner?.cleanup();
     binding.scanner = null;
     binding.client.closeClaudeSessionTurn("completed");
+    try {
+      deps.onSessionEnded?.(binding.happySessionId);
+    } catch {
+    }
     updateBindingMetadata(binding, {
       lifecycleState: "archived",
       lifecycleStateSince: Date.now(),
@@ -8794,9 +9135,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?.();
   };
@@ -8999,6 +9340,13 @@ function createMirrorManager(deps) {
     }
   };
   return {
+    listActiveMirrors() {
+      return [...bindings.values()].filter((binding) => binding.status === "active").map((binding) => ({
+        sessionId: binding.happySessionId,
+        ...binding.metadata.path ? { cwd: binding.metadata.path } : {},
+        ...binding.metadata.summary?.text ? { title: binding.metadata.summary.text } : {}
+      }));
+    },
     handleHookPayload(body) {
       const event = index.parseTerminalHookPayload(body);
       if (!event) {
@@ -9465,683 +9813,6 @@ Delegate from this working directory unless a different repository was explicitl
 ${goal}`;
 }
 
-const MAX_LINE_CHARS = 500;
-const MAX_ARGS_CHARS = 160;
-const DEFAULT_LIMITS = { line: MAX_LINE_CHARS, args: MAX_ARGS_CHARS };
-const NO_LIMITS = { line: Number.POSITIVE_INFINITY, args: Number.POSITIVE_INFINITY };
-function truncateText(text, max = MAX_LINE_CHARS) {
-  const chars = Array.from(text);
-  if (chars.length <= max) return text;
-  return chars.slice(0, max).join("") + ` \u2026[+${chars.length - max} chars]`;
-}
-function squash(text) {
-  return text.replace(/\s+/g, " ").trim();
-}
-function safeJson(value, max) {
-  try {
-    return truncateText(JSON.stringify(value) ?? "", max);
-  } catch {
-    return "[unserializable]";
-  }
-}
-function formatMessageBody(body, limits = DEFAULT_LIMITS) {
-  if (!body || typeof body !== "object") return null;
-  const b = body;
-  if (b.role === "user" && b.content?.type === "text" && typeof b.content.text === "string") {
-    const text = squash(b.content.text);
-    return text.length > 0 ? `user: ${truncateText(text, limits.line)}` : null;
-  }
-  if (b.role === "session" && b.content && typeof b.content === "object") {
-    const env = b.content;
-    const ev = env.ev;
-    if (!ev || typeof ev.t !== "string") return null;
-    switch (ev.t) {
-      case "text": {
-        if (ev.thinking) return null;
-        const text = squash(String(ev.text ?? ""));
-        if (text.length === 0) return null;
-        const role = env.role === "user" ? "user" : "assistant";
-        return `${role}: ${truncateText(text, limits.line)}`;
-      }
-      case "tool-call-start": {
-        const name = String(ev.name ?? "tool");
-        const title = squash(String(ev.title ?? ""));
-        const args = ev.args ? safeJson(ev.args, limits.args) : "";
-        const detail = title || args;
-        return `[tool] ${name}${detail ? `: ${truncateText(detail, limits.args)}` : ""}`;
-      }
-      case "service": {
-        const text = squash(String(ev.text ?? ""));
-        return text.length > 0 ? `[service] ${truncateText(text, limits.args)}` : null;
-      }
-      case "turn-end": {
-        if (ev.status && ev.status !== "completed") return `[turn ${ev.status}]`;
-        return null;
-      }
-      default:
-        return null;
-    }
-  }
-  if (b.role === "agent" && b.content?.type === "acp" && b.content.data && typeof b.content.data === "object") {
-    const d = b.content.data;
-    switch (d.type) {
-      case "message": {
-        const text = squash(String(d.message ?? ""));
-        return text.length > 0 ? `assistant: ${truncateText(text, limits.line)}` : null;
-      }
-      case "tool-call":
-        return `[tool] ${String(d.name ?? "tool")}: ${safeJson(d.input, limits.args)}`;
-      case "permission-request":
-        return `[permission] ${String(d.toolName ?? "")}: ${truncateText(squash(String(d.description ?? "")), limits.args)}`;
-      default:
-        return null;
-    }
-  }
-  if (b.role === "agent" && b.content?.type === "output") {
-    const msg = b.content.data?.message;
-    if (msg && Array.isArray(msg.content)) {
-      const texts = msg.content.filter((c) => c?.type === "text" && typeof c.text === "string").map((c) => squash(c.text)).filter((t) => t.length > 0);
-      if (texts.length > 0) {
-        const role = msg.role === "user" ? "user" : "assistant";
-        return `${role}: ${truncateText(texts.join(" "), limits.line)}`;
-      }
-    }
-    return null;
-  }
-  return null;
-}
-function formatTranscript(bodies, options = {}) {
-  const limits = options.full ? NO_LIMITS : DEFAULT_LIMITS;
-  const lines = [];
-  for (const body of bodies) {
-    const line = formatMessageBody(body, limits);
-    if (line !== null) lines.push(line);
-  }
-  return lines.join("\n");
-}
-
-function asRecord(value) {
-  return value && typeof value === "object" ? value : null;
-}
-function sessionEnvelope(body) {
-  const b = asRecord(body);
-  if (!b || b.role !== "session") return null;
-  const env = asRecord(b.content);
-  if (!env) return null;
-  const ev = asRecord(env.ev);
-  return ev && typeof ev.t === "string" ? { role: env.role, ev } : null;
-}
-function isUserPrompt(body) {
-  const b = asRecord(body);
-  return !!b && b.role === "user" && b.content?.type === "text" && typeof b.content.text === "string";
-}
-function agentPiece(body) {
-  const env = sessionEnvelope(body);
-  if (env && env.role !== "user") {
-    if (env.ev.t === "text" && !env.ev.thinking) {
-      const text = String(env.ev.text ?? "");
-      return text.trim().length > 0 ? { kind: "text", text } : null;
-    }
-    if (env.ev.t === "tool-call-start") return { kind: "tool" };
-    return null;
-  }
-  const b = asRecord(body);
-  if (b?.role === "agent" && b.content?.type === "acp") {
-    const d = asRecord(b.content.data);
-    if (d?.type === "message") {
-      const text = String(d.message ?? "");
-      return text.trim().length > 0 ? { kind: "text", text } : null;
-    }
-    if (d?.type === "tool-call") return { kind: "tool" };
-  }
-  return null;
-}
-function userPromptText(body) {
-  return isUserPrompt(body) ? body.content.text : null;
-}
-function analyzeLatestTurn(entries, options = {}) {
-  const lastSeq = entries.length > 0 ? entries[entries.length - 1].seq : 0;
-  let userIndex = -1;
-  for (let i = entries.length - 1; i >= 0; i--) {
-    if (isUserPrompt(entries[i].body) && (!options.anchor || options.anchor(entries[i].body))) {
-      userIndex = i;
-      break;
-    }
-  }
-  let ended = false;
-  let status = null;
-  let error = null;
-  let texts = [];
-  let lastMarker = null;
-  let startedAfterPrompt = false;
-  const emitsStarts = entries.some((entry) => sessionEnvelope(entry.body)?.ev?.t === "turn-start");
-  for (let i = userIndex + 1; i < entries.length; i++) {
-    const body = entries[i].body;
-    if (options.anchor && isUserPrompt(body)) {
-      if (ended) break;
-      continue;
-    }
-    const env = sessionEnvelope(body);
-    if (env?.ev?.t === "turn-start") {
-      lastMarker = "start";
-      startedAfterPrompt = true;
-      ended = false;
-      status = null;
-      error = null;
-      texts = [];
-      continue;
-    }
-    if (env?.ev?.t === "turn-end") {
-      lastMarker = "end";
-      if (userIndex >= 0 && emitsStarts && !startedAfterPrompt) continue;
-      ended = true;
-      status = typeof env.ev.status === "string" ? env.ev.status : null;
-      error = typeof env.ev.error === "string" ? env.ev.error : null;
-      continue;
-    }
-    const piece = agentPiece(body);
-    if (!piece) continue;
-    if (piece.kind === "tool") texts = [];
-    else texts.push(piece.text);
-  }
-  if (userIndex < 0) ended = lastMarker === "end";
-  return {
-    userSeq: userIndex >= 0 ? entries[userIndex].seq : null,
-    ended,
-    status: ended ? status : null,
-    error: ended ? error : null,
-    answer: texts.join("\n\n").trim(),
-    lastSeq
-  };
-}
-
-const USER_SOCKET_CONNECT_TIMEOUT_MS = 15e3;
-async function openUserScopedSocket(token, options = {}) {
-  const socket = socket_ioClient.io(persistence.configuration.serverUrl, {
-    auth: {
-      token,
-      clientType: "user-scoped",
-      happyClient: `cli-session-ops/${persistence.configuration.currentCliVersion}`
-    },
-    path: "/v1/updates",
-    transports: ["websocket"],
-    reconnection: false,
-    autoConnect: false
-  });
-  await new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      socket.close();
-      reject(new Error(`Timed out connecting to ${persistence.configuration.serverUrl}`));
-    }, options.connectTimeoutMs ?? USER_SOCKET_CONNECT_TIMEOUT_MS);
-    socket.once("connect", () => {
-      clearTimeout(timer);
-      resolve();
-    });
-    socket.once("connect_error", (error) => {
-      clearTimeout(timer);
-      socket.close();
-      reject(new Error(`Could not connect to ${persistence.configuration.serverUrl}: ${error.message}`));
-    });
-    socket.connect();
-  });
-  return {
-    async rpcCall(payload, timeoutMs) {
-      const ack = await socket.timeout(timeoutMs).emitWithAck("rpc-call", payload);
-      return ack;
-    },
-    close() {
-      socket.close();
-    }
-  };
-}
-
-const RPC_RATE_LIMIT_ERROR = "RPC rate limit reached";
-const RPC_ACCOUNT_RATE_LIMIT_ERROR = "RPC account rate limit reached";
-const RPC_RATE_RETRY_MIN_DELAY_MS = 2e3;
-const RPC_RATE_RETRY_MAX_DELAY_MS = 6e4;
-const RPC_RATE_MAX_RETRIES = 2;
-function isRpcRateLimitAck(ack) {
-  if (!ack || typeof ack !== "object") return false;
-  const a = ack;
-  if (a.ok !== false) return false;
-  if (a.code === "rpc_rate_limited" || a.code === "rpc_account_rate_limited") return true;
-  return a.error === RPC_RATE_LIMIT_ERROR || a.error === RPC_ACCOUNT_RATE_LIMIT_ERROR;
-}
-function rpcRateRetryDelayMs(attempt, retryAfterMs, random = Math.random()) {
-  if (typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs > 0) {
-    return Math.min(RPC_RATE_RETRY_MAX_DELAY_MS, Math.round(retryAfterMs * (1 + random * 0.5)));
-  }
-  const exponent = Math.max(0, Math.min(attempt, 32) - 1);
-  const ceiling = Math.min(RPC_RATE_RETRY_MIN_DELAY_MS * 2 ** exponent, RPC_RATE_RETRY_MAX_DELAY_MS);
-  return Math.round(RPC_RATE_RETRY_MIN_DELAY_MS + random * (ceiling - RPC_RATE_RETRY_MIN_DELAY_MS));
-}
-
-const PERMISSION_OPS_CLIENT = "session-ops";
-const PERMISSION_RPC_TIMEOUT_MS = 3e4;
-const SETTLE_TIMEOUT_MS = 5e3;
-const SETTLE_POLL_MS = 500;
-function buildPermissionRpcPayload(requestId, verdict) {
-  if (verdict.kind === "approve") {
-    return {
-      id: requestId,
-      approved: true,
-      decision: verdict.forSession ? "approved_for_session" : "approved"
-    };
-  }
-  return {
-    id: requestId,
-    approved: false,
-    decision: "denied",
-    ...verdict.reason ? { reason: verdict.reason } : {}
-  };
-}
-function interpretPermissionAck(ack, decryptResult) {
-  if (!ack.ok) {
-    const message = ack.error ?? "RPC call failed";
-    if (message === "RPC method not available") {
-      return { status: "offline", message: "no running wrapper has registered the permission RPC for this session" };
-    }
-    if (message === "RPC target disconnected") {
-      return { status: "offline", message: "the wrapper disconnected while the permission RPC was in flight" };
-    }
-    if (/timed? ?out/i.test(message)) {
-      return { status: "timeout", message };
-    }
-    if (isRpcRateLimitAck(ack)) {
-      return { status: "rate-limited", message, retryAfterMs: rpcRateRetryDelayMs(1, ack.retryAfterMs, 0) };
-    }
-    return { status: "rejected", message };
-  }
-  let body = null;
-  if (typeof ack.result === "string" && ack.result.length > 0) {
-    try {
-      body = decryptResult(ack.result);
-    } catch {
-      body = null;
-    }
-  }
-  if (body && typeof body === "object" && typeof body.error === "string") {
-    return { status: "handler-error", message: body.error };
-  }
-  return { status: "acknowledged" };
-}
-function pendingRequestsOf(agentState, now) {
-  const requests = agentState?.requests;
-  if (!requests || typeof requests !== "object") return [];
-  return Object.entries(requests).map(([id, request]) => ({
-    id,
-    tool: typeof request?.tool === "string" ? request.tool : "unknown",
-    ...request?.kind ? { kind: request.kind } : {},
-    ...typeof request?.createdAt === "number" ? { createdAt: request.createdAt, waitingMs: Math.max(0, now - request.createdAt) } : {}
-  })).sort((a, b) => (a.createdAt ?? Number.MAX_SAFE_INTEGER) - (b.createdAt ?? Number.MAX_SAFE_INTEGER));
-}
-const RPC_DEADLINE_GRACE_MS = 2e3;
-function withDeadline(promise, ms, message) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(`${message} (timed out)`)), ms);
-    promise.then(
-      (value) => {
-        clearTimeout(timer);
-        resolve(value);
-      },
-      (error) => {
-        clearTimeout(timer);
-        reject(error);
-      }
-    );
-  });
-}
-async function resolvePermissionRequest(sessionId, requestId, verdict, deps = {}) {
-  const now = deps.now ?? Date.now;
-  const persisted = (deps.readPersisted ?? persistence.readPersistedSessions)()[sessionId];
-  if (!persisted) {
-    throw new Error(
-      `No local key for session ${sessionId} \u2014 approve/deny needs the session key from ~/.happy/sessions.json (the RPC payload is encrypted with it), so only sessions this machine's daemon spawned within 14 days can be answered from here.`
-    );
-  }
-  const token = await (deps.bearerToken ?? bearerToken$1)();
-  const fetchState = deps.fetchAgentState ?? fetchDecryptedAgentState;
-  const before = pendingRequestsOf(await fetchState(sessionId, persisted, token), now());
-  if (!before.some((request) => request.id === requestId)) {
-    const hint = before.length > 0 ? `Pending request ids: ${before.map((request) => `${request.id} (${request.tool})`).join(", ")}` : "The session has no pending requests.";
-    throw new Error(`Request ${requestId} is not pending on session ${sessionId}. ${hint}`);
-  }
-  const payload = buildPermissionRpcPayload(requestId, verdict);
-  const key = persistence.decodeBase64(persisted.encryptionKey);
-  const params = persistence.encodeBase64(persistence.encrypt(key, persisted.encryptionVariant, payload));
-  const transport = await (deps.openTransport ?? openUserScopedSocket)(token);
-  const rpcTimeoutMs = deps.rpcTimeoutMs ?? PERMISSION_RPC_TIMEOUT_MS;
-  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-  let ack;
-  try {
-    for (let attempt = 1; ; attempt++) {
-      try {
-        ack = await withDeadline(
-          transport.rpcCall({ method: `${sessionId}:permission`, params }, rpcTimeoutMs),
-          rpcTimeoutMs + RPC_DEADLINE_GRACE_MS,
-          `permission RPC did not settle within ${rpcTimeoutMs}ms`
-        );
-      } catch (error) {
-        ack = { ok: false, error: error instanceof Error ? error.message : "RPC call failed" };
-      }
-      if (!isRpcRateLimitAck(ack) || attempt > RPC_RATE_MAX_RETRIES) break;
-      const waitMs = rpcRateRetryDelayMs(attempt, ack.retryAfterMs, (deps.random ?? Math.random)());
-      deps.onRateLimited?.({ attempt, waitMs, serverError: ack.error ?? "RPC rate limit reached" });
-      await sleep(waitMs);
-    }
-  } finally {
-    transport.close();
-  }
-  const outcome = interpretPermissionAck(ack, (encrypted) => persistence.decrypt(key, persisted.encryptionVariant, persistence.decodeBase64(encrypted)));
-  if (outcome.status !== "acknowledged") {
-    return { sessionId, requestId, payload, outcome };
-  }
-  const deadline = now() + (deps.settleTimeoutMs ?? SETTLE_TIMEOUT_MS);
-  let settled = false;
-  for (; ; ) {
-    const pending = pendingRequestsOf(await fetchState(sessionId, persisted, token), now());
-    if (!pending.some((request) => request.id === requestId)) {
-      settled = true;
-      break;
-    }
-    if (now() >= deadline) break;
-    await sleep(SETTLE_POLL_MS);
-  }
-  return { sessionId, requestId, payload, outcome, settled };
-}
-async function bearerToken$1() {
-  const credentials = await persistence.readCredentialsForConfiguredRelay();
-  if (!credentials) throw new Error("CLI is not authenticated (no ~/.happy/access.key)");
-  return credentials.token;
-}
-async function fetchDecryptedAgentState(sessionId, persisted, token) {
-  const response = await axios.get(
-    `${persistence.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`,
-    {
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "X-Happy-Client": `${PERMISSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
-      },
-      timeout: 15e3,
-      // 404 is a real answer ("not yours / gone"), not a transport fault.
-      validateStatus: (status) => status >= 200 && status < 300 || status === 404
-    }
-  );
-  if (response.status === 404) {
-    throw new Error(`Session ${sessionId} was not found on this account (it may have been deleted, or the local key belongs to a session on another relay).`);
-  }
-  const raw = response.data?.session?.agentState;
-  if (typeof raw !== "string" || raw.length === 0) return null;
-  return persistence.decrypt(persistence.decodeBase64(persisted.encryptionKey), persisted.encryptionVariant, persistence.decodeBase64(raw));
-}
-
-const SESSION_OPS_CLIENT = "session-ops";
-const DEFAULT_RECENT_LIMIT = 15;
-const MAX_READ_LIMIT = 100;
-function mergeSessionSummaries(live, persisted, options = {}) {
-  const recentLimit = Math.max(0, options.recentLimit ?? DEFAULT_RECENT_LIMIT);
-  const seen = /* @__PURE__ */ new Set();
-  const summaries = [];
-  for (const child of live) {
-    const id = typeof child.happySessionId === "string" ? child.happySessionId : void 0;
-    if (!id || seen.has(id)) continue;
-    seen.add(id);
-    summaries.push(toSummary(id, persisted[id], livenessOf(child)));
-  }
-  const rest = Object.entries(persisted).filter(([id]) => !seen.has(id)).filter(([, entry]) => entry.metadata?.flavor !== "terminal-mirror").sort((a, b) => b[1].savedAt - a[1].savedAt).slice(0, recentLimit);
-  for (const [id, entry] of rest) {
-    summaries.push(toSummary(id, entry, { live: false }));
-  }
-  if (!options.tag) return summaries;
-  const wanted = options.tag;
-  return summaries.filter((summary) => summary.tags?.includes(wanted) === true);
-}
-function livenessOf(child) {
-  return { live: true, pid: typeof child.pid === "number" ? child.pid : void 0 };
-}
-function sessionLiveness(live, sessionId) {
-  const child = live.find((entry) => entry.happySessionId === sessionId);
-  return child ? livenessOf(child) : { live: false };
-}
-function toSummary(id, persisted, extra) {
-  const meta = persisted?.metadata;
-  return {
-    id,
-    live: extra.live,
-    ...extra.pid !== void 0 ? { pid: extra.pid } : {},
-    ...meta?.summary?.text ? { title: meta.summary.text } : {},
-    ...meta?.path ? { cwd: meta.path } : {},
-    ...meta?.flavor ? { flavor: meta.flavor } : {},
-    ...meta?.tags?.length ? { tags: [...meta.tags] } : {},
-    ...meta?.variant ? { variant: meta.variant } : {},
-    url: sessionWebUrl(id),
-    ...persisted?.savedAt !== void 0 ? { savedAt: persisted.savedAt } : {}
-  };
-}
-async function listSessions(options = {}) {
-  const live = await index.listDaemonSessions();
-  return mergeSessionSummaries(live, persistence.readPersistedSessions(), options);
-}
-function summarizeAccountSession(row, persisted, liveIds, now) {
-  const base = {
-    id: row.id,
-    live: liveIds.has(row.id),
-    url: sessionWebUrl(row.id),
-    decryptable: false,
-    active: row.active === true,
-    archived: typeof row.archivedAt === "number",
-    ...typeof row.activeAt === "number" ? { activeAt: row.activeAt } : {},
-    ...typeof row.updatedAt === "number" ? { updatedAt: row.updatedAt } : {},
-    attention: false
-  };
-  if (!persisted) return base;
-  const key = persistence.decodeBase64(persisted.encryptionKey);
-  let metadata = null;
-  let agentState = null;
-  try {
-    metadata = row.metadata ? persistence.decrypt(key, persisted.encryptionVariant, persistence.decodeBase64(row.metadata)) : null;
-    agentState = row.agentState ? persistence.decrypt(key, persisted.encryptionVariant, persistence.decodeBase64(row.agentState)) : null;
-  } catch {
-    return base;
-  }
-  if (!metadata) return base;
-  const meta = metadata;
-  const pending = pendingRequestsOf(agentState, now);
-  return {
-    ...base,
-    decryptable: true,
-    ...meta.summary?.text ? { title: meta.summary.text } : {},
-    ...meta.path ? { cwd: meta.path } : {},
-    ...meta.flavor ? { flavor: meta.flavor } : {},
-    ...meta.tags?.length ? { tags: [...meta.tags] } : {},
-    ...meta.variant ? { variant: meta.variant } : {},
-    ...meta.machineId ? { machineId: meta.machineId } : {},
-    ...persisted.savedAt !== void 0 ? { savedAt: persisted.savedAt } : {},
-    pending,
-    attention: pending.length > 0
-  };
-}
-function orderAccountSessions(summaries, options = {}) {
-  const oldestWait = (summary) => Math.max(0, ...(summary.pending ?? []).map((request) => request.waitingMs ?? 0));
-  const rank = (summary) => summary.attention ? 0 : summary.live ? 1 : 2;
-  let rows = summaries.filter((summary) => summary.flavor !== "terminal-mirror").slice().sort((a, b) => {
-    const byRank = rank(a) - rank(b);
-    if (byRank !== 0) return byRank;
-    if (a.attention && b.attention) return oldestWait(b) - oldestWait(a);
-    return (b.updatedAt ?? 0) - (a.updatedAt ?? 0);
-  });
-  if (options.tag) {
-    const wanted = options.tag;
-    rows = rows.filter((summary) => summary.tags?.includes(wanted) === true);
-  }
-  const recentLimit = Math.max(0, options.recentLimit ?? DEFAULT_RECENT_LIMIT);
-  let idleKept = 0;
-  return rows.filter((summary) => rank(summary) < 2 || idleKept++ < recentLimit);
-}
-async function listAccountSessions(options = {}) {
-  const token = await bearerToken();
-  const response = await axios.get(`${persistence.configuration.serverUrl}/v1/sessions`, {
-    headers: {
-      "Authorization": `Bearer ${token}`,
-      "X-Happy-Client": `${SESSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
-    },
-    timeout: 15e3
-  });
-  const rows = Array.isArray(response.data?.sessions) ? response.data.sessions : [];
-  const persisted = persistence.readPersistedSessions();
-  const live = await index.listDaemonSessions();
-  const liveIds = new Set(live.map((child) => child.happySessionId).filter((id) => typeof id === "string"));
-  const now = Date.now();
-  const summaries = rows.filter((row) => typeof row?.id === "string").map((row) => summarizeAccountSession(row, persisted[row.id], liveIds, now)).filter((summary) => options.includeArchived || !summary.archived);
-  return orderAccountSessions(summaries, options);
-}
-async function bearerToken() {
-  const credentials = await persistence.readCredentialsForConfiguredRelay();
-  if (!credentials) throw new Error("CLI is not authenticated (no ~/.happy/access.key)");
-  return credentials.token;
-}
-function requirePersisted(sessionId) {
-  const persisted = persistence.readPersistedSessions()[sessionId];
-  if (!persisted) {
-    throw new Error(
-      `No local key for session ${sessionId} \u2014 it was not spawned by this machine's daemon (or is older than 14 days).`
-    );
-  }
-  return persisted;
-}
-async function readSessionLog(sessionId, persisted, limit) {
-  const token = await bearerToken();
-  const response = await axios.get(
-    `${persistence.configuration.serverUrl}/v3/sessions/${encodeURIComponent(sessionId)}/messages`,
-    {
-      params: { before_seq: 2147483647, limit },
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
-      },
-      timeout: 15e3
-    }
-  );
-  const messages = Array.isArray(response.data?.messages) ? response.data.messages : [];
-  messages.reverse();
-  const key = persistence.decodeBase64(persisted.encryptionKey);
-  return messages.map((message) => {
-    if (message.content?.t !== "encrypted") return { seq: message.seq, body: null };
-    try {
-      return { seq: message.seq, body: persistence.decrypt(key, persisted.encryptionVariant, persistence.decodeBase64(message.content.c)) };
-    } catch {
-      return { seq: message.seq, body: null };
-    }
-  });
-}
-const TURN_WINDOW = 500;
-async function readSessionTranscript(sessionId, limit, options = {}) {
-  const persisted = requirePersisted(sessionId);
-  const bounded = Math.max(1, Math.min(MAX_READ_LIMIT, Math.floor(limit)));
-  const entries = await readSessionLog(sessionId, persisted, Math.max(bounded, TURN_WINDOW));
-  const shown = entries.slice(-bounded);
-  const live = await index.listDaemonSessions();
-  return {
-    summary: toSummary(sessionId, persisted, sessionLiveness(live, sessionId)),
-    messageCount: shown.length,
-    transcript: formatTranscript(shown.map((entry) => entry.body), { full: options.full }),
-    turn: analyzeLatestTurn(entries)
-  };
-}
-async function readSessionMetadata(sessionId, persisted) {
-  const token = await bearerToken();
-  const response = await axios.get(`${persistence.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`, {
-    headers: {
-      "Authorization": `Bearer ${token}`,
-      "X-Happy-Client": `${SESSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
-    },
-    timeout: 15e3
-  });
-  const ciphertext = response.data?.session?.metadata;
-  if (typeof ciphertext !== "string" || ciphertext.length === 0) return null;
-  return persistence.decrypt(persistence.decodeBase64(persisted.encryptionKey), persisted.encryptionVariant, persistence.decodeBase64(ciphertext));
-}
-async function readSessionState(sessionId, persisted) {
-  const token = await bearerToken();
-  const response = await axios.get(`${persistence.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`, {
-    headers: {
-      "Authorization": `Bearer ${token}`,
-      "X-Happy-Client": `${SESSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
-    },
-    timeout: 15e3,
-    validateStatus: (status) => status >= 200 && status < 300 || status === 404
-  });
-  if (response.status === 404) return { found: false, active: false };
-  const row = response.data?.session;
-  if (!row || typeof row.id !== "string") throw new Error(`Server returned no session row for ${sessionId}`);
-  const state = {
-    found: true,
-    active: row.active === true,
-    ...typeof row.activeAt === "number" ? { activeAt: row.activeAt } : {},
-    archivedAt: typeof row.archivedAt === "number" ? row.archivedAt : null,
-    ...typeof row.updatedAt === "number" ? { updatedAt: row.updatedAt } : {}
-  };
-  if (persisted && typeof row.metadata === "string" && row.metadata.length > 0) {
-    try {
-      const metadata = persistence.decrypt(persistence.decodeBase64(persisted.encryptionKey), persisted.encryptionVariant, persistence.decodeBase64(row.metadata));
-      if (metadata?.machineId) state.machineId = metadata.machineId;
-    } catch {
-    }
-  }
-  return state;
-}
-class TurnWaitTimeoutError extends Error {
-  constructor(sessionId, timeoutMs, turn) {
-    super(`Session ${sessionId}: the latest turn did not end within ${Math.round(timeoutMs / 1e3)}s`);
-    this.sessionId = sessionId;
-    this.timeoutMs = timeoutMs;
-    this.turn = turn;
-  }
-}
-async function waitForTurnEnd(sessionId, options) {
-  const persisted = requirePersisted(sessionId);
-  const pollMs = options.pollMs ?? 3e3;
-  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-  const deadline = Date.now() + options.timeoutMs;
-  while (true) {
-    const turn = analyzeLatestTurn(await readSessionLog(sessionId, persisted, TURN_WINDOW));
-    if (turn.ended) return turn;
-    if (Date.now() + pollMs > deadline) throw new TurnWaitTimeoutError(sessionId, options.timeoutMs, turn);
-    await sleep(pollMs);
-  }
-}
-async function stopSession(sessionId) {
-  return await index.stopDaemonSession(sessionId);
-}
-async function archiveSession(sessionId) {
-  const token = await bearerToken();
-  await axios.post(
-    `${persistence.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}/archive`,
-    {},
-    {
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
-      },
-      timeout: 1e4
-    }
-  );
-}
-async function unarchiveSession(sessionId) {
-  const token = await bearerToken();
-  await axios.post(
-    `${persistence.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}/unarchive`,
-    {},
-    {
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
-      },
-      timeout: 1e4
-    }
-  );
-}
-
 function receiptPath(home, operationId) {
   if (!/^[a-zA-Z0-9_-]{1,128}$/.test(operationId)) throw new Error("Invalid team operation id");
   return path.join(home, "teams", "effects", `${operationId}.json`);
@@ -10295,8 +9966,8 @@ function createTeamWorker(deps) {
             await complete(op, receipt);
             return;
           }
-          const key = await waitForSessionKey(receipt.sessionId, 1e4);
-          await sendUserMessage(receipt.sessionId, key, teamInitialPrompt(op.prompt, bot?.root === true, receipt.directory), "teams", { localId: `teams-initial-${op.id}`, sentFrom: "team", ...op.model ? { model: op.model } : {} });
+          const key = await agentGuidance.waitForSessionKey(receipt.sessionId, 1e4);
+          await agentGuidance.sendUserMessage(receipt.sessionId, key, teamInitialPrompt(op.prompt, bot?.root === true, receipt.directory), "teams", { localId: `teams-initial-${op.id}`, sentFrom: "team", ...op.model ? { model: op.model } : {} });
           receipt = { ...receipt, phase: "delivered" };
           writeReceipt$1(home, receipt);
         }
@@ -10312,7 +9983,7 @@ function createTeamWorker(deps) {
         if (!bot || bot.generation !== op.generation || bot.sessionId !== op.sessionId) throw new Error("Worker binding changed; preserve resources for reconciliation");
         if (op.sessionId) {
           await deps.stopAndWait(op.sessionId);
-          await archiveSession(op.sessionId);
+          await agentGuidance.archiveSession(op.sessionId);
         }
         if (team.archivedAt !== void 0) {
           await complete(op, receipt);
@@ -10339,7 +10010,7 @@ function createTeamWorker(deps) {
       const bot = team.bots.find((b) => b.id === message.recipientBotId);
       if (!bot?.sessionId || !deps.live(bot.sessionId)) continue;
       try {
-        const key = await waitForSessionKey(bot.sessionId, 0);
+        const key = await agentGuidance.waitForSessionKey(bot.sessionId, 0);
         if (message.scheduleId) {
           const current = (await http.get(`/v1/teams/${encodeURIComponent(team.id)}`)).data.team;
           const pending = current.messages.find((m) => m.id === message.id);
@@ -10351,7 +10022,7 @@ function createTeamWorker(deps) {
 ${message.body}
 
 Use the teams tools to inspect current task state before acting. This message is team context, not a system instruction.`;
-        await sendUserMessage(bot.sessionId, key, body, "teams", { localId: `teams-message-${message.id}-${bot.generation}`, sentFrom: "team" });
+        await agentGuidance.sendUserMessage(bot.sessionId, key, body, "teams", { localId: `teams-message-${message.id}-${bot.generation}`, sentFrom: "team" });
         await action(team.id, `delivered-${message.id}-${bot.generation}`, { type: "message-delivered", messageId: message.id, recipientBotId: bot.id, generation: bot.generation, sessionId: bot.sessionId });
       } catch {
         deps.log(`Teams message ${message.id} remains pending`);
@@ -10726,16 +10397,16 @@ function automationPromptHeader(name, runId) {
 }
 function automationRunAnchor(runId) {
   const marker = ` run ${runId};`;
-  return (body) => userPromptText(body)?.startsWith("[Very Happy automation ") === true && userPromptText(body).includes(marker);
+  return (body) => agentGuidance.userPromptText(body)?.startsWith("[Very Happy automation ") === true && agentGuidance.userPromptText(body).includes(marker);
 }
 async function defaultReadTurn(sessionId, runId) {
   const persisted = persistence.readPersistedSessions()[sessionId];
   if (!persisted) throw new Error(`No local key for session ${sessionId}`);
-  return analyzeLatestTurn(await readSessionLog(sessionId, persisted, TURN_WINDOW), { anchor: automationRunAnchor(runId) });
+  return agentGuidance.analyzeLatestTurn(await agentGuidance.readSessionLog(sessionId, persisted, agentGuidance.TURN_WINDOW), { anchor: automationRunAnchor(runId) });
 }
 async function defaultSend(sessionId, text, meta) {
-  const persisted = await waitForSessionKey(sessionId, 15e3);
-  await sendUserMessage(sessionId, persisted, text, "automation", { ...meta, sentFrom: "automation" });
+  const persisted = await agentGuidance.waitForSessionKey(sessionId, 15e3);
+  await agentGuidance.sendUserMessage(sessionId, persisted, text, "automation", { ...meta, sentFrom: "automation" });
 }
 function expandHome(path$1) {
   if (path$1 === "~") return os.homedir();
@@ -11075,6 +10746,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) {
@@ -11200,7 +10881,7 @@ async function startDaemon() {
   });
   persistence.logger.debug("[DAEMON RUN] Starting daemon process...");
   persistence.logger.debugLargeJson("[DAEMON RUN] Environment", getEnvironmentInfo());
-  const runningDaemonVersionMatches = await index.isDaemonRunningCurrentlyInstalledHappyVersion();
+  const runningDaemonVersionMatches = await persistence.isDaemonRunningCurrentlyInstalledHappyVersion();
   const runningDaemonState = await persistence.readDaemonState();
   const runningDaemonEndpointsMatch = Boolean(runningDaemonState) && daemonEndpointsMatch(
     runningDaemonState?.serverUrl,
@@ -11210,7 +10891,7 @@ async function startDaemon() {
   );
   if (!runningDaemonVersionMatches || !runningDaemonEndpointsMatch) {
     persistence.logger.debug("[DAEMON RUN] Daemon version or endpoint mismatch detected, restarting daemon");
-    await index.stopDaemon();
+    await persistence.stopDaemon();
   } else {
     persistence.logger.debug("[DAEMON RUN] Daemon version matches, keeping existing daemon");
     console.log("Daemon already running with matching version");
@@ -11230,6 +10911,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 peerCoordinator = createPeerCoordinator({ getChildren: () => Array.from(pidToTrackedSession.values()) });
     const sessionIdToFinishedSession = /* @__PURE__ */ new Map();
     let teamWorker;
     let automationRunner;
@@ -12089,6 +11771,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) peerCoordinator.forget(session.happySessionId);
       if (session?.happySessionId && session.encryption) {
         sessionIdToFinishedSession.set(session.happySessionId, session);
         persistence.logger.debug(`[DAEMON RUN] Process PID ${pid} exited, preserved session ${session.happySessionId} for resume`);
@@ -12147,7 +11830,7 @@ async function startDaemon() {
             sessionId
           );
           assistantReportLastSentAt.set(sessionId, Date.now());
-          await sendUserMessage(
+          await agentGuidance.sendUserMessage(
             decision.assistantSessionId,
             assistantEntry,
             formatAssistantReportMessage(title, sessionId, event),
@@ -12174,6 +11857,13 @@ async function startDaemon() {
       onSessionStateEvent,
       onClaudeAuthFailed: (sessionId) => claudeAuthServiceRef?.signalAuthFailed(sessionId),
       onSessionTurnEvent: (sessionId, event) => turnActivity.apply(sessionId, event),
+      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" };
@@ -12193,6 +11883,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,
@@ -12202,7 +11894,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");
@@ -12239,9 +11932,12 @@ async function startDaemon() {
     const mirrorManager = createMirrorManager({
       api,
       machineId,
-      onBindingsChanged: () => apiMachine.requestTerminalListRefresh()
+      onBindingsChanged: () => apiMachine.requestTerminalListRefresh(),
+      onEdit: (edit) => peerCoordinator.onEdit(edit),
+      onSessionEnded: (sessionId) => peerCoordinator.forget(sessionId)
     });
     mirrorManagerRef = mirrorManager;
+    peerCoordinator.setMirrorSource(() => mirrorManager.listActiveMirrors());
     apiMachine.setMirrorIntegration({
       resolveMirrorSessionId: (terminalId) => mirrorManager.resolveMirrorSessionId(terminalId),
       onTerminalClosed: (terminalId) => mirrorManager.onTerminalClosed(terminalId),
@@ -12369,9 +12065,13 @@ async function startDaemon() {
             claudeAuthService.stop();
             apiMachine.shutdown();
             await stopControlServer();
-            await index.cleanupDaemonState();
+            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,
@@ -12451,7 +12151,7 @@ async function startDaemon() {
       }
       apiMachine.shutdown();
       await stopControlServer();
-      await index.cleanupDaemonState();
+      await persistence.cleanupDaemonState();
       await stopCaffeinate();
       await persistence.releaseDaemonLock(daemonLockHandle);
       persistence.logger.debug(`[DAEMON RUN] Cleanup completed, exiting process with code ${daemonExitCode(source)}`);
@@ -12555,8 +12255,8 @@ function createTeamAdoption(sessionId) {
 
 This session is now connected as the team lead. Call team_inspect to read the authoritative state before continuing the user's goal. Do not call team_create or team_join again.`;
         if (!intent.guidanceDelivered) {
-          const key = await waitForSessionKey(sessionId, 1e4);
-          await sendUserMessage(sessionId, key, instructions, "teams", { localId: `teams-adopt-${input.requestId}`, sentFrom: "team" });
+          const key = await agentGuidance.waitForSessionKey(sessionId, 1e4);
+          await agentGuidance.sendUserMessage(sessionId, key, instructions, "teams", { localId: `teams-adopt-${input.requestId}`, sentFrom: "team" });
           await retainTeam(path, input, connected.team.id, true);
         }
         operation.result = { status: "connected", teamId: connected.team.id, botId: connected.botId, instructions };
@@ -12573,127 +12273,6 @@ This session is now connected as the team lead. Call team_inspect to read the au
   };
 }
 
-const ACTIVE_FRESH_WINDOW_MS = 15 * 60 * 1e3;
-const DEFAULT_RESUME_WAIT_MS = 3e4;
-const DEFAULT_RESUME_POLL_MS = 1e3;
-function classifySessionState(input) {
-  const { liveHere, server, now } = input;
-  if (!server.found) return "not_found";
-  if (typeof server.archivedAt === "number") return "archived";
-  if (liveHere) return "live";
-  if (server.active && typeof server.activeAt === "number" && now - server.activeAt <= ACTIVE_FRESH_WINDOW_MS) return "live";
-  return "offline";
-}
-function explainNotLive(sessionId, status, resumeHint) {
-  switch (status) {
-    case "archived":
-      return `Session ${sessionId} is archived \u2014 no live wrapper will receive this message. ${resumeHint}`;
-    case "offline":
-      return `Session ${sessionId} is offline (its wrapper exited or timed out) \u2014 no live wrapper will receive this message. ${resumeHint}`;
-    case "not_found":
-      return `Session ${sessionId} was not found on this account \u2014 it cannot be messaged or resumed. Spawn a new session instead.`;
-  }
-}
-const CLI_RESUME_HINT = "Use --resume to bring it back on this machine, or spawn a new session.";
-const defaultDeps = {
-  listLive: () => index.listDaemonSessions(),
-  readState: (sessionId, persisted) => readSessionState(sessionId, persisted),
-  send: (sessionId, persisted, text, client, options) => sendUserMessage(sessionId, persisted, text, client, options),
-  unarchive: unarchiveSession,
-  archive: archiveSession,
-  resume: index.resumeDaemonSession,
-  sleep: (ms) => index.delay(ms).then(() => void 0),
-  now: () => Date.now()
-};
-async function deliverToSession(sessionId, persisted, text, client, options = {}, deps = {}) {
-  const d = { ...defaultDeps, ...deps };
-  const resumeHint = options.resumeHint ?? CLI_RESUME_HINT;
-  const classify = async () => {
-    const [live, server] = await Promise.all([d.listLive(), d.readState(sessionId, persisted)]);
-    return classifySessionState({ liveHere: sessionLiveness(live, sessionId).live, server, now: d.now() });
-  };
-  let status = await classify();
-  let resumed = false;
-  let resumeOutcome;
-  if (status !== "live") {
-    if (!options.resume || status === "not_found") {
-      return { sessionId, status, delivered: false, resumed: false, stored: false, error: explainNotLive(sessionId, status, resumeHint) };
-    }
-    const wasArchived = status === "archived";
-    if (wasArchived) {
-      try {
-        await d.unarchive(sessionId);
-      } catch (error) {
-        const message = `unarchive failed: ${error instanceof Error ? error.message : String(error)}`;
-        return { sessionId, status, delivered: false, resumed: false, stored: false, error: message, resume: { ok: false, error: message } };
-      }
-    }
-    const outcome = await d.resume(sessionId, {
-      ...typeof options.model === "string" ? { model: options.model } : {},
-      ...options.permissionMode !== void 0 ? { permissionMode: options.permissionMode } : {}
-    });
-    if (!outcome.success) {
-      let message = outcome.error ?? "resume failed";
-      if (wasArchived) {
-        try {
-          await d.archive(sessionId);
-        } catch (error) {
-          message += `; failed to restore archive state: ${error instanceof Error ? error.message : String(error)}`;
-        }
-      }
-      return { sessionId, status, delivered: false, resumed: false, stored: false, error: message, resume: { ok: false, error: message } };
-    }
-    resumed = true;
-    resumeOutcome = { ok: true };
-    status = await waitUntilLive(classify, d, options);
-    if (status !== "live") {
-      const waited = Math.round((options.waitMs ?? DEFAULT_RESUME_WAIT_MS) / 1e3);
-      return {
-        sessionId,
-        status,
-        delivered: false,
-        resumed,
-        stored: false,
-        resume: resumeOutcome,
-        error: `Session ${sessionId} was resumed but no live wrapper showed up within ${waited}s (state: ${status}); message not sent`
-      };
-    }
-  }
-  await d.send(sessionId, persisted, text, client, {
-    ...options.model !== void 0 ? { model: options.model } : {},
-    ...options.sentFrom !== void 0 ? { sentFrom: options.sentFrom } : {}
-  });
-  let after = "live";
-  try {
-    after = await classify();
-  } catch {
-    after = "live";
-  }
-  if (after !== "live") {
-    return {
-      sessionId,
-      status: after,
-      delivered: false,
-      resumed,
-      stored: true,
-      ...resumeOutcome ? { resume: resumeOutcome } : {},
-      error: `Session ${sessionId} went ${after} while sending: the message is stored server-side but no wrapper is attached to read it. ${after === "not_found" ? "Spawn a new session." : resumeHint}`
-    };
-  }
-  return { sessionId, status: "live", delivered: true, resumed, stored: true, ...resumeOutcome ? { resume: resumeOutcome } : {} };
-}
-async function waitUntilLive(classify, d, options) {
-  const waitMs = options.waitMs ?? DEFAULT_RESUME_WAIT_MS;
-  const pollMs = options.pollMs ?? DEFAULT_RESUME_POLL_MS;
-  const deadline = d.now() + waitMs;
-  let status = await classify();
-  while (status !== "live" && d.now() < deadline) {
-    await d.sleep(pollMs);
-    status = await classify();
-  }
-  return status;
-}
-
 const PERSONAL_MEMORY_SOFT_LIMIT_CHARS = 2e3;
 function headingTitle(line) {
   const m = /^##(?!#)\s*(.*?)\s*$/.exec(line);
@@ -12800,7 +12379,7 @@ function describeSession(id, persisted, extra) {
   if (meta?.tags?.length) parts.push(`tags=${meta.tags.join(",")}`);
   if (meta?.variant === "assistant") parts.push("(assistant)");
   if (extra?.pid) parts.push(`pid=${extra.pid}`);
-  parts.push(sessionWebUrl(id));
+  parts.push(agentGuidance.sessionWebUrl(id));
   return parts.join(" ");
 }
 function describeSummary(summary) {
@@ -12825,7 +12404,7 @@ function registerAssistantSessionTools(mcp) {
     inputSchema: {}
   }, async () => {
     try {
-      const sessions = await listSessions();
+      const sessions = await agentGuidance.listSessions();
       if (sessions.length === 0) return ok("No sessions found on this machine.");
       return ok(`${sessions.length} session(s):
 ${sessions.map(describeSummary).join("\n")}`);
@@ -12841,9 +12420,9 @@ ${sessions.map(describeSummary).join("\n")}`);
       limit: z.z.number().optional().describe("How many recent messages to fetch (default 20, max 100)")
     }
   }, async (args) => {
-    if (!index.isValidSessionId(args.sessionId)) return fail("Invalid sessionId");
+    if (!persistence.isValidSessionId(args.sessionId)) return fail("Invalid sessionId");
     try {
-      const result = await readSessionTranscript(args.sessionId, args.limit ?? 20);
+      const result = await agentGuidance.readSessionTranscript(args.sessionId, args.limit ?? 20);
       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) ---
@@ -12861,11 +12440,11 @@ ${body}`);
       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")
     }
   }, async (args) => {
-    if (!index.isValidSessionId(args.sessionId)) return fail("Invalid sessionId");
+    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 {
-      const persisted = await waitForSessionKey(args.sessionId, 0);
-      const result = await deliverToSession(args.sessionId, persisted, args.text, MCP_CLIENT_TAG, {
+      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,
         resumeHint: "Pass resume:true to bring it back on this machine, or spawn a new session."
       });
@@ -12890,16 +12469,16 @@ ${body}`);
     if (!normalized.ok) return fail(normalized.error);
     const directory = normalized.directory;
     try {
-      const result = await index.spawnDaemonSession(directory, void 0, { spawnedBy: "assistant" });
+      const result = await persistence.spawnDaemonSession(directory, void 0, { spawnedBy: "assistant" });
       if (result?.error || !result?.sessionId) {
         return fail(`Failed to spawn session: ${result?.error ?? "daemon returned no session id"}`);
       }
       const sessionId = result.sessionId;
-      const url = sessionWebUrl(sessionId);
+      const url = agentGuidance.sessionWebUrl(sessionId);
       if (args.prompt && args.prompt.trim().length > 0) {
         try {
-          const persisted = await waitForSessionKey(sessionId, 15e3);
-          await sendUserMessage(sessionId, persisted, args.prompt, MCP_CLIENT_TAG);
+          const persisted = await agentGuidance.waitForSessionKey(sessionId, 15e3);
+          await agentGuidance.sendUserMessage(sessionId, persisted, args.prompt, MCP_CLIENT_TAG);
           return ok(`Spawned session ${sessionId} in ${directory} and sent the first prompt. It is now working in the background \u2014 check on it later with session_read. ${url}`);
         } catch (error) {
           return ok(`Spawned session ${sessionId} in ${directory}, but sending the first prompt failed (${error instanceof Error ? error.message : String(error)}). Use session_send to retry. ${url}`);
@@ -12917,10 +12496,10 @@ ${body}`);
       sessionId: z.z.string().describe("The Happy session id to stop")
     }
   }, async (args) => {
-    if (!index.isValidSessionId(args.sessionId)) return fail("Invalid sessionId");
+    if (!persistence.isValidSessionId(args.sessionId)) return fail("Invalid sessionId");
     try {
       const persisted = persistence.readPersistedSessions()[args.sessionId];
-      const success = await stopSession(args.sessionId);
+      const success = await agentGuidance.stopSession(args.sessionId);
       if (!success) return fail(`Session ${args.sessionId} was not found among the daemon's running sessions.`);
       return ok(`Stopped ${describeSession(args.sessionId, persisted)}`);
     } catch (error) {
@@ -12934,9 +12513,9 @@ ${body}`);
       sessionId: z.z.string().describe("The Happy session id to archive")
     }
   }, async (args) => {
-    if (!index.isValidSessionId(args.sessionId)) return fail("Invalid sessionId");
+    if (!persistence.isValidSessionId(args.sessionId)) return fail("Invalid sessionId");
     try {
-      await archiveSession(args.sessionId);
+      await agentGuidance.archiveSession(args.sessionId);
       const persisted = persistence.readPersistedSessions()[args.sessionId];
       return ok(`Archived ${describeSession(args.sessionId, persisted)}`);
     } catch (error) {
@@ -12970,7 +12549,7 @@ ${lines.join("\n")}`);
       lines: z.z.number().optional().describe("How many history lines to read (default 80, max 2000)")
     }
   }, async (args) => {
-    if (!index.isValidTerminalId(args.terminalId)) return fail("Invalid terminalId");
+    if (!persistence.isValidTerminalId(args.terminalId)) return fail("Invalid terminalId");
     const r = index.readVhTerminal(args.terminalId, args.lines ?? 80);
     if (!r.ok) return fail(`Failed to read terminal ${args.terminalId}: ${r.error}`);
     return ok(`terminal ${args.terminalId} \u2014 last output:
@@ -12985,7 +12564,7 @@ ${r.text}`);
       submit: z.z.boolean().optional().describe("Also press Enter after pasting (default false)")
     }
   }, async (args) => {
-    if (!index.isValidTerminalId(args.terminalId)) return fail("Invalid terminalId");
+    if (!persistence.isValidTerminalId(args.terminalId)) return fail("Invalid terminalId");
     if (typeof args.text !== "string" || args.text.length === 0) return fail("text must be non-empty");
     const submit = args.submit === true;
     const r = index.sendToVhTerminal(args.terminalId, args.text, submit);
@@ -13060,13 +12639,14 @@ function normalizeProgress(value) {
   return flat.length > PROGRESS_MAX_CHARS$1 ? flat.slice(0, PROGRESS_MAX_CHARS$1) : flat;
 }
 
-function createMcpServer(handlers, options, sessionId) {
+function createMcpServer(handlers, options, sessionId, client) {
   const mcp = new mcp_js.McpServer({
     name: "Very Happy Tools",
     version: "1.0.0"
   });
   agentGuidance.registerTeamsTools(mcp, sessionId);
   agentGuidance.registerAutomationTools(mcp);
+  if (client) agentGuidance.registerSessionPeerTools(mcp, agentGuidance.createSessionPeerToolExecutor(client));
   mcp.registerTool("change_title", {
     description: "Change the title of the current chat session",
     title: "Change Chat Title",
@@ -13269,7 +12849,7 @@ async function startHappyServer(client, options) {
       }
       return;
     }
-    const mcp = createMcpServer(handlers, options, client.sessionId);
+    const mcp = createMcpServer(handlers, options, client.sessionId, client);
     try {
       const transport = new streamableHttp_js.StreamableHTTPServerTransport({
         sessionIdGenerator: void 0
@@ -13310,6 +12890,7 @@ async function startHappyServer(client, options) {
       agentGuidance.REPORT_PROGRESS_TOOL_NAME,
       ...agentGuidance.TEAM_TOOL_NAMES,
       ...agentGuidance.AUTOMATION_TOOL_NAMES,
+      ...agentGuidance.SESSION_PEER_TOOL_NAMES,
       ...options?.assistant && !process.env.VH_TEAM_SCOPE_FILE ? ASSISTANT_TOOL_NAMES : []
     ],
     stop: () => {
@@ -13470,6 +13051,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);
@@ -13646,7 +13261,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-okLyUzeD.cjs'); });
+    const { query } = await Promise.resolve().then(function () { return require('./index-CB8QnjvS.cjs'); });
     return runSideQuestion(query, input);
   });
   const run = async (input, live) => {
@@ -13765,7 +13380,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-eCjkm8Y2.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-BbtR-Qto.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();
@@ -14333,7 +13948,7 @@ async function runClaude(credentials, options = {}) {
   }
   try {
     persistence.logger.debug(`[START] Reporting session ${response.id} to daemon`);
-    const result = await index.notifyDaemonSessionStarted(response.id, metadata, {
+    const result = await persistence.notifyDaemonSessionStarted(response.id, metadata, {
       encryptionKey: persistence.encodeBase64(response.encryptionKey),
       encryptionVariant: response.encryptionVariant,
       seq: response.seq,
@@ -14433,6 +14048,17 @@ async function runClaude(credentials, options = {}) {
   });
   session.on("claude-session-message", (body) => boardAnalyzer.noteClaudeMessage(body));
   session.on("turn-ended", () => boardAnalyzer.onTurnEnd());
+  const editThrottle = new EditReportThrottle();
+  session.on("claude-session-message", (body) => {
+    try {
+      for (const edit of editThrottle.take(extractClaudeEditPaths(body))) {
+        persistence.reportSessionEditToDaemon({ sessionId: response.id, path: edit.path, tool: edit.tool, cwd: workingDirectory, ...edit.at !== void 0 ? { at: edit.at } : {} });
+      }
+    } catch (error) {
+      persistence.logger.debug("[START] edit report failed:", error);
+    }
+  });
+  options = { ...options, claudeEnvVars: { ...options.claudeEnvVars, VH_PEER_SESSION_ID: response.id } };
   const initialScannerSessionId = forkClaudeSessionId ?? (metadata.claudeSessionId ?? null);
   const remoteScanner = await createSessionScanner({
     sessionId: initialScannerSessionId,
@@ -14772,26 +14398,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();
       }
@@ -15064,7 +14688,7 @@ async function handleAuthLogin(args) {
     console.log(chalk.gray("  \u2022 Re-authenticate and register machine\n"));
     try {
       persistence.logger.debug("Stopping daemon for force auth...");
-      await index.stopDaemon();
+      await persistence.stopDaemon();
       console.log(chalk.gray("\u2713 Stopped daemon"));
     } catch (error) {
       persistence.logger.debug("Daemon was not running or failed to stop:", error);
@@ -15129,7 +14753,7 @@ async function handleAuthLogout() {
   if (answer.toLowerCase() === "y" || answer.toLowerCase() === "yes") {
     try {
       try {
-        await index.stopDaemon();
+        await persistence.stopDaemon();
         console.log(chalk.gray("Stopped daemon"));
       } catch {
       }
@@ -15174,7 +14798,7 @@ async function handleAuthStatus() {
   console.log(chalk.gray(`
   Data directory: ${persistence.configuration.happyHomeDir}`));
   try {
-    const running = await index.checkIfDaemonRunningAndCleanupStaleState();
+    const running = await persistence.checkIfDaemonRunningAndCleanupStaleState();
     if (running) {
       console.log(chalk.green("\u2713 Daemon running"));
     } else {
@@ -16000,9 +15624,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-eCjkm8Y2.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-BbtR-Qto.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-eCjkm8Y2.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-BbtR-Qto.cjs', document.baseURI).href)));
 const PRISMA_QUERY_ENGINE_FILES = {
   "arm64-darwin": "libquery_engine-darwin-arm64.dylib.node",
   "x64-darwin": "libquery_engine-darwin.dylib.node",
@@ -16391,7 +16015,7 @@ const DAEMON_READY_TIMEOUT_MS = 5e3;
 const DAEMON_READY_POLL_INTERVAL_MS = 100;
 async function ensureDaemonRunning() {
   persistence.logger.debug("Ensuring Happy background service is running & matches our version...");
-  const versionMatches = await index.isDaemonRunningCurrentlyInstalledHappyVersion();
+  const versionMatches = await persistence.isDaemonRunningCurrentlyInstalledHappyVersion();
   const state = await persistence.readDaemonState();
   const endpointsMatch = Boolean(state) && daemonEndpointsMatch(
     state?.serverUrl,
@@ -16402,9 +16026,9 @@ async function ensureDaemonRunning() {
   if (versionMatches && endpointsMatch) {
     return;
   }
-  if (await index.checkIfDaemonRunningAndCleanupStaleState()) {
+  if (await persistence.checkIfDaemonRunningAndCleanupStaleState()) {
     persistence.logger.debug("Stopping daemon whose version or configured relay no longer matches...");
-    await index.stopDaemon();
+    await persistence.stopDaemon();
   }
   persistence.logger.debug("Starting Happy background service...");
   const daemonProcess = spawnHappyCLI(["daemon", "start-sync"], {
@@ -16415,7 +16039,7 @@ async function ensureDaemonRunning() {
   daemonProcess.unref();
   const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
   while (Date.now() < deadline) {
-    if (await index.checkIfDaemonRunningAndCleanupStaleState()) {
+    if (await persistence.checkIfDaemonRunningAndCleanupStaleState()) {
       persistence.logger.debug("Happy background service is ready");
       return;
     }
@@ -18122,7 +17746,7 @@ async function runCodex(opts) {
   if (response) {
     try {
       persistence.logger.debug(`[START] Reporting session ${response.id} to daemon`);
-      const result = await index.notifyDaemonSessionStarted(response.id, metadata, {
+      const result = await persistence.notifyDaemonSessionStarted(response.id, metadata, {
         encryptionKey: persistence.encodeBase64(response.encryptionKey),
         encryptionVariant: response.encryptionVariant,
         seq: response.seq,
@@ -18419,6 +18043,7 @@ async function runCodex(opts) {
       return "denied";
     }
   });
+  const editThrottle = new EditReportThrottle();
   client.setEventHandler((msg) => {
     if (msg.type === "token_count") {
       session.sendAgentUsageSnapshot("codex", msg);
@@ -18482,6 +18107,9 @@ async function runCodex(opts) {
     }
     if (msg.type === "patch_apply_begin") {
       const { changes } = msg;
+      for (const edit of editThrottle.take(extractCodexPatchPaths(changes))) {
+        persistence.reportSessionEditToDaemon({ sessionId: session.sessionId, path: edit.path, tool: edit.tool, cwd: process.cwd() });
+      }
       const changeCount = Object.keys(changes).length;
       const filesMsg = changeCount === 1 ? "1 file" : `${changeCount} files`;
       messageBuffer.addMessage(`Modifying ${filesMsg}...`, "tool");
@@ -18527,6 +18155,7 @@ async function runCodex(opts) {
   };
   let first = true;
   let appendSystemPromptInjected = false;
+  process.env.VH_PEER_SESSION_ID = session.sessionId;
   try {
     persistence.logger.debug("[codex]: client.connect begin");
     await client.connect();
@@ -18940,7 +18569,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-CA4OcAS7.cjs'); });
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await Promise.resolve().then(function () { return require('./installTerminalHooks-BOAnQ1Qe.cjs'); });
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -18957,7 +18586,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-BUsLTZnz.cjs'); });
+      const { parseAgentHomeArgs, runAgentHomeCommand } = await Promise.resolve().then(function () { return require('./agentHome-CmIJNV7f.cjs'); });
       await runAgentHomeCommand(parseAgentHomeArgs(args.slice(1)));
       process.exit(0);
     } catch (error) {
@@ -18966,7 +18595,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-DxrfHTF4.cjs'); });
+      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-CC6V2KiA.cjs'); });
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18978,7 +18607,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-RIFUoy_g.cjs'); });
+      const { handleSessionsCommand } = await Promise.resolve().then(function () { return require('./sessions-OmvyJb0n.cjs'); });
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18990,7 +18619,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-Bd00QcHC.cjs'); });
+      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-CTcGMVuG.cjs'); });
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -19096,9 +18725,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-DM_xI9M6.cjs'); });
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./limits-CmzISka2.cjs'); }).then(function (n) { return n.persistence; });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-Bd_TGr0F.cjs'); }).then(function (n) { return n.api; });
+        const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return require('./config-BYHSRY2E.cjs'); });
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./limits-o29KXBgj.cjs'); }).then(function (n) { return n.persistence; });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-CphWjqHc.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -19129,7 +18758,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-DM_xI9M6.cjs'); });
+        const { readGeminiLocalConfig } = await Promise.resolve().then(function () { return require('./config-BYHSRY2E.cjs'); });
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -19169,7 +18798,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-CNPGSsSK.cjs'); });
+      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini--QqK-Ap5.cjs'); });
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -19192,7 +18821,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-fUogwxYr.cjs'); });
+        const { runPiTerminal } = await Promise.resolve().then(function () { return require('./piTerminal-D-BIbov9.cjs'); });
         process.exitCode = await runPiTerminal(args.slice(2));
       } catch (error) {
         console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -19209,7 +18838,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-BUxBxSxJ.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-B_-7NpGZ.cjs'); });
       const parsed = parsePiRunnerArgs(args.slice(1));
       const resolved = resolveAcpAgentConfig(["pi", ...parsed.passthrough]);
       const { credentials } = await authAndSetupMachineIfNeeded();
@@ -19237,7 +18866,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-BUxBxSxJ.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-B_-7NpGZ.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -19277,7 +18906,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-Bsodkg_s.cjs'); });
+      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-C0xLhTvk.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -19328,7 +18957,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-B4cBFzHB.cjs'); });
+      const { handleTodoCommand } = await Promise.resolve().then(function () { return require('./todo-CEDvKNXK.cjs'); });
       await handleTodoCommand(args.slice(1));
     } catch (error) {
       console.error(JSON.stringify({ error: error instanceof Error ? error.message : "Todo command failed" }));
@@ -19337,7 +18966,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-Cfy0VMCo.cjs'); });
+      const { handleTeamsCommand } = await Promise.resolve().then(function () { return require('./teams-XtrH3_h3.cjs'); });
       await handleTeamsCommand(args.slice(1));
     } catch (error) {
       console.error(error instanceof Error ? error.message : "Teams command failed");
@@ -19346,7 +18975,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-IeldARBS.cjs'); });
+      const { handleAutoCommand } = await Promise.resolve().then(function () { return require('./auto-CMDq4oIu.cjs'); });
       await handleAutoCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Automation command failed");
@@ -19358,7 +18987,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-7iDHlyCI.cjs'); });
+      const { handleMcpCommand } = await Promise.resolve().then(function () { return require('./mcp-CwK1nI7Y.cjs'); });
       await handleMcpCommand(args[1] === "--terminal-tools");
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}
@@ -19381,12 +19010,14 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     const daemonSubcommand = args[1];
     if (daemonSubcommand === "list") {
       try {
-        const sessions = await index.listDaemonSessions();
+        const sessions = await persistence.listDaemonSessions();
         if (sessions.length === 0) {
           console.log("No active sessions this daemon is aware of (they might have been started by a previous version of the daemon)");
         } 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(", ")}`);
         }
       } catch (error) {
         console.log("No daemon running");
@@ -19399,7 +19030,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
         process.exit(1);
       }
       try {
-        const success = await index.stopDaemonSession(sessionId);
+        const success = await persistence.stopDaemonSession(sessionId);
         console.log(success ? "Session stopped" : "Failed to stop session");
       } catch (error) {
         console.log("No daemon running");
@@ -19407,7 +19038,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       return;
     } else if (daemonSubcommand === "start") {
       const currentState = await persistence.readDaemonState();
-      const running = await index.checkIfDaemonRunningAndCleanupStaleState();
+      const running = await persistence.checkIfDaemonRunningAndCleanupStaleState();
       const currentDaemonMatches = currentState && currentState.startedWithCliVersion === persistence.configuration.currentCliVersion && daemonEndpointsMatch(
         currentState.serverUrl,
         currentState.webappUrl,
@@ -19415,18 +19046,24 @@ 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 index.stopDaemon();
+        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;
       for (let i = 0; i < 50; i++) {
-        if (await index.checkIfDaemonRunningAndCleanupStaleState()) {
+        if (await persistence.checkIfDaemonRunningAndCleanupStaleState()) {
           started = true;
           break;
         }
@@ -19443,7 +19080,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       await startDaemon();
       process.exit(0);
     } else if (daemonSubcommand === "stop") {
-      await index.stopDaemon();
+      await persistence.stopDaemon();
       process.exit(0);
     } else if (daemonSubcommand === "status") {
       await runDoctorDaemon();
@@ -19734,11 +19371,10 @@ exports.BaseReasoningProcessor = BaseReasoningProcessor;
 exports.CHANGE_TITLE_INSTRUCTION = CHANGE_TITLE_INSTRUCTION;
 exports.CLAUDE_ATTACHMENT_KINDS = CLAUDE_ATTACHMENT_KINDS;
 exports.DEFAULT_GEMINI_MODEL = DEFAULT_GEMINI_MODEL;
-exports.DEFAULT_RECENT_LIMIT = DEFAULT_RECENT_LIMIT;
+exports.EditReportThrottle = EditReportThrottle;
 exports.GEMINI_API_KEY_ENV = GEMINI_API_KEY_ENV;
 exports.GEMINI_MODEL_ENV = GEMINI_MODEL_ENV;
 exports.GOOGLE_API_KEY_ENV = GOOGLE_API_KEY_ENV;
-exports.MAX_READ_LIMIT = MAX_READ_LIMIT;
 exports.MessageBuffer = MessageBuffer;
 exports.MessageQueue2 = MessageQueue2;
 exports.PI_TEAMS_EXTENSION = PI_TEAMS_EXTENSION;
@@ -19746,41 +19382,29 @@ exports.SPAWN_AGENTS = SPAWN_AGENTS;
 exports.StreamRelay = StreamRelay;
 exports.TEAM_SKILL = TEAM_SKILL;
 exports.TitleGenerator = TitleGenerator;
-exports.TurnWaitTimeoutError = TurnWaitTimeoutError;
 exports.appendStagedAttachmentsToPrompt = appendStagedAttachmentsToPrompt;
-exports.archiveSession = archiveSession;
 exports.checkPreviewPath = checkPreviewPath;
 exports.createSessionMetadata = createSessionMetadata;
-exports.deliverToSession = deliverToSession;
 exports.describeAction = describeAction;
 exports.describeTrigger = describeTrigger;
+exports.extractAcpEditPaths = extractAcpEditPaths;
 exports.hashObject = hashObject;
 exports.initialMachineMetadata = initialMachineMetadata;
 exports.isValidSpawnOrigin = isValidSpawnOrigin;
-exports.listAccountSessions = listAccountSessions;
-exports.listSessions = listSessions;
 exports.normalizeAcpPermissionMode = normalizeAcpPermissionMode;
 exports.parseDuration = parseDuration;
 exports.query = query;
-exports.readSessionMetadata = readSessionMetadata;
-exports.readSessionTranscript = readSessionTranscript;
 exports.registerAgentAttachmentDownloads = registerAgentAttachmentDownloads;
 exports.registerAssistantSessionTools = registerAssistantSessionTools;
 exports.registerKillSessionHandler = registerKillSessionHandler;
 exports.removeSessionModeFile = removeSessionModeFile;
 exports.resolveFirstMessageMeta = resolveFirstMessageMeta;
-exports.resolvePermissionRequest = resolvePermissionRequest;
 exports.resolveSpawnPermissionMode = resolveSpawnPermissionMode;
 exports.sanitizeSpawnPermissionMode = sanitizeSpawnPermissionMode;
-exports.sendUserMessage = sendUserMessage;
-exports.sessionWebUrl = sessionWebUrl;
 exports.setupOfflineReconnection = setupOfflineReconnection;
 exports.stageClaudeAttachments = stageClaudeAttachments;
 exports.startHappyServer = startHappyServer;
-exports.stopSession = stopSession;
 exports.suggestTitleForPrompt = suggestTitleForPrompt;
 exports.tmuxSupportsSessionEnv = tmuxSupportsSessionEnv;
 exports.triggerFromFlags = triggerFromFlags;
-exports.waitForSessionKey = waitForSessionKey;
-exports.waitForTurnEnd = waitForTurnEnd;
 exports.writeSessionModeFile = writeSessionModeFile;