very-happy-cli 0.2.154 → 0.2.156

package/dist/{index-BELV05ko.mjs → index-DAAreiRF.mjs}

@@ -1,14 +1,14 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
 import os, { homedir, userInfo, tmpdir } from 'node:os';
 import { randomUUID, randomInt, randomBytes, createHash as createHash$1, timingSafeEqual } from 'node:crypto';
-import { v as notifyDaemonSessionEvent, g as getProjectPath, w as initializeSandbox, x as wrapCommand, u as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, c as delay, y as AsyncLock, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, z as notifyDaemonClaudeAuthFailed, B as commandOnPath, j as checkIfDaemonRunningAndCleanupStaleState, D as deriveLocalCliUpdateSummary, E as isClaudeSessionId, G as getLocalHappyAgentCredentialPath, H as readLocalHappyAgentCredentials, J as parseExactVersion, K as compareExactVersions, L as extractCompleteLines, N as decideBackfill, O as parseTerminalHookPayload, P as tmuxArgs, Q as scrubTmuxClientEnv, S as decideMirrorBinding, T as MIRROR_BACKFILL_LINES_DEFAULT, U as mirrorLineKey, V as mirrorLocalId, W as listDaemonSessions, k as stopDaemonSession, X as detectCLIAvailability, Y as detectResumeSupport, Z as refreshAgentHomes, d as describeAgentHome, _ as isDaemonRunningCurrentlyInstalledHappyVersion, $ as stopDaemon, a0 as TurnActivityTracker, a1 as summarizeSpawnSessionForLog, a2 as locateClaudeConversation, a3 as agentHomeSpawnEnv, a4 as shellescape, A as ApiClient, a5 as fetchCliUpdateState, a6 as resolveCliUpdateCheckInterval, a7 as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, a8 as cleanupDaemonState, a9 as resumeDaemonSession, i as isValidSessionId, s as spawnDaemonSession, aa as listVhTerminals, ab as isValidTerminalId, ac as readVhTerminal, ad as sendToVhTerminal, ae as TITLE_PROMPT_PREFIX, af as BOARD_ANALYZER_PROMPT_PREFIX, o as connectionState, ag as startOfflineReconnection, q as notifyDaemonSessionStarted, C as CodexAppServerClient } from './types-D5RWyBE5.mjs';
-import { l as logger, k as BUILTIN_TODO_DISCOVERY, U as STREAM_DELTA_MAX_CHARS, V as ensurePrivateDirectory, W as hardenPrivateFile, c as configuration, p as packageJson, r as readSettings, X as readCredentials, L as credentialRelayProblem, F as readDaemonState, Y as AGENT_VERSION_SOURCES, j as encodeBase64, Z as readSettingsOutcome, u as updateSettings, _ as encodeBase64Url, E as decodeBase64, $ as writeCredentialsLegacy, a0 as writeCredentialsDataKey, f as readCredentialsForConfiguredRelay, z as encrypt, d as readPersistedSessions, w as writePrivateFileSync, a1 as decryptWithDataKey, a2 as decryptLegacy, a3 as persistSession, D as decrypt, m as ensurePrivateDirectorySync, a4 as getAgentCodeDefaults, a5 as normalizeAgentKey, a6 as isClaudeOpus55Model, a7 as supportsClaudeOpus55, a8 as AUTOMATION_SUMMARY_MAX_CHARS, a9 as AUTOMATION_CLAIM_MAX_RUNS, aa as AUTOMATION_DEFAULT_LEASE_MS, i as isAutomationRunTerminal, ab as acquireDaemonLock, ac as deletePersistedSessions, ad as writeDaemonState, ae as writeSettings, af as releaseDaemonLock, ag as ContextUsageSchema, C as CLIPBOARD_TOOL_NAME, a as CLIPBOARD_TOOL_TITLE, b as CLIPBOARD_TOOL_DESCRIPTION, h as CLIPBOARD_MAX_BYTES, ah as clearCredentials, ai as clearMachineId, aj as SandboxConfigSchema, e as createEnvelope, ak as getLatestDaemonLog } from './limits-Dt7_unH4.mjs';
+import { g as getProjectPath, k as initializeSandbox, w as wrapCommand, j as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, l as AsyncLock, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, m as commandOnPath, n as deriveLocalCliUpdateSummary, o as isClaudeSessionId, q as getLocalHappyAgentCredentialPath, s as readLocalHappyAgentCredentials, t as parseExactVersion, u as compareExactVersions, v as extractCompleteLines, x as decideBackfill, y as parseTerminalHookPayload, z as tmuxArgs, B as scrubTmuxClientEnv, D as decideMirrorBinding, E as MIRROR_BACKFILL_LINES_DEFAULT, G as mirrorLineKey, H as mirrorLocalId, J as detectCLIAvailability, K as detectResumeSupport, L as refreshAgentHomes, d as describeAgentHome, T as TurnActivityTracker, N as summarizeSpawnSessionForLog, O as locateClaudeConversation, P as agentHomeSpawnEnv, Q as shellescape, A as ApiClient, S as fetchCliUpdateState, U as resolveCliUpdateCheckInterval, V as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, W as listVhTerminals, X as readVhTerminal, Y as sendToVhTerminal, Z as TITLE_PROMPT_PREFIX, _ as BOARD_ANALYZER_PROMPT_PREFIX, h as connectionState, $ as startOfflineReconnection, C as CodexAppServerClient } from './types-BEVzYSoV.mjs';
+import { l as logger, a7 as notifyDaemonSessionEvent, x as BUILTIN_TODO_DISCOVERY, g as delay, a8 as STREAM_DELTA_MAX_CHARS, a9 as ensurePrivateDirectory, aa as hardenPrivateFile, c as configuration, ab as notifyDaemonClaudeAuthFailed, F as packageJson, r as readSettings, ac as readCredentials, Z as credentialRelayProblem, k as checkIfDaemonRunningAndCleanupStaleState, ad as readDaemonState, ae as AGENT_VERSION_SOURCES, w as encodeBase64, af as readSettingsOutcome, u as updateSettings, ag as encodeBase64Url, M as decodeBase64, ah as writeCredentialsLegacy, ai as writeCredentialsDataKey, d as readPersistedSessions, E as writePrivateFileSync, aj as decryptWithDataKey, ak as decryptLegacy, al as persistSession, z as ensurePrivateDirectorySync, am as getAgentCodeDefaults, an as normalizeAgentKey, ao as isClaudeOpus55Model, ap as supportsClaudeOpus55, aq as AUTOMATION_SUMMARY_MAX_CHARS, ar as AUTOMATION_CLAIM_MAX_RUNS, as as AUTOMATION_DEFAULT_LEASE_MS, f as isAutomationRunTerminal, at as isDaemonRunningCurrentlyInstalledHappyVersion, au as stopDaemon, av as acquireDaemonLock, aw as deletePersistedSessions, N as decrypt, ax as writeDaemonState, ay as writeSettings, az as cleanupDaemonState, aA as releaseDaemonLock, i as isValidSessionId, m as spawnDaemonSession, a1 as isValidTerminalId, aB as ContextUsageSchema, C as CLIPBOARD_TOOL_NAME, a as CLIPBOARD_TOOL_TITLE, b as CLIPBOARD_TOOL_DESCRIPTION, o as CLIPBOARD_MAX_BYTES, v as notifyDaemonSessionStarted, y as reportSessionEditToDaemon, aC as clearCredentials, aD as clearMachineId, h as readCredentialsForConfiguredRelay, aE as SandboxConfigSchema, e as createEnvelope, O as listDaemonSessions, n as stopDaemonSession, aF as getLatestDaemonLog } from './limits-DmMdchTz.mjs';
 import spawn$1, { spawn } from 'cross-spawn';
 import path, { join, resolve, basename, delimiter, isAbsolute, dirname, sep, normalize } from 'node:path';
 import { createInterface } from 'node:readline';
 import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, realpathSync, unlinkSync, renameSync, writeFileSync, accessSync, constants as constants$1, openSync, fsyncSync, closeSync, rmSync as rmSync$1, chmodSync as chmodSync$1 } from 'node:fs';
 import { p as projectPath } from './terminalTitleSuggest-DKgX3osW.mjs';
-import { j as trimIdent, k as AGENT_GUIDANCE, l as createAutomationsClient, i as isAutomationsUnavailable, m as AutomationsRequestError, t as teamScopePath, T as TeamConnectionPreflightError, h as createTeamsClient, P as PREVIEW_TOOL_NAME, R as REPORT_PROGRESS_TOOL_NAME, n as TEAM_TOOL_NAMES, o as AUTOMATION_TOOL_NAMES, r as registerTeamsTools, c as registerAutomationTools, a as PREVIEW_TOOL_TITLE, b as PREVIEW_TOOL_DESCRIPTION, p as REPORT_PROGRESS_TOOL_TITLE, q as REPORT_PROGRESS_TOOL_DESCRIPTION } from './agentGuidance-TLYQxsm2.mjs';
+import { E as trimIdent, F as AGENT_GUIDANCE, G as formatEditConflictNotice, z as sendUserMessage, S as SESSION_PEER_SENT_FROM, x as readSessionMetadata, y as waitForSessionKey, k as archiveSession, H as createAutomationsClient, t as isAutomationsUnavailable, I as AutomationsRequestError, J as analyzeLatestTurn, K as readSessionLog$1, L as TURN_WINDOW, N as userPromptText, v as teamScopePath, O as TeamConnectionPreflightError, C as createTeamsClient, e as listSessions, h as readSessionTranscript, n as deliverToSession, o as sessionWebUrl, i as stopSession, P as PREVIEW_TOOL_NAME, R as REPORT_PROGRESS_TOOL_NAME, Q as TEAM_TOOL_NAMES, U as AUTOMATION_TOOL_NAMES, V as SESSION_PEER_TOOL_NAMES, r as registerTeamsTools, c as registerAutomationTools, d as registerSessionPeerTools, W as createSessionPeerToolExecutor, a as PREVIEW_TOOL_TITLE, b as PREVIEW_TOOL_DESCRIPTION, X as REPORT_PROGRESS_TOOL_TITLE, Y as REPORT_PROGRESS_TOOL_DESCRIPTION } from './agentGuidance-C604n0Zq.mjs';
 import { readFile, writeFile, rename, unlink, mkdir, access as access$1, symlink, rm, readlink, lstat, constants, stat, open as open$1, appendFile } from 'node:fs/promises';
 import fs, { watch, access } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
@@ -16,7 +16,7 @@ import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { query as query$1, AbortError } from '@anthropic-ai/claude-agent-sdk';
 import axios, { AxiosError } from 'axios';
 import 'node:events';
-import { io } from 'socket.io-client';
+import 'socket.io-client';
 import tweetnacl from 'tweetnacl';
 import os$1, { homedir as homedir$1 } from 'os';
 import { spawn as spawn$2, execSync as execSync$1, exec as exec$1 } from 'child_process';
@@ -878,7 +878,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);
     logger.debug(`[SESSION_SCANNER] Marking ${messages.length} existing messages as processed from session ${opts.sessionId}`);
     for (let m of messages) {
       processedMessageKeys.add(messageKey(m));
@@ -901,7 +901,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) {
@@ -978,7 +978,7 @@ async function createSessionScanner(opts) {
         return;
       }
       if (options?.treatExistingAsProcessed) {
-        const existing = await readSessionLog$1(projectDir, sessionId);
+        const existing = await readSessionLog(projectDir, sessionId);
         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));
@@ -1006,7 +1006,7 @@ function messageKey(message) {
     throw Error();
   }
 }
-async function readSessionLog$1(projectDir, sessionId) {
+async function readSessionLog(projectDir, sessionId) {
   const expectedSessionFile = join(projectDir, `${sessionId}.jsonl`);
   logger.debug(`[SESSION_SCANNER] Reading session file: ${expectedSessionFile}`);
   let file;
@@ -5380,8 +5380,8 @@ ${typeLabels[type] || type}:`));
   }
   console.log(chalk.gray("  An external claude command is only needed for native terminal/mirror use."));
   try {
-    const { resolveAgentHomesForCli } = await import('./agentHome-B20RWdgE.mjs');
-    const { describeAgentHome } = await import('./types-D5RWyBE5.mjs').then(function (n) { return n.ah; });
+    const { resolveAgentHomesForCli } = await import('./agentHome-D2XGsoqs.mjs');
+    const { describeAgentHome } = await import('./types-BEVzYSoV.mjs').then(function (n) { return n.a0; });
     const homes = await resolveAgentHomesForCli();
     console.log(chalk.green(`\u2713 Claude config dir: ${describeAgentHome(homes.claudeConfigDir)}`));
     console.log(chalk.green(`\u2713 Codex home: ${describeAgentHome(homes.codexHome)}`));
@@ -6063,59 +6063,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 `${configuration.webappUrl.replace(/\/+$/, "")}/session/${sessionId}`;
-}
-async function waitForSessionKey(sessionId, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (true) {
-    const entry = readPersistedSessions()[sessionId];
-    if (entry) return entry;
-    if (Date.now() >= deadline) {
-      throw new Error(
-        `Session ${sessionId} has no encryption key in ${configuration.sessionsFile}. Either it was not spawned by this machine's daemon, or the daemon is too old to persist session keys.`
-      );
-    }
-    await delay(200);
-  }
-}
-async function sendUserMessage(sessionId, persisted, text, client, options = {}) {
-  const credentials = await readCredentialsForConfiguredRelay();
-  if (!credentials) {
-    throw new Error("Not authenticated. Run `very-happy auth login` first.");
-  }
-  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 = encodeBase64(encrypt(
-    decodeBase64(persisted.encryptionKey),
-    persisted.encryptionVariant,
-    envelope
-  ));
-  await axios.post(
-    `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(sessionId)}/messages`,
-    { messages: [{ content: encrypted, localId: options.localId ?? randomUUID() }] },
-    {
-      headers: {
-        "Authorization": `Bearer ${credentials.token}`,
-        "Content-Type": "application/json",
-        "X-Happy-Client": `${client}/${configuration.currentCliVersion}`
-      },
-      timeout: 3e4
-    }
-  );
-}
-
 const ALLOWED_SPAWN_PERMISSION_MODES = [
   "default",
   "acceptEdits",
@@ -6271,7 +6218,10 @@ function startDaemonControlServer({
   pushClipboard,
   pushFilePreview,
   onTerminalHook,
-  setTerminalTitle
+  setTerminalTitle,
+  onSessionEdit,
+  listPeers,
+  isTurnActive
 }) {
   return new Promise((resolve) => {
     const app = fastify({
@@ -6355,7 +6305,8 @@ function startDaemonControlServer({
             children: z.array(z.object({
               startedBy: z.string(),
               happySessionId: z.string(),
-              pid: z.number()
+              pid: z.number(),
+              turnActive: z.boolean()
             }))
           })
         }
@@ -6367,7 +6318,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
         }))
       };
     });
@@ -6594,6 +6546,45 @@ function startDaemonControlServer({
       }
       return { status: "ok" };
     });
+    typed.post("/session-edit", {
+      schema: {
+        body: z.object({
+          sessionId: z.string().regex(/^[a-zA-Z0-9_-]{1,128}$/),
+          path: z.string().min(1).max(4096),
+          tool: z.string().min(1).max(64),
+          cwd: 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.number().int().nonnegative().optional()
+        }),
+        response: { 200: z.object({ status: z.literal("ok") }) }
+      }
+    }, async (request) => {
+      try {
+        onSessionEdit?.(request.body);
+      } catch (error) {
+        logger.debug("[CONTROL SERVER] session-edit handler failed:", error);
+      }
+      return { status: "ok" };
+    });
+    typed.post("/peers", {
+      schema: {
+        response: {
+          200: z.object({
+            sessions: z.array(z.object({
+              sessionId: z.string(),
+              kind: z.enum(["managed", "mirror"]),
+              pid: z.number().optional(),
+              cwd: z.string().optional(),
+              flavor: z.string().optional(),
+              title: z.string().optional(),
+              variant: z.string().optional(),
+              edits: z.array(z.object({ path: z.string(), tool: z.string(), at: z.number() }))
+            }))
+          })
+        }
+      }
+    }, async () => ({ sessions: listPeers ? listPeers() : [] }));
     typed.post("/stop", {
       schema: {
         response: {
@@ -6629,6 +6620,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, cwd, realpath = realpathSync.native ?? realpathSync) {
+  const absolute = isAbsolute(path) ? resolve(path) : resolve(cwd, path);
+  let existing = absolute;
+  const tail = [];
+  for (let depth = 0; depth < 64; depth++) {
+    try {
+      const real = realpath(existing);
+      return tail.length ? join(real, ...tail) : real;
+    } catch {
+      const parent = dirname(existing);
+      if (parent === existing) break;
+      tail.unshift(existing.slice(parent.length).replace(new RegExp(`^\\${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 ?? readPersistedSessions;
+  const send = deps.send ?? sendUserMessage;
+  const normalize = deps.normalize ?? normalizeEditPath;
+  const liveTitle = deps.liveTitle ?? (async (sessionId, persisted) => (await 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) {
+      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 = formatEditConflictNotice({ id: noticeId, path: paths[0], paths, peer: peerSender, peerEditedAgoMs, windowMs });
+    try {
+      await send(recipient.sessionId, persisted, text, "edit-conflict", {
+        sentFrom: SESSION_PEER_SENT_FROM,
+        delivery: "steer",
+        localId: `edit-conflict-${noticeId}-${recipient.sessionId}`
+      });
+      logger.debug(`[PEERS] conflict notice ${noticeId} \u2192 ${recipient.sessionId} (${paths.length} file(s), first ${paths[0]}, peer ${peerId})`);
+    } catch (error) {
+      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);
+      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 = 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) {
+        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) {
+        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
@@ -8548,6 +8806,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 = [];
@@ -8584,12 +8909,15 @@ function createMirrorScanner(opts) {
       }
       tail.offset = 0;
     }
+    let replaced = false;
     if (tail.offset > size) {
       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 open$1(tail.path, "r");
     let buf;
     try {
@@ -8609,7 +8937,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 InvalidateSync(async () => {
     for (const tail of files.values()) {
@@ -8732,8 +9060,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) {
+            logger.debug(`[MIRROR] edit tap failed for terminal ${binding.terminalId}:`, error);
+          }
+        }
+      }
       const key = mirrorLineKey(message);
       binding.client.sendClaudeSessionMessage(message, key ? { localIdFor: (envelopeIndex) => mirrorLocalId(key, envelopeIndex) } : void 0);
     }
@@ -8742,7 +9079,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`
@@ -8765,6 +9102,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(),
@@ -8772,9 +9113,9 @@ function createMirrorManager(deps) {
       archiveReason: reason
     });
     try {
-      await deps.api.deactivateSession(binding.happySessionId);
+      await deps.api.archiveSession(binding.happySessionId);
     } catch (error) {
-      logger.debug(`[MIRROR] deactivateSession failed for ${binding.happySessionId}:`, error);
+      logger.debug(`[MIRROR] archiveSession failed for ${binding.happySessionId}:`, error);
     }
     deps.onBindingsChanged?.();
   };
@@ -8977,6 +9318,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 = parseTerminalHookPayload(body);
       if (!event) {
@@ -9443,683 +9791,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 = io(configuration.serverUrl, {
-    auth: {
-      token,
-      clientType: "user-scoped",
-      happyClient: `cli-session-ops/${configuration.currentCliVersion}`
-    },
-    path: "/v1/updates",
-    transports: ["websocket"],
-    reconnection: false,
-    autoConnect: false
-  });
-  await new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      socket.close();
-      reject(new Error(`Timed out connecting to ${configuration.serverUrl}`));
-    }, options.connectTimeoutMs ?? USER_SOCKET_CONNECT_TIMEOUT_MS);
-    socket.once("connect", () => {
-      clearTimeout(timer);
-      resolve();
-    });
-    socket.once("connect_error", (error) => {
-      clearTimeout(timer);
-      socket.close();
-      reject(new Error(`Could not connect to ${configuration.serverUrl}: ${error.message}`));
-    });
-    socket.connect();
-  });
-  return {
-    async rpcCall(payload, timeoutMs) {
-      const ack = await socket.timeout(timeoutMs).emitWithAck("rpc-call", payload);
-      return ack;
-    },
-    close() {
-      socket.close();
-    }
-  };
-}
-
-const RPC_RATE_LIMIT_ERROR = "RPC rate limit reached";
-const RPC_ACCOUNT_RATE_LIMIT_ERROR = "RPC account rate limit reached";
-const RPC_RATE_RETRY_MIN_DELAY_MS = 2e3;
-const RPC_RATE_RETRY_MAX_DELAY_MS = 6e4;
-const RPC_RATE_MAX_RETRIES = 2;
-function isRpcRateLimitAck(ack) {
-  if (!ack || typeof ack !== "object") return false;
-  const a = ack;
-  if (a.ok !== false) return false;
-  if (a.code === "rpc_rate_limited" || a.code === "rpc_account_rate_limited") return true;
-  return a.error === RPC_RATE_LIMIT_ERROR || a.error === RPC_ACCOUNT_RATE_LIMIT_ERROR;
-}
-function rpcRateRetryDelayMs(attempt, retryAfterMs, random = Math.random()) {
-  if (typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs > 0) {
-    return Math.min(RPC_RATE_RETRY_MAX_DELAY_MS, Math.round(retryAfterMs * (1 + random * 0.5)));
-  }
-  const exponent = Math.max(0, Math.min(attempt, 32) - 1);
-  const ceiling = Math.min(RPC_RATE_RETRY_MIN_DELAY_MS * 2 ** exponent, RPC_RATE_RETRY_MAX_DELAY_MS);
-  return Math.round(RPC_RATE_RETRY_MIN_DELAY_MS + random * (ceiling - RPC_RATE_RETRY_MIN_DELAY_MS));
-}
-
-const PERMISSION_OPS_CLIENT = "session-ops";
-const PERMISSION_RPC_TIMEOUT_MS = 3e4;
-const SETTLE_TIMEOUT_MS = 5e3;
-const SETTLE_POLL_MS = 500;
-function buildPermissionRpcPayload(requestId, verdict) {
-  if (verdict.kind === "approve") {
-    return {
-      id: requestId,
-      approved: true,
-      decision: verdict.forSession ? "approved_for_session" : "approved"
-    };
-  }
-  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 ?? readPersistedSessions)()[sessionId];
-  if (!persisted) {
-    throw new Error(
-      `No local key for session ${sessionId} \u2014 approve/deny needs the session key from ~/.happy/sessions.json (the RPC payload is encrypted with it), so only sessions this machine's daemon spawned within 14 days can be answered from here.`
-    );
-  }
-  const token = await (deps.bearerToken ?? bearerToken$1)();
-  const fetchState = deps.fetchAgentState ?? fetchDecryptedAgentState;
-  const before = pendingRequestsOf(await fetchState(sessionId, persisted, token), now());
-  if (!before.some((request) => request.id === requestId)) {
-    const hint = before.length > 0 ? `Pending request ids: ${before.map((request) => `${request.id} (${request.tool})`).join(", ")}` : "The session has no pending requests.";
-    throw new Error(`Request ${requestId} is not pending on session ${sessionId}. ${hint}`);
-  }
-  const payload = buildPermissionRpcPayload(requestId, verdict);
-  const key = decodeBase64(persisted.encryptionKey);
-  const params = encodeBase64(encrypt(key, persisted.encryptionVariant, payload));
-  const transport = await (deps.openTransport ?? openUserScopedSocket)(token);
-  const rpcTimeoutMs = deps.rpcTimeoutMs ?? PERMISSION_RPC_TIMEOUT_MS;
-  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-  let ack;
-  try {
-    for (let attempt = 1; ; attempt++) {
-      try {
-        ack = await withDeadline(
-          transport.rpcCall({ method: `${sessionId}:permission`, params }, rpcTimeoutMs),
-          rpcTimeoutMs + RPC_DEADLINE_GRACE_MS,
-          `permission RPC did not settle within ${rpcTimeoutMs}ms`
-        );
-      } catch (error) {
-        ack = { ok: false, error: error instanceof Error ? error.message : "RPC call failed" };
-      }
-      if (!isRpcRateLimitAck(ack) || attempt > RPC_RATE_MAX_RETRIES) break;
-      const waitMs = rpcRateRetryDelayMs(attempt, ack.retryAfterMs, (deps.random ?? Math.random)());
-      deps.onRateLimited?.({ attempt, waitMs, serverError: ack.error ?? "RPC rate limit reached" });
-      await sleep(waitMs);
-    }
-  } finally {
-    transport.close();
-  }
-  const outcome = interpretPermissionAck(ack, (encrypted) => decrypt(key, persisted.encryptionVariant, decodeBase64(encrypted)));
-  if (outcome.status !== "acknowledged") {
-    return { sessionId, requestId, payload, outcome };
-  }
-  const deadline = now() + (deps.settleTimeoutMs ?? SETTLE_TIMEOUT_MS);
-  let settled = false;
-  for (; ; ) {
-    const pending = pendingRequestsOf(await fetchState(sessionId, persisted, token), now());
-    if (!pending.some((request) => request.id === requestId)) {
-      settled = true;
-      break;
-    }
-    if (now() >= deadline) break;
-    await sleep(SETTLE_POLL_MS);
-  }
-  return { sessionId, requestId, payload, outcome, settled };
-}
-async function bearerToken$1() {
-  const credentials = await readCredentialsForConfiguredRelay();
-  if (!credentials) throw new Error("CLI is not authenticated (no ~/.happy/access.key)");
-  return credentials.token;
-}
-async function fetchDecryptedAgentState(sessionId, persisted, token) {
-  const response = await axios.get(
-    `${configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`,
-    {
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "X-Happy-Client": `${PERMISSION_OPS_CLIENT}/${configuration.currentCliVersion}`
-      },
-      timeout: 15e3,
-      // 404 is a real answer ("not yours / gone"), not a transport fault.
-      validateStatus: (status) => status >= 200 && status < 300 || status === 404
-    }
-  );
-  if (response.status === 404) {
-    throw new Error(`Session ${sessionId} was not found on this account (it may have been deleted, or the local key belongs to a session on another relay).`);
-  }
-  const raw = response.data?.session?.agentState;
-  if (typeof raw !== "string" || raw.length === 0) return null;
-  return decrypt(decodeBase64(persisted.encryptionKey), persisted.encryptionVariant, decodeBase64(raw));
-}
-
-const SESSION_OPS_CLIENT = "session-ops";
-const DEFAULT_RECENT_LIMIT = 15;
-const MAX_READ_LIMIT = 100;
-function mergeSessionSummaries(live, persisted, options = {}) {
-  const recentLimit = Math.max(0, options.recentLimit ?? DEFAULT_RECENT_LIMIT);
-  const seen = /* @__PURE__ */ new Set();
-  const summaries = [];
-  for (const child of live) {
-    const id = typeof child.happySessionId === "string" ? child.happySessionId : void 0;
-    if (!id || seen.has(id)) continue;
-    seen.add(id);
-    summaries.push(toSummary(id, persisted[id], livenessOf(child)));
-  }
-  const rest = Object.entries(persisted).filter(([id]) => !seen.has(id)).filter(([, entry]) => entry.metadata?.flavor !== "terminal-mirror").sort((a, b) => b[1].savedAt - a[1].savedAt).slice(0, recentLimit);
-  for (const [id, entry] of rest) {
-    summaries.push(toSummary(id, entry, { live: false }));
-  }
-  if (!options.tag) return summaries;
-  const wanted = options.tag;
-  return summaries.filter((summary) => summary.tags?.includes(wanted) === true);
-}
-function livenessOf(child) {
-  return { live: true, pid: typeof child.pid === "number" ? child.pid : void 0 };
-}
-function sessionLiveness(live, sessionId) {
-  const child = live.find((entry) => entry.happySessionId === sessionId);
-  return child ? livenessOf(child) : { live: false };
-}
-function toSummary(id, persisted, extra) {
-  const meta = persisted?.metadata;
-  return {
-    id,
-    live: extra.live,
-    ...extra.pid !== void 0 ? { pid: extra.pid } : {},
-    ...meta?.summary?.text ? { title: meta.summary.text } : {},
-    ...meta?.path ? { cwd: meta.path } : {},
-    ...meta?.flavor ? { flavor: meta.flavor } : {},
-    ...meta?.tags?.length ? { tags: [...meta.tags] } : {},
-    ...meta?.variant ? { variant: meta.variant } : {},
-    url: sessionWebUrl(id),
-    ...persisted?.savedAt !== void 0 ? { savedAt: persisted.savedAt } : {}
-  };
-}
-async function listSessions(options = {}) {
-  const live = await listDaemonSessions();
-  return mergeSessionSummaries(live, readPersistedSessions(), options);
-}
-function summarizeAccountSession(row, persisted, liveIds, now) {
-  const base = {
-    id: row.id,
-    live: liveIds.has(row.id),
-    url: sessionWebUrl(row.id),
-    decryptable: false,
-    active: row.active === true,
-    archived: typeof row.archivedAt === "number",
-    ...typeof row.activeAt === "number" ? { activeAt: row.activeAt } : {},
-    ...typeof row.updatedAt === "number" ? { updatedAt: row.updatedAt } : {},
-    attention: false
-  };
-  if (!persisted) return base;
-  const key = decodeBase64(persisted.encryptionKey);
-  let metadata = null;
-  let agentState = null;
-  try {
-    metadata = row.metadata ? decrypt(key, persisted.encryptionVariant, decodeBase64(row.metadata)) : null;
-    agentState = row.agentState ? decrypt(key, persisted.encryptionVariant, decodeBase64(row.agentState)) : null;
-  } catch {
-    return base;
-  }
-  if (!metadata) return base;
-  const meta = metadata;
-  const pending = pendingRequestsOf(agentState, now);
-  return {
-    ...base,
-    decryptable: true,
-    ...meta.summary?.text ? { title: meta.summary.text } : {},
-    ...meta.path ? { cwd: meta.path } : {},
-    ...meta.flavor ? { flavor: meta.flavor } : {},
-    ...meta.tags?.length ? { tags: [...meta.tags] } : {},
-    ...meta.variant ? { variant: meta.variant } : {},
-    ...meta.machineId ? { machineId: meta.machineId } : {},
-    ...persisted.savedAt !== void 0 ? { savedAt: persisted.savedAt } : {},
-    pending,
-    attention: pending.length > 0
-  };
-}
-function orderAccountSessions(summaries, options = {}) {
-  const oldestWait = (summary) => Math.max(0, ...(summary.pending ?? []).map((request) => request.waitingMs ?? 0));
-  const rank = (summary) => summary.attention ? 0 : summary.live ? 1 : 2;
-  let rows = summaries.filter((summary) => summary.flavor !== "terminal-mirror").slice().sort((a, b) => {
-    const byRank = rank(a) - rank(b);
-    if (byRank !== 0) return byRank;
-    if (a.attention && b.attention) return oldestWait(b) - oldestWait(a);
-    return (b.updatedAt ?? 0) - (a.updatedAt ?? 0);
-  });
-  if (options.tag) {
-    const wanted = options.tag;
-    rows = rows.filter((summary) => summary.tags?.includes(wanted) === true);
-  }
-  const recentLimit = Math.max(0, options.recentLimit ?? DEFAULT_RECENT_LIMIT);
-  let idleKept = 0;
-  return rows.filter((summary) => rank(summary) < 2 || idleKept++ < recentLimit);
-}
-async function listAccountSessions(options = {}) {
-  const token = await bearerToken();
-  const response = await axios.get(`${configuration.serverUrl}/v1/sessions`, {
-    headers: {
-      "Authorization": `Bearer ${token}`,
-      "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.currentCliVersion}`
-    },
-    timeout: 15e3
-  });
-  const rows = Array.isArray(response.data?.sessions) ? response.data.sessions : [];
-  const persisted = readPersistedSessions();
-  const live = await listDaemonSessions();
-  const liveIds = new Set(live.map((child) => child.happySessionId).filter((id) => typeof id === "string"));
-  const now = Date.now();
-  const summaries = rows.filter((row) => typeof row?.id === "string").map((row) => summarizeAccountSession(row, persisted[row.id], liveIds, now)).filter((summary) => options.includeArchived || !summary.archived);
-  return orderAccountSessions(summaries, options);
-}
-async function bearerToken() {
-  const credentials = await readCredentialsForConfiguredRelay();
-  if (!credentials) throw new Error("CLI is not authenticated (no ~/.happy/access.key)");
-  return credentials.token;
-}
-function requirePersisted(sessionId) {
-  const persisted = readPersistedSessions()[sessionId];
-  if (!persisted) {
-    throw new Error(
-      `No local key for session ${sessionId} \u2014 it was not spawned by this machine's daemon (or is older than 14 days).`
-    );
-  }
-  return persisted;
-}
-async function readSessionLog(sessionId, persisted, limit) {
-  const token = await bearerToken();
-  const response = await axios.get(
-    `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(sessionId)}/messages`,
-    {
-      params: { before_seq: 2147483647, limit },
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.currentCliVersion}`
-      },
-      timeout: 15e3
-    }
-  );
-  const messages = Array.isArray(response.data?.messages) ? response.data.messages : [];
-  messages.reverse();
-  const key = decodeBase64(persisted.encryptionKey);
-  return messages.map((message) => {
-    if (message.content?.t !== "encrypted") return { seq: message.seq, body: null };
-    try {
-      return { seq: message.seq, body: decrypt(key, persisted.encryptionVariant, 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 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(`${configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`, {
-    headers: {
-      "Authorization": `Bearer ${token}`,
-      "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.currentCliVersion}`
-    },
-    timeout: 15e3
-  });
-  const ciphertext = response.data?.session?.metadata;
-  if (typeof ciphertext !== "string" || ciphertext.length === 0) return null;
-  return decrypt(decodeBase64(persisted.encryptionKey), persisted.encryptionVariant, decodeBase64(ciphertext));
-}
-async function readSessionState(sessionId, persisted) {
-  const token = await bearerToken();
-  const response = await axios.get(`${configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`, {
-    headers: {
-      "Authorization": `Bearer ${token}`,
-      "X-Happy-Client": `${SESSION_OPS_CLIENT}/${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 = decrypt(decodeBase64(persisted.encryptionKey), persisted.encryptionVariant, 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 stopDaemonSession(sessionId);
-}
-async function archiveSession(sessionId) {
-  const token = await bearerToken();
-  await axios.post(
-    `${configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}/archive`,
-    {},
-    {
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.currentCliVersion}`
-      },
-      timeout: 1e4
-    }
-  );
-}
-async function unarchiveSession(sessionId) {
-  const token = await bearerToken();
-  await axios.post(
-    `${configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}/unarchive`,
-    {},
-    {
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.currentCliVersion}`
-      },
-      timeout: 1e4
-    }
-  );
-}
-
 function receiptPath(home, operationId) {
   if (!/^[a-zA-Z0-9_-]{1,128}$/.test(operationId)) throw new Error("Invalid team operation id");
   return join(home, "teams", "effects", `${operationId}.json`);
@@ -10709,7 +10380,7 @@ function automationRunAnchor(runId) {
 async function defaultReadTurn(sessionId, runId) {
   const persisted = 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 analyzeLatestTurn(await readSessionLog$1(sessionId, persisted, TURN_WINDOW), { anchor: automationRunAnchor(runId) });
 }
 async function defaultSend(sessionId, text, meta) {
   const persisted = await waitForSessionKey(sessionId, 15e3);
@@ -11053,6 +10724,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) {
@@ -11208,6 +10889,7 @@ async function startDaemon() {
     logger.debug("[DAEMON RUN] Auth and machine setup complete");
     const pidToTrackedSession = /* @__PURE__ */ new Map();
     const turnActivity = new TurnActivityTracker();
+    const peerCoordinator = createPeerCoordinator({ getChildren: () => Array.from(pidToTrackedSession.values()) });
     const sessionIdToFinishedSession = /* @__PURE__ */ new Map();
     let teamWorker;
     let automationRunner;
@@ -12067,6 +11749,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);
         logger.debug(`[DAEMON RUN] Process PID ${pid} exited, preserved session ${session.happySessionId} for resume`);
@@ -12152,6 +11835,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" };
@@ -12171,6 +11861,8 @@ async function startDaemon() {
       }
     });
     const daemonClaudeCredentials = resolveClaudeCredentialReadiness();
+    const daemonSupervisor = detectDaemonSupervisor(process.env);
+    logger.debug(`[DAEMON RUN] Supervisor: ${daemonSupervisor}`);
     let fileState = {
       pid: process.pid,
       httpPort: controlPort,
@@ -12180,7 +11872,8 @@ async function startDaemon() {
       serverUrl: configuration.serverUrl,
       webappUrl: configuration.webappUrl,
       daemonLogPath: logger.logFilePath,
-      claudeCredentialSource: daemonClaudeCredentials.source
+      claudeCredentialSource: daemonClaudeCredentials.source,
+      supervisor: daemonSupervisor
     };
     writeDaemonState(fileState);
     logger.debug("[DAEMON RUN] Daemon state written");
@@ -12217,9 +11910,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),
@@ -12350,6 +12046,10 @@ async function startDaemon() {
             await cleanupDaemonState();
             await releaseDaemonLock(daemonLockHandle);
             await stopCaffeinate();
+            if (daemonSupervisor === "systemd") {
+              logger.debug(`[DAEMON RUN] systemd-supervised: exiting ${HANDOVER_EXIT_CODE} for the unit to restart on the new bundle`);
+              process.exit(HANDOVER_EXIT_CODE);
+            }
             try {
               spawnHappyCLI(["daemon", "start"], {
                 detached: true,
@@ -12551,127 +12251,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: () => listDaemonSessions(),
-  readState: (sessionId, persisted) => readSessionState(sessionId, persisted),
-  send: (sessionId, persisted, text, client, options) => sendUserMessage(sessionId, persisted, text, client, options),
-  unarchive: unarchiveSession,
-  archive: archiveSession,
-  resume: resumeDaemonSession,
-  sleep: (ms) => 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);
@@ -13038,13 +12617,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 McpServer({
     name: "Very Happy Tools",
     version: "1.0.0"
   });
   registerTeamsTools(mcp, sessionId);
   registerAutomationTools(mcp);
+  if (client) registerSessionPeerTools(mcp, createSessionPeerToolExecutor(client));
   mcp.registerTool("change_title", {
     description: "Change the title of the current chat session",
     title: "Change Chat Title",
@@ -13247,7 +12827,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 StreamableHTTPServerTransport({
         sessionIdGenerator: void 0
@@ -13288,6 +12868,7 @@ async function startHappyServer(client, options) {
       REPORT_PROGRESS_TOOL_NAME,
       ...TEAM_TOOL_NAMES,
       ...AUTOMATION_TOOL_NAMES,
+      ...SESSION_PEER_TOOL_NAMES,
       ...options?.assistant && !process.env.VH_TEAM_SCOPE_FILE ? ASSISTANT_TOOL_NAMES : []
     ],
     stop: () => {
@@ -13448,6 +13029,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);
@@ -13624,7 +13239,7 @@ function registerSideQuestionHandler(rpc, deps) {
   const retainMs = deps.retainMs ?? SIDE_QUESTION_RETAIN_MS;
   const maxRunMs = deps.maxRunMs ?? SIDE_QUESTION_MAX_RUN_MS;
   const fork = deps.run ?? (async (input) => {
-    const { query } = await import('./index-CIx3248o.mjs');
+    const { query } = await import('./index-PYO8Mdz4.mjs');
     return runSideQuestion(query, input);
   });
   const run = async (input, live) => {
@@ -14411,6 +14026,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))) {
+        reportSessionEditToDaemon({ sessionId: response.id, path: edit.path, tool: edit.tool, cwd: workingDirectory, ...edit.at !== void 0 ? { at: edit.at } : {} });
+      }
+    } catch (error) {
+      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,
@@ -14750,26 +14376,24 @@ async function runClaude(credentials, options = {}) {
       hasMetadata: Boolean(message.meta)
     });
   });
+  const exitGate = new SessionExitGate();
   const cleanup = async (opts = { archive: true }) => {
-    logger.debug(`[START] Received termination signal, cleaning up (archive=${opts.archive ?? true})...`);
+    const intent = exitGate.claim(exitIntentFromArchiveFlag(opts.archive));
+    if (intent === null) {
+      logger.debug(`[START] Termination (archive=${opts.archive ?? true}) ignored: cleanup already running as ${exitGate.current}`);
+      return;
+    }
+    logger.debug(`[START] Received termination signal, cleaning up (archive=${intent === "archive"})...`);
     try {
       if (session) {
-        if (opts.archive ?? true) {
-          session.updateMetadata((currentMetadata) => ({
-            ...currentMetadata,
-            lifecycleState: "archived",
-            lifecycleStateSince: Date.now(),
-            archivedBy: "cli",
-            archiveReason: "User terminated"
-          }));
-        }
         currentSession?.cleanup();
-        session.sendSessionDeath();
-        try {
-          await api.deactivateSession(session.sessionId);
-        } catch (err) {
-          logger.debug("[START] deactivateSession during cleanup failed:", err);
-        }
+        await settleSessionOnExit(session.sessionId, intent, {
+          updateMetadata: (handler) => session.updateMetadata(handler),
+          sendSessionDeath: () => session.sendSessionDeath(),
+          archiveSession: (id) => api.archiveSession(id),
+          deactivateSession: (id) => api.deactivateSession(id),
+          log: (message, ...args) => logger.debug(message, ...args)
+        });
         await session.flush();
         await session.close();
       }
@@ -18397,6 +18021,7 @@ async function runCodex(opts) {
       return "denied";
     }
   });
+  const editThrottle = new EditReportThrottle();
   client.setEventHandler((msg) => {
     if (msg.type === "token_count") {
       session.sendAgentUsageSnapshot("codex", msg);
@@ -18460,6 +18085,9 @@ async function runCodex(opts) {
     }
     if (msg.type === "patch_apply_begin") {
       const { changes } = msg;
+      for (const edit of editThrottle.take(extractCodexPatchPaths(changes))) {
+        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");
@@ -18505,6 +18133,7 @@ async function runCodex(opts) {
   };
   let first = true;
   let appendSystemPromptInjected = false;
+  process.env.VH_PEER_SESSION_ID = session.sessionId;
   try {
     logger.debug("[codex]: client.connect begin");
     await client.connect();
@@ -18918,7 +18547,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "install-terminal-hooks") {
     try {
-      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-Dde_8t36.mjs');
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-CMpOV3RU.mjs');
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -18935,7 +18564,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "agent-home") {
     try {
-      const { parseAgentHomeArgs, runAgentHomeCommand } = await import('./agentHome-B20RWdgE.mjs');
+      const { parseAgentHomeArgs, runAgentHomeCommand } = await import('./agentHome-D2XGsoqs.mjs');
       await runAgentHomeCommand(parseAgentHomeArgs(args.slice(1)));
       process.exit(0);
     } catch (error) {
@@ -18944,7 +18573,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "spawn") {
     try {
-      const { handleSpawnCommand } = await import('./spawn-D1bhyHbH.mjs');
+      const { handleSpawnCommand } = await import('./spawn-BKNabutV.mjs');
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18956,7 +18585,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "sessions") {
     try {
-      const { handleSessionsCommand } = await import('./sessions-DlPOYKLU.mjs');
+      const { handleSessionsCommand } = await import('./sessions-Bn304xF1.mjs');
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18968,7 +18597,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "send") {
     try {
-      const { handleSendCommand } = await import('./send-DYeSFg8s.mjs');
+      const { handleSendCommand } = await import('./send-BaOkDgH0.mjs');
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -19074,9 +18703,9 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     if (geminiSubcommand === "project" && args[2] === "set" && args[3]) {
       const projectId = args[3];
       try {
-        const { saveGoogleCloudProjectToConfig } = await import('./config-B-ocQh5V.mjs');
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./limits-Dt7_unH4.mjs').then(function (n) { return n.al; });
-        const { ApiClient: ApiClient2 } = await import('./types-D5RWyBE5.mjs').then(function (n) { return n.ai; });
+        const { saveGoogleCloudProjectToConfig } = await import('./config-BkTu25bH.mjs');
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./limits-DmMdchTz.mjs').then(function (n) { return n.aG; });
+        const { ApiClient: ApiClient2 } = await import('./types-BEVzYSoV.mjs').then(function (n) { return n.a1; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -19107,7 +18736,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
     if (geminiSubcommand === "project" && args[2] === "get") {
       try {
-        const { readGeminiLocalConfig } = await import('./config-B-ocQh5V.mjs');
+        const { readGeminiLocalConfig } = await import('./config-BkTu25bH.mjs');
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -19147,7 +18776,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await import('./runGemini-BW-pEklU.mjs');
+      const { runGemini } = await import('./runGemini-CZ_lhMWY.mjs');
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -19170,7 +18799,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
   } else if (subcommand === "pi") {
     if (args[1] === "--terminal") {
       try {
-        const { runPiTerminal } = await import('./piTerminal-CCEGCQOY.mjs');
+        const { runPiTerminal } = await import('./piTerminal-DanZeBrO.mjs');
         process.exitCode = await runPiTerminal(args.slice(2));
       } catch (error) {
         console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -19187,7 +18816,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       }
     };
     try {
-      const { runAcp, resolveAcpAgentConfig } = await import('./index-ZKuBjvHi.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-B5QbzEga.mjs');
       const parsed = parsePiRunnerArgs(args.slice(1));
       const resolved = resolveAcpAgentConfig(["pi", ...parsed.passthrough]);
       const { credentials } = await authAndSetupMachineIfNeeded();
@@ -19215,7 +18844,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "acp") {
     try {
-      const { runAcp, resolveAcpAgentConfig } = await import('./index-ZKuBjvHi.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-B5QbzEga.mjs');
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -19255,7 +18884,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "openclaw") {
     try {
-      const { runOpenClaw } = await import('./runOpenClaw-NRB6-_jU.mjs');
+      const { runOpenClaw } = await import('./runOpenClaw-CxgLpm38.mjs');
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -19306,7 +18935,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "todo") {
     try {
-      const { handleTodoCommand } = await import('./todo-B2CjDg_V.mjs');
+      const { handleTodoCommand } = await import('./todo-BcPbNKt2.mjs');
       await handleTodoCommand(args.slice(1));
     } catch (error) {
       console.error(JSON.stringify({ error: error instanceof Error ? error.message : "Todo command failed" }));
@@ -19315,7 +18944,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "teams") {
     try {
-      const { handleTeamsCommand } = await import('./teams-pfKHpkgL.mjs');
+      const { handleTeamsCommand } = await import('./teams-CLbS2_4Q.mjs');
       await handleTeamsCommand(args.slice(1));
     } catch (error) {
       console.error(error instanceof Error ? error.message : "Teams command failed");
@@ -19324,7 +18953,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "auto") {
     try {
-      const { handleAutoCommand } = await import('./auto-BQnncDcs.mjs');
+      const { handleAutoCommand } = await import('./auto-B1I6G_Nf.mjs');
       await handleAutoCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Automation command failed");
@@ -19336,7 +18965,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "mcp" && (args.length === 1 || args.length === 2 && args[1] === "--terminal-tools")) {
     try {
-      const { handleMcpCommand } = await import('./mcp-9Ui4nQZL.mjs');
+      const { handleMcpCommand } = await import('./mcp-C_uejotl.mjs');
       await handleMcpCommand(args[1] === "--terminal-tools");
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}
@@ -19365,6 +18994,8 @@ Conversation history is preserved on the server, but in-flight tool calls are in
         } else {
           console.log("Active sessions:");
           console.log(JSON.stringify(sessions, null, 2));
+          const busy = sessions.filter((s) => s.turnActive === true);
+          console.log(busy.length === 0 ? "No turn in flight on this machine (wrappers older than 0.2.139 do not report turns)." : `${busy.length} session(s) with a turn in flight: ${busy.map((s) => s.happySessionId).join(", ")}`);
         }
       } catch (error) {
         console.log("No daemon running");
@@ -19393,13 +19024,19 @@ Conversation history is preserved on the server, but in-flight tool calls are in
         configuration.webappUrl
       );
       if (running && !currentDaemonMatches) {
+        if (currentState?.supervisor === "systemd") {
+          console.error(`The running daemon is supervised by systemd; hand over through the unit instead:
+  ${SYSTEMD_RESTART_HINT}`);
+          process.exit(1);
+        }
         console.log("Configured relay or CLI version changed; restarting the existing daemon");
         await stopDaemon();
       }
+      const { HAPPY_DAEMON_SUPERVISOR: _supervisor, INVOCATION_ID: _invocation, ...detachedEnv } = process.env;
       const child = spawnHappyCLI(["daemon", "start-sync"], {
         detached: true,
         stdio: "ignore",
-        env: process.env
+        env: detachedEnv
       });
       child.unref();
       let started = false;
@@ -19706,4 +19343,4 @@ ${chalk.bold("Examples:")}
   }
 }
 
-export { BaseReasoningProcessor as $, ALLOWED_SPAWN_PERMISSION_MODES as A, TEAM_SKILL as B, initialMachineMetadata as C, DEFAULT_RECENT_LIMIT as D, createSessionMetadata as E, setupOfflineReconnection as F, GEMINI_MODEL_ENV as G, StreamRelay as H, MessageQueue2 as I, hashObject as J, startHappyServer as K, registerAgentAttachmentDownloads as L, MAX_READ_LIMIT as M, TitleGenerator as N, registerKillSessionHandler as O, PI_TEAMS_EXTENSION as P, CLAUDE_ATTACHMENT_KINDS as Q, stageClaudeAttachments as R, SPAWN_AGENTS as S, TurnWaitTimeoutError as T, appendStagedAttachmentsToPrompt as U, BasePermissionHandler as V, writeSessionModeFile as W, normalizeAcpPermissionMode as X, removeSessionModeFile as Y, GEMINI_API_KEY_ENV as Z, GOOGLE_API_KEY_ENV as _, listSessions as a, MessageBuffer as a0, CHANGE_TITLE_INSTRUCTION as a1, resolvePermissionRequest as b, archiveSession as c, deliverToSession as d, sessionWebUrl as e, DEFAULT_GEMINI_MODEL as f, describeTrigger as g, describeAction as h, sanitizeSpawnPermissionMode as i, tmuxSupportsSessionEnv as j, readSessionMetadata as k, listAccountSessions as l, resolveSpawnPermissionMode as m, resolveFirstMessageMeta as n, isValidSpawnOrigin as o, parseDuration as p, query as q, readSessionTranscript as r, stopSession as s, triggerFromFlags as t, waitForSessionKey as u, sendUserMessage as v, waitForTurnEnd as w, checkPreviewPath as x, registerAssistantSessionTools as y, suggestTitleForPrompt as z };
+export { ALLOWED_SPAWN_PERMISSION_MODES as A, BasePermissionHandler as B, CLAUDE_ATTACHMENT_KINDS as C, DEFAULT_GEMINI_MODEL as D, EditReportThrottle as E, normalizeAcpPermissionMode as F, GEMINI_MODEL_ENV as G, removeSessionModeFile as H, GEMINI_API_KEY_ENV as I, GOOGLE_API_KEY_ENV as J, BaseReasoningProcessor as K, MessageBuffer as L, MessageQueue2 as M, CHANGE_TITLE_INSTRUCTION as N, PI_TEAMS_EXTENSION as P, SPAWN_AGENTS as S, TEAM_SKILL as T, describeAction as a, tmuxSupportsSessionEnv as b, resolveFirstMessageMeta as c, describeTrigger as d, checkPreviewPath as e, registerAssistantSessionTools as f, suggestTitleForPrompt as g, initialMachineMetadata as h, isValidSpawnOrigin as i, createSessionMetadata as j, setupOfflineReconnection as k, StreamRelay as l, hashObject as m, startHappyServer as n, registerAgentAttachmentDownloads as o, parseDuration as p, query as q, resolveSpawnPermissionMode as r, sanitizeSpawnPermissionMode as s, triggerFromFlags as t, TitleGenerator as u, registerKillSessionHandler as v, stageClaudeAttachments as w, appendStagedAttachmentsToPrompt as x, extractAcpEditPaths as y, writeSessionModeFile as z };