@hydra-acp/cli 0.1.29 → 0.1.31

package/README.md

@@ -259,6 +259,20 @@ hydra-acp --name "$BUFFER_NAME" launch claude-acp
 
 After the first user prompt lands, hydra automatically replaces the label with the first line of that prompt (truncated, ≤80 chars) and emits a `session_info_update` so every attached client (TUI, slack, browser) refreshes its header. Agents that emit their own `session_info_update` override that — last write wins.
 
+### Read-only viewer (`--readonly`)
+
+Sometimes you want to scroll through a session's transcript — usually one imported from another machine — without spawning the underlying agent. Pass `--readonly` to `tui` to attach in view-only mode:
+
+```text
+hydra-acp tui --resume <id> --readonly
+```
+
+The daemon enforces the contract: a `readonly: true` attach to a *cold* session takes a viewer path that streams history straight from disk — no `manager.resurrect`, no agent process. Any mutating JSON-RPC method (`session/prompt`, `session/cancel`, `session/set_model`, and the `hydra-acp/*` prompt-mutation methods) sent from a read-only connection is refused with `-32011 PermissionDenied`. History replay and `session/update` deliveries are unchanged, so the existing scrollback search (`^R` when scrolled back) works over the full transcript.
+
+The TUI suppresses the composer entirely — those rows go to scrollback so you see more of the conversation. The window title is suffixed `[VIEW ONLY]` so the mode is unambiguous. Prompt-shaped keys (Enter, Shift+Enter, Shift+Tab) are inert; `^P`, `^G`, `^L`, `^R`, `PgUp/PgDn`, `^C`, `^D` work as usual.
+
+From inside the TUI's session picker, **`v`** on a selected row enters view-only mode for that session. Enter still attaches normally. The mode is per-session: `^P` → pick another with Enter drops out of read-only; `v` re-enters it.
+
 ### Slash commands (typed in any composer)
 
 Slash commands of the form `/hydra <verb> [args]` are intercepted by hydra before the prompt reaches the agent. They never appear in the conversation log; the only client-visible signal is the notification(s) the verb implies.

package/dist/cli.js

@@ -584,6 +584,12 @@ var init_types = __esm({
         name: z3.string(),
         version: z3.string().optional()
       }).optional(),
+      // When true, the connection observes the session but cannot mutate
+      // it: state-changing methods (session/prompt, session/cancel,
+      // session/set_model, etc.) are rejected with -32011, and attaching
+      // to a cold session does not resurrect or spawn an agent — just
+      // streams history from disk. Used by the TUI's view-only mode.
+      readonly: z3.boolean().optional(),
       _meta: z3.record(z3.unknown()).optional()
     });
     HYDRA_META_KEY = "hydra-acp";
@@ -5413,6 +5419,15 @@ var init_discovery = __esm({
 
 // src/tui/picker.ts
 async function pickSession(term, opts) {
+  process.stdout.write("\x1B[<u");
+  process.stdout.write("\x1B[?2004l");
+  process.stdout.write("\x1B[>4;0m");
+  process.stdout.write("\x1B[>5;0m");
+  process.stdout.write("\x1B[?1000l");
+  process.stdout.write("\x1B[?1002l");
+  process.stdout.write("\x1B[?1006l");
+  process.stdout.write("\x1B[?1l");
+  process.stdout.write("\x1B>");
   if (opts.sessions.length === 0) {
     return { kind: "new" };
   }
@@ -5947,6 +5962,23 @@ async function pickSession(term, opts) {
           void refresh(currentId);
           return;
         }
+        if ((name === "v" || name === "V") && selectedIdx > 0) {
+          const session = visible[selectedIdx - 1];
+          if (!session) {
+            return;
+          }
+          cleanup();
+          const result = {
+            kind: "attach",
+            sessionId: session.sessionId,
+            readonly: true
+          };
+          if (session.agentId !== void 0) {
+            result.agentId = session.agentId;
+          }
+          resolve5(result);
+          return;
+        }
         if ((name === "k" || name === "K") && selectedIdx > 0) {
           const session = visible[selectedIdx - 1];
           if (!session) {
@@ -6134,6 +6166,7 @@ var init_picker = __esm({
       ["PgUp / PgDn", "page up / page down"],
       ["Home / End", "first / last"],
       ["Enter", "open selected session (or create new)"],
+      ["v", "view-only (open transcript without spawning the agent)"],
       null,
       ["/", "search sessions"],
       ["o", "toggle cwd-only filter"],
@@ -6807,6 +6840,110 @@ function mapKeyName(name) {
       return null;
   }
 }
+function emergencyTerminalReset() {
+  const seq = [
+    "\x1B[?1000l",
+    // mouse button reporting off
+    "\x1B[?1002l",
+    // mouse drag reporting off
+    "\x1B[?1003l",
+    // mouse any-motion reporting off
+    "\x1B[?1006l",
+    // SGR mouse mode off
+    "\x1B[?1015l",
+    // urxvt mouse mode off
+    "\x1B[?2004l",
+    // bracketed paste off
+    "\x1B[>4;0m",
+    // xterm modifyOtherKeys off
+    "\x1B[>5;0m",
+    // xterm formatOtherKeys off
+    "\x1B[<u",
+    // pop kitty keyboard stack
+    "\x1B[?1l",
+    // DECCKM off: arrows send CSI A/B/C/D not SS3 O A/B/C/D
+    "\x1B>",
+    // DECPAM off: numeric keypad mode
+    "\x1B[?7h",
+    // auto-wrap on
+    "\x1B[?25h",
+    // show cursor
+    "\x1B]9;4;0\x07",
+    // clear OSC 9;4 progress indicator
+    "\x1B[?1049l"
+    // leave alternate screen
+  ].join("");
+  try {
+    process.stdout.write(seq);
+  } catch {
+  }
+}
+function mapCsiUToKeyName(code, mod) {
+  const CTRL_LETTERS = {
+    97: "ctrl-a",
+    98: "ctrl-b",
+    99: "ctrl-c",
+    100: "ctrl-d",
+    101: "ctrl-e",
+    102: "ctrl-f",
+    103: "ctrl-g",
+    107: "ctrl-k",
+    108: "ctrl-l",
+    110: "ctrl-n",
+    111: "ctrl-o",
+    112: "ctrl-p",
+    114: "ctrl-r",
+    115: "ctrl-s",
+    116: "ctrl-t",
+    117: "ctrl-u",
+    118: "ctrl-v",
+    119: "ctrl-w",
+    121: "ctrl-y"
+  };
+  if (mod === 5) {
+    return CTRL_LETTERS[code] ?? null;
+  }
+  if (code === 27) {
+    return "escape";
+  }
+  if (code === 9) {
+    if (mod === 2) {
+      return "shift-tab";
+    }
+    if (mod === 1) {
+      return "tab";
+    }
+    return null;
+  }
+  if (code === 13) {
+    if (mod === 2) {
+      return "shift-enter";
+    }
+    if (mod === 3) {
+      return "alt-enter";
+    }
+    if (mod === 5) {
+      return "ctrl-enter";
+    }
+    if (mod === 1) {
+      return "enter";
+    }
+    return null;
+  }
+  if (code === 127 && mod === 1) {
+    return "backspace";
+  }
+  if (mod === 3) {
+    if (code === 98 || code === 66) {
+      return "alt-b";
+    }
+    if (code === 102 || code === 70) {
+      return "alt-f";
+    }
+    return null;
+  }
+  return null;
+}
 var SESSIONBAR_ROWS, BANNER_ROWS, SEPARATOR_ROWS, MAX_PROMPT_ROWS, MAX_QUEUED_ROWS, MAX_PERMISSION_ROWS, MAX_HELP_ROWS, MAX_COMPLETION_ROWS, MAX_CHIP_ROWS, CONFIRM_PROMPT_ROWS, DEFAULT_CONTENT_REPAINT_THROTTLE_MS, DEFAULT_MAX_SCROLLBACK_LINES, BARE_URL_RE, Screen, NON_ASCII, SEGMENTER, TK_MARKUP_STYLE_CHAR, shortId;
 var init_screen = __esm({
   "src/tui/screen.ts"() {
@@ -6935,11 +7072,25 @@ var init_screen = __esm({
       rawStdinHandler;
       mouseEnabled;
       progressIndicatorEnabled;
+      // Listeners registered on process via installEmergencyCleanup so an
+      // ungraceful exit (SIGTERM, SIGHUP, uncaughtException) still restores
+      // mouse capture / alt-screen / kitty stack / cursor visibility — the
+      // graceful stop() path isn't guaranteed to run in those cases and
+      // would otherwise leave the host terminal wedged.
+      emergencyCleanupInstalled = false;
+      onProcessExit = null;
+      onProcessSignal = null;
+      onProcessUncaught = null;
       // Last OSC 9;4 state we wrote (3 = indeterminate, 0 = remove). Used to
       // suppress redundant writes when setBanner runs but `status` didn't
       // actually change, and to re-emit on start() if a picker round-trip
       // cleared the host terminal's indicator.
       lastProgressState = 0;
+      // View-only mode. Set once at construction. When true, promptRows()
+      // returns 0 (composer collapses, scrollback expands), drawPrompt()
+      // bails before computing layout, and syncWindowTitle() appends
+      // "[VIEW ONLY]" so the chrome makes the mode obvious.
+      readonly;
       constructor(opts) {
         this.term = opts.term;
         this.dispatcher = opts.dispatcher;
@@ -6948,6 +7099,7 @@ var init_screen = __esm({
         this.maxScrollbackLines = opts.maxScrollbackLines ?? DEFAULT_MAX_SCROLLBACK_LINES;
         this.mouseEnabled = opts.mouse ?? true;
         this.progressIndicatorEnabled = opts.progressIndicator ?? true;
+        this.readonly = opts.readonly ?? false;
         this.resizeHandler = () => this.repaint();
         this.keyHandler = (name, _matches, data) => this.handleKey(name, data);
         this.mouseHandler = (name) => this.handleMouse(name);
@@ -6976,6 +7128,7 @@ var init_screen = __esm({
         }
         this.term.on("resize", this.resizeHandler);
         this.installBracketedPaste();
+        this.installEmergencyCleanup();
         this.lastProgressState = 0;
         this.writeProgressIndicator(this.banner.status === "busy" ? 3 : 0);
         this.repaint();
@@ -6993,6 +7146,7 @@ var init_screen = __esm({
           this.throttledRepaintTimer = null;
         }
         this.uninstallBracketedPaste();
+        this.uninstallEmergencyCleanup();
         this.term.off("key", this.keyHandler);
         if (this.mouseEnabled) {
           this.term.off("mouse", this.mouseHandler);
@@ -7028,6 +7182,8 @@ var init_screen = __esm({
         process.stdout.write("\x1B[>4;0m");
         process.stdout.write("\x1B[>5;0m");
         process.stdout.write("\x1B[<u");
+        process.stdout.write("\x1B[?1l");
+        process.stdout.write("\x1B>");
         const t = this.term;
         if (!t.stdin || this.terminalKitStdinHandler === null) {
           return;
@@ -7038,72 +7194,109 @@ var init_screen = __esm({
         this.pasteActive = false;
         this.pasteBuffer = "";
       }
+      installEmergencyCleanup() {
+        if (this.emergencyCleanupInstalled) {
+          return;
+        }
+        this.emergencyCleanupInstalled = true;
+        this.onProcessExit = () => emergencyTerminalReset();
+        this.onProcessSignal = (sig) => {
+          emergencyTerminalReset();
+          process.off(sig, this.onProcessSignal);
+          process.kill(process.pid, sig);
+        };
+        this.onProcessUncaught = (err) => {
+          emergencyTerminalReset();
+          process.stderr.write(`
+uncaught: ${err.stack ?? err.message}
+`);
+          process.exit(1);
+        };
+        process.on("exit", this.onProcessExit);
+        process.on("SIGTERM", this.onProcessSignal);
+        process.on("SIGHUP", this.onProcessSignal);
+        process.on("uncaughtException", this.onProcessUncaught);
+      }
+      uninstallEmergencyCleanup() {
+        if (!this.emergencyCleanupInstalled) {
+          return;
+        }
+        this.emergencyCleanupInstalled = false;
+        if (this.onProcessExit) {
+          process.off("exit", this.onProcessExit);
+          this.onProcessExit = null;
+        }
+        if (this.onProcessSignal) {
+          process.off("SIGTERM", this.onProcessSignal);
+          process.off("SIGHUP", this.onProcessSignal);
+          this.onProcessSignal = null;
+        }
+        if (this.onProcessUncaught) {
+          process.off("uncaughtException", this.onProcessUncaught);
+          this.onProcessUncaught = null;
+        }
+      }
       handleRawStdin(chunk) {
-        let text = chunk.toString("binary");
-        if (!this.pasteActive) {
-          const markers = [
-            { seq: "\x1B[13;2u", name: "shift-enter" },
-            { seq: "\x1B[27;2;13~", name: "shift-enter" },
-            { seq: "\x1B[13;5u", name: "ctrl-enter" },
-            { seq: "\x1B[27;5;13~", name: "ctrl-enter" },
-            // Bare LF — universal fallback for terminals without
-            // modifyOtherKeys / kitty protocol. Last so the longer escape
-            // sequences match first and we don't double-fire.
-            { seq: "\n", name: "ctrl-enter" }
-          ];
-          for (const { seq, name } of markers) {
-            if (text.includes(seq)) {
-              const parts = text.split(seq);
-              for (let i = 0; i < parts.length; i++) {
-                if (parts[i].length > 0) {
-                  this.handleRawStdin(Buffer.from(parts[i], "binary"));
-                }
-                if (i < parts.length - 1) {
-                  this.onKey([{ type: "key", name }]);
-                }
+        const text = chunk.toString("binary");
+        if (this.pasteActive) {
+          this.handleRawStdinSegment(text);
+          return;
+        }
+        const legacyMarkers = [
+          { seq: "\x1B[27;2;13~", name: "shift-enter" },
+          { seq: "\x1B[27;5;13~", name: "ctrl-enter" },
+          // Bare LF — universal fallback for terminals without
+          // modifyOtherKeys / kitty protocol. Last so the longer escape
+          // sequences match first and we don't double-fire.
+          { seq: "\n", name: "ctrl-enter" }
+        ];
+        for (const { seq, name } of legacyMarkers) {
+          if (text.includes(seq)) {
+            const parts = text.split(seq);
+            for (let i = 0; i < parts.length; i++) {
+              if (parts[i].length > 0) {
+                this.handleRawStdin(Buffer.from(parts[i], "binary"));
               }
-              return;
-            }
-          }
-          const csiUCtrlMap = {
-            97: "ctrl-a",
-            98: "ctrl-b",
-            99: "ctrl-c",
-            100: "ctrl-d",
-            101: "ctrl-e",
-            102: "ctrl-f",
-            103: "ctrl-g",
-            107: "ctrl-k",
-            108: "ctrl-l",
-            110: "ctrl-n",
-            111: "ctrl-o",
-            112: "ctrl-p",
-            114: "ctrl-r",
-            115: "ctrl-s",
-            116: "ctrl-t",
-            117: "ctrl-u",
-            118: "ctrl-v",
-            119: "ctrl-w",
-            121: "ctrl-y"
-          };
-          const csiUCtrlRe = /\x1b\[(\d+);5u/;
-          const m = csiUCtrlRe.exec(text);
-          if (m !== null) {
-            const keyName = csiUCtrlMap[parseInt(m[1], 10)];
-            if (keyName !== void 0) {
-              const parts = text.split(m[0]);
-              for (let i = 0; i < parts.length; i++) {
-                if (parts[i].length > 0)
-                  this.handleRawStdin(Buffer.from(parts[i], "binary"));
-                if (i < parts.length - 1)
-                  this.onKey([{ type: "key", name: keyName }]);
+              if (i < parts.length - 1) {
+                this.onKey([{ type: "key", name }]);
               }
-              return;
             }
+            return;
           }
         }
+        if (text.includes("\x1B[") && /\x1b\[\d+(?:;\d+)?u/.test(text)) {
+          this.handleCsiUStdin(text);
+          return;
+        }
         this.handleRawStdinSegment(text);
       }
+      // Walk `text` extracting every kitty CSI-u sequence. Each non-CSI-u
+      // span is recursed back into handleRawStdin so paste markers and
+      // legacy-modifyOtherKeys sequences in the same chunk still get
+      // handled; each matched CSI-u is mapped to a KeyEvent (or dropped if
+      // unmapped). Caller has already verified at least one match exists.
+      handleCsiUStdin(text) {
+        const csiU = /\x1b\[(\d+)(?:;(\d+))?u/g;
+        let lastEnd = 0;
+        let m;
+        while ((m = csiU.exec(text)) !== null) {
+          if (m.index > lastEnd) {
+            this.handleRawStdin(
+              Buffer.from(text.slice(lastEnd, m.index), "binary")
+            );
+          }
+          const code = parseInt(m[1], 10);
+          const mod = m[2] !== void 0 ? parseInt(m[2], 10) : 1;
+          const name = mapCsiUToKeyName(code, mod);
+          if (name !== null) {
+            this.onKey([{ type: "key", name }]);
+          }
+          lastEnd = m.index + m[0].length;
+        }
+        if (lastEnd < text.length) {
+          this.handleRawStdin(Buffer.from(text.slice(lastEnd), "binary"));
+        }
+      }
       // Inner stdin-segment handler — paste-marker detection and forwarding
       // to terminal-kit. Split out so shift-enter interception can call it
       // for the non-shift-enter portions of a mixed chunk.
@@ -7360,7 +7553,8 @@ var init_screen = __esm({
         const title = this.sessionbar.title?.trim();
         const fallback = shortId(this.sessionbar.sessionId) || "hydra";
         const raw = title && title.length > 0 ? title : fallback;
-        const clean = raw.replace(/[\x00-\x1f\x7f]/g, "").slice(0, 200);
+        const tagged = this.readonly ? `${raw} [VIEW ONLY]` : raw;
+        const clean = tagged.replace(/[\x00-\x1f\x7f]/g, "").slice(0, 200);
         if (clean === this.lastWindowTitle) {
           return;
         }
@@ -8243,6 +8437,9 @@ var init_screen = __esm({
           this.drawHelpPrompt();
           return;
         }
+        if (this.readonly) {
+          return;
+        }
         const w = this.term.width;
         const room = Math.max(1, w - 2);
         const state = this.dispatcher.state();
@@ -8493,6 +8690,9 @@ var init_screen = __esm({
         if (this.helpPrompt) {
           return this.helpRows();
         }
+        if (this.readonly) {
+          return 0;
+        }
         const w = this.term.width;
         const room = Math.max(1, w - 2);
         const state = this.dispatcher.state();
@@ -10248,6 +10448,19 @@ import { nanoid as nanoid3 } from "nanoid";
 import termkit from "terminal-kit";
 import fs19 from "fs/promises";
 import path14 from "path";
+function isReadonlyForbiddenEffect(effect) {
+  switch (effect.type) {
+    case "send":
+    case "amend":
+    case "queue-edit":
+    case "queue-remove":
+    case "plan-toggle":
+    case "attachment-request":
+      return true;
+    default:
+      return false;
+  }
+}
 async function runTuiApp(opts) {
   const config = await loadConfig();
   const serviceToken = await ensureServiceToken();
@@ -10266,8 +10479,11 @@ async function runTuiApp(opts) {
   }
   if (exitHint.sessionId) {
     const short = stripHydraSessionPrefix(exitHint.sessionId);
-    process.stdout.write(`To resume: hydra-acp tui --resume ${short}
-`);
+    const flags = exitHint.readonly ? " --readonly" : "";
+    process.stdout.write(
+      `To resume: hydra-acp tui --resume ${short}${flags}
+`
+    );
   }
 }
 async function runSession(term, config, serviceToken, opts, exitHint) {
@@ -10695,6 +10911,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       ownClientId = created.clientId;
     }
     exitHint.sessionId = resolvedSessionId;
+    exitHint.readonly = false;
     const hydraMeta = extractHydraMeta(created._meta ?? void 0);
     upstreamSessionId = hydraMeta.upstreamSessionId;
     if (hydraMeta.agentId) {
@@ -10721,13 +10938,15 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     const attached = await conn.request("session/attach", {
       sessionId: ctx.sessionId,
       historyPolicy: "full",
-      clientInfo: { name: "hydra-acp-tui", version: HYDRA_VERSION }
+      clientInfo: { name: "hydra-acp-tui", version: HYDRA_VERSION },
+      ...opts.readonly === true ? { readonly: true } : {}
     });
     resolvedSessionId = attached.sessionId;
     if (attached.clientId) {
       ownClientId = attached.clientId;
     }
     exitHint.sessionId = resolvedSessionId;
+    exitHint.readonly = opts.readonly === true;
     const hydraMeta = extractHydraMeta(attached._meta ?? void 0);
     upstreamSessionId = hydraMeta.upstreamSessionId;
     if (hydraMeta.agentId) {
@@ -10767,6 +10986,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     maxScrollbackLines: config.tui.maxScrollbackLines,
     mouse: config.tui.mouse,
     progressIndicator: config.tui.progressIndicator,
+    readonly: opts.readonly === true,
     onKey: (events) => {
       for (const ev of events) {
         if (pendingPermission && tryHandlePermissionKey(ev)) {
@@ -10790,6 +11010,9 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
         }
         const effects = dispatcher.feed(ev);
         for (const effect of effects) {
+          if (opts.readonly === true && isReadonlyForbiddenEffect(effect)) {
+            continue;
+          }
           handleEffect(effect);
         }
       }
@@ -11152,13 +11375,14 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     if (choice.kind === "new") {
       const { sessionId: _drop, ...rest } = opts;
       void _drop;
-      resume({ ...rest, cwd: resolvedCwd, forceNew: true });
+      resume({ ...rest, cwd: resolvedCwd, forceNew: true, readonly: false });
       return;
     }
     const nextOpts = {
       ...opts,
       sessionId: choice.sessionId,
-      cwd: resolvedCwd
+      cwd: resolvedCwd,
+      readonly: choice.readonly === true
     };
     if (choice.agentId !== void 0) {
       nextOpts.agentId = choice.agentId;
@@ -11178,7 +11402,12 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     finishSession = null;
     process.off("SIGINT", sigintHandler);
     void stream.close().catch(() => void 0);
-    const nextOpts = { ...opts, sessionId: next.sessionId, cwd: resolvedCwd };
+    const nextOpts = {
+      ...opts,
+      sessionId: next.sessionId,
+      cwd: resolvedCwd,
+      readonly: false
+    };
     if (next.agentId !== void 0)
       nextOpts.agentId = next.agentId;
     resume(nextOpts);
@@ -12235,6 +12464,7 @@ async function resolveSession(term, config, serviceToken, opts) {
   if (choice.kind === "new") {
     return newCtx(opts, cwd, config);
   }
+  opts.readonly = choice.readonly === true;
   return {
     sessionId: choice.sessionId,
     agentId: choice.agentId ?? "",
@@ -12454,6 +12684,7 @@ var KNOWN_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "json",
   "new",
   "reattach",
+  "readonly",
   "replace",
   "rotate-token",
   "version"
@@ -13998,6 +14229,13 @@ var SessionManager = class {
     }
     return this.histories.load(sessionId).catch(() => []);
   }
+  // Read the on-disk history.jsonl for a session without constructing a
+  // Session instance. Used by the daemon's read-only viewer attach path
+  // (cli/src/daemon/acp-ws.ts) to stream replay events to a client for
+  // a cold session without spawning an agent.
+  async loadHistory(sessionId) {
+    return this.histories.load(sessionId);
+  }
   async loadFromDisk(sessionId) {
     const record = await this.store.read(sessionId);
     if (!record) {
@@ -14224,6 +14462,10 @@ var SessionManager = class {
       args.sessionId,
       args.bundle.history
     );
+    const sourceMtime = new Date(args.bundle.session.updatedAt);
+    if (!Number.isNaN(sourceMtime.getTime())) {
+      await fs11.utimes(paths.historyFile(args.sessionId), sourceMtime, sourceMtime).catch(() => void 0);
+    }
     if (args.bundle.promptHistory && args.bundle.promptHistory.length > 0) {
       await saveHistory(
         paths.tuiHistoryFile(args.sessionId),
@@ -14247,7 +14489,9 @@ var SessionManager = class {
         currentUsage: args.bundle.session.currentUsage,
         agentCommands: args.bundle.session.agentCommands,
         createdAt: args.preservedCreatedAt ?? now,
-        updatedAt: now
+        // Fallback path for historyMtimeIso (used when the history file
+        // is missing). Keep this consistent with the utimes stamp above.
+        updatedAt: args.bundle.session.updatedAt
       });
     });
   }
@@ -15170,6 +15414,9 @@ async function pruneStaleAgentVersions(registry, sessionManager) {
       if (activeVersions.has(version)) {
         continue;
       }
+      if (version.includes(".partial-")) {
+        continue;
+      }
       const versionDir = path8.join(agentDir, version);
       try {
         await fsp4.rm(versionDir, { recursive: true, force: true });
@@ -16094,6 +16341,16 @@ function registerAcpWsEndpoint(app, deps) {
       }
       state.attached.clear();
     });
+    const denyIfReadonly = (sessionId, method) => {
+      const att = state.attached.get(sessionId);
+      if (att?.readonly) {
+        const err = new Error(
+          `${method} not permitted on a read-only attachment`
+        );
+        err.code = JsonRpcErrorCodes.PermissionDenied;
+        throw err;
+      }
+    };
     connection.onRequest("initialize", async (raw) => {
       InitializeParams.parse(raw ?? {});
       return buildInitializeResult();
@@ -16120,7 +16377,8 @@ function registerAcpWsEndpoint(app, deps) {
       const { entries: replay } = await session.attach(client, "full");
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
-        clientId: client.clientId
+        clientId: client.clientId,
+        readonly: false
       });
       setImmediate(() => {
         void (async () => {
@@ -16146,11 +16404,46 @@ function registerAcpWsEndpoint(app, deps) {
     connection.onRequest("session/attach", async (raw) => {
       const params = SessionAttachParams.parse(raw);
       const hydraHints = extractHydraMeta(params._meta).resume;
+      const readonly = params.readonly === true;
       app.log.info(
-        `session/attach sessionId=${params.sessionId} hasResumeHints=${!!hydraHints}`
+        `session/attach sessionId=${params.sessionId} hasResumeHints=${!!hydraHints} readonly=${readonly}`
       );
       const lookupId = hydraHints ? params.sessionId : await deps.manager.resolveCanonicalId(params.sessionId) ?? params.sessionId;
       let session = deps.manager.get(lookupId);
+      if (!session && readonly) {
+        const fromDisk = await deps.manager.loadFromDisk(lookupId);
+        if (!fromDisk) {
+          const err = new Error(
+            `session ${params.sessionId} not found`
+          );
+          err.code = JsonRpcErrorCodes.SessionNotFound;
+          throw err;
+        }
+        const history = await deps.manager.loadHistory(lookupId);
+        const viewerClientId = params.clientId ?? `cli_${nanoid2(8)}`;
+        state.attached.set(fromDisk.hydraSessionId, {
+          sessionId: fromDisk.hydraSessionId,
+          clientId: viewerClientId,
+          readonly: true
+        });
+        app.log.info(
+          `session/attach OK (viewer) sessionId=${fromDisk.hydraSessionId} clientId=${viewerClientId} attachedCount=${state.attached.size} replayed=${history.length}`
+        );
+        for (const entry of history) {
+          await connection.notify(entry.method, entry.params).catch(() => void 0);
+        }
+        return {
+          sessionId: fromDisk.hydraSessionId,
+          clientId: viewerClientId,
+          connectedClients: [viewerClientId],
+          // No Session.attach() ran, so no history policy was applied —
+          // the viewer always gets full history. Report "full" so the
+          // wire shape matches the normal attach response.
+          historyPolicy: "full",
+          replayed: history.length,
+          _meta: buildViewerResponseMeta(fromDisk)
+        };
+      }
       if (!session) {
         const fromDisk = await deps.manager.loadFromDisk(lookupId);
         let resurrectParams = fromDisk;
@@ -16194,10 +16487,11 @@ function registerAcpWsEndpoint(app, deps) {
       );
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
-        clientId: client.clientId
+        clientId: client.clientId,
+        readonly
       });
       app.log.info(
-        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} requestedPolicy=${params.historyPolicy} appliedPolicy=${appliedPolicy} replayed=${replay.length}`
+        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} requestedPolicy=${params.historyPolicy} appliedPolicy=${appliedPolicy} replayed=${replay.length} readonly=${readonly}`
       );
       for (const note of replay) {
         await connection.notify(note.method, note.params);
@@ -16241,6 +16535,7 @@ function registerAcpWsEndpoint(app, deps) {
     });
     connection.onRequest("session/prompt", async (raw) => {
       const params = SessionPromptParams.parse(raw);
+      denyIfReadonly(params.sessionId, "session/prompt");
       const att = state.attached.get(params.sessionId);
       if (!att) {
         app.log.warn(
@@ -16289,6 +16584,12 @@ function registerAcpWsEndpoint(app, deps) {
       if (!att) {
         return;
       }
+      if (att.readonly) {
+        app.log.warn(
+          `session/cancel dropped (readonly attachment) sessionId=${params.sessionId}`
+        );
+        return;
+      }
       const session = deps.manager.get(params.sessionId);
       if (!session) {
         return;
@@ -16301,11 +16602,14 @@ function registerAcpWsEndpoint(app, deps) {
     };
     connection.onNotification("session/cancel", handleCancelParams);
     connection.onRequest("session/cancel", async (raw) => {
+      const params = SessionCancelParams.parse(raw);
+      denyIfReadonly(params.sessionId, "session/cancel");
       handleCancelParams(raw);
       return null;
     });
     connection.onRequest("hydra-acp/cancel_prompt", async (raw) => {
       const params = CancelPromptParams.parse(raw);
+      denyIfReadonly(params.sessionId, "hydra-acp/cancel_prompt");
       const session = deps.manager.get(params.sessionId);
       if (!session) {
         const err = new Error(`session ${params.sessionId} not found`);
@@ -16316,6 +16620,7 @@ function registerAcpWsEndpoint(app, deps) {
     });
     connection.onRequest("hydra-acp/update_prompt", async (raw) => {
       const params = UpdatePromptParams.parse(raw);
+      denyIfReadonly(params.sessionId, "hydra-acp/update_prompt");
       const session = deps.manager.get(params.sessionId);
       if (!session) {
         const err = new Error(`session ${params.sessionId} not found`);
@@ -16326,6 +16631,7 @@ function registerAcpWsEndpoint(app, deps) {
     });
     connection.onRequest("hydra-acp/amend_prompt", async (raw) => {
       const params = AmendPromptParams.parse(raw);
+      denyIfReadonly(params.sessionId, "hydra-acp/amend_prompt");
       const att = state.attached.get(params.sessionId);
       if (!att) {
         const err = new Error("not attached to session");
@@ -16365,7 +16671,8 @@ function registerAcpWsEndpoint(app, deps) {
       const { entries: replay } = await session.attach(client, "pending_only");
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
-        clientId: client.clientId
+        clientId: client.clientId,
+        readonly: false
       });
       for (const note of replay) {
         await connection.notify(note.method, note.params);
@@ -16384,6 +16691,10 @@ function registerAcpWsEndpoint(app, deps) {
       };
     });
     connection.onRequest("session/set_model", async (rawParams) => {
+      const sessionIdField = rawParams?.sessionId;
+      if (typeof sessionIdField === "string") {
+        denyIfReadonly(sessionIdField, "session/set_model");
+      }
       const decision = decideSetModel(rawParams, deps.manager);
       if (decision.kind === "error") {
         app.log.warn(decision.logMessage);
@@ -16417,6 +16728,7 @@ function registerAcpWsEndpoint(app, deps) {
         err.code = JsonRpcErrorCodes.MethodNotFound;
         throw err;
       }
+      denyIfReadonly(sessionId, method);
       const session = deps.manager.get(sessionId);
       if (!session) {
         const err = new Error(`session ${sessionId} not found`);
@@ -16555,6 +16867,38 @@ function decideSetModel(rawParams, manager) {
     logMessage: `session/set_model accepted sessionId=${params.sessionId} modelId=${JSON.stringify(params.modelId)}`
   };
 }
+function buildViewerResponseMeta(fromDisk) {
+  const ours = {
+    upstreamSessionId: fromDisk.upstreamSessionId,
+    agentId: fromDisk.agentId,
+    cwd: fromDisk.cwd
+  };
+  if (fromDisk.title !== void 0) {
+    ours.name = fromDisk.title;
+  }
+  if (fromDisk.agentArgs && fromDisk.agentArgs.length > 0) {
+    ours.agentArgs = fromDisk.agentArgs;
+  }
+  if (fromDisk.currentModel !== void 0) {
+    ours.currentModel = fromDisk.currentModel;
+  }
+  if (fromDisk.currentMode !== void 0) {
+    ours.currentMode = fromDisk.currentMode;
+  }
+  if (fromDisk.currentUsage !== void 0) {
+    ours.currentUsage = fromDisk.currentUsage;
+  }
+  if (fromDisk.agentCommands && fromDisk.agentCommands.length > 0) {
+    ours.availableCommands = fromDisk.agentCommands;
+  }
+  if (fromDisk.agentModes && fromDisk.agentModes.length > 0) {
+    ours.availableModes = fromDisk.agentModes;
+  }
+  if (fromDisk.agentModels && fromDisk.agentModels.length > 0) {
+    ours.availableModels = fromDisk.agentModels;
+  }
+  return { [HYDRA_META_KEY]: ours };
+}
 function buildResponseMeta(session) {
   const ours = {
     upstreamSessionId: session.upstreamSessionId,
@@ -18536,8 +18880,15 @@ async function dispatchTui(flags, base) {
   const cwd = resolveOption(flags, "cwd");
   const resume = flags.reattach === true;
   const forceNew = flags.new === true;
+  const readonly = flags.readonly === true;
+  if (readonly && base.sessionId === void 0) {
+    process.stderr.write(
+      "hydra-acp: --readonly requires a session id. Pass --resume <id> --readonly, or open the picker and press `v` on a session.\n"
+    );
+    process.exit(2);
+  }
   const { runTui } = await Promise.resolve().then(() => (init_tui(), tui_exports));
-  const tuiOpts = { resume, forceNew };
+  const tuiOpts = { resume, forceNew, readonly };
   if (base.sessionId !== void 0) {
     tuiOpts.sessionId = base.sessionId;
   }
@@ -18612,8 +18963,9 @@ function printHelp() {
       "  hydra-acp auth password [--force]           Set the daemon's master password",
       "  hydra-acp auth [list]                       List active session tokens",
       "  hydra-acp auth revoke <id>                  Revoke a session token",
-      "  hydra-acp tui flags: [--resume <id>] [--reattach] [--new] [--agent <id>] [--model <id>] [--cwd <path>] [--name <label>]",
+      "  hydra-acp tui flags: [--resume <id>] [--reattach] [--new] [--readonly] [--agent <id>] [--model <id>] [--cwd <path>] [--name <label>]",
       "                                     --resume <id> attaches to a specific session; --reattach picks the most-recent in cwd.",
+      "                                     --readonly opens a session as a transcript viewer (no agent spawn, no prompting). Requires --resume.",
       "                                     Smart default (no flags): shows a picker when sessions exist, else new.",
       "  hydra-acp --version                Print version",
       "  hydra-acp --help                   Show this help",

package/dist/index.d.ts

@@ -1320,10 +1320,12 @@ declare const SessionAttachParams: z.ZodObject<{
         name: string;
         version?: string | undefined;
     }>>;
+    readonly: z.ZodOptional<z.ZodBoolean>;
     _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     sessionId: string;
     historyPolicy: "full" | "pending_only" | "none" | "after_message";
+    readonly?: boolean | undefined;
     clientInfo?: {
         name: string;
         version?: string | undefined;
@@ -1333,6 +1335,7 @@ declare const SessionAttachParams: z.ZodObject<{
     _meta?: Record<string, unknown> | undefined;
 }, {
     sessionId: string;
+    readonly?: boolean | undefined;
     clientInfo?: {
         name: string;
         version?: string | undefined;
@@ -1779,6 +1782,7 @@ interface AttachedClient {
         name: string;
         version?: string;
     };
+    readonly?: boolean;
 }
 type CachedNotification = HistoryEntry;
 interface SpawnReplacementAgentParams {
@@ -2400,6 +2404,7 @@ declare class SessionManager {
     private bootstrapAgent;
     private attachManagerHooks;
     getHistory(sessionId: string): Promise<HistoryEntry[] | undefined>;
+    loadHistory(sessionId: string): Promise<HistoryEntry[]>;
     loadFromDisk(sessionId: string): Promise<ResurrectParams | undefined>;
     private deriveTitleFromHistory;
     get(sessionId: string): Session | undefined;

package/dist/index.js

@@ -1075,6 +1075,12 @@ var SessionAttachParams = z3.object({
     name: z3.string(),
     version: z3.string().optional()
   }).optional(),
+  // When true, the connection observes the session but cannot mutate
+  // it: state-changing methods (session/prompt, session/cancel,
+  // session/set_model, etc.) are rejected with -32011, and attaching
+  // to a cold session does not resurrect or spawn an agent — just
+  // streams history from disk. Used by the TUI's view-only mode.
+  readonly: z3.boolean().optional(),
   _meta: z3.record(z3.unknown()).optional()
 });
 var HYDRA_META_KEY = "hydra-acp";
@@ -4893,6 +4899,13 @@ var SessionManager = class {
     }
     return this.histories.load(sessionId).catch(() => []);
   }
+  // Read the on-disk history.jsonl for a session without constructing a
+  // Session instance. Used by the daemon's read-only viewer attach path
+  // (cli/src/daemon/acp-ws.ts) to stream replay events to a client for
+  // a cold session without spawning an agent.
+  async loadHistory(sessionId) {
+    return this.histories.load(sessionId);
+  }
   async loadFromDisk(sessionId) {
     const record = await this.store.read(sessionId);
     if (!record) {
@@ -5119,6 +5132,10 @@ var SessionManager = class {
       args.sessionId,
       args.bundle.history
     );
+    const sourceMtime = new Date(args.bundle.session.updatedAt);
+    if (!Number.isNaN(sourceMtime.getTime())) {
+      await fs10.utimes(paths.historyFile(args.sessionId), sourceMtime, sourceMtime).catch(() => void 0);
+    }
     if (args.bundle.promptHistory && args.bundle.promptHistory.length > 0) {
       await saveHistory(
         paths.tuiHistoryFile(args.sessionId),
@@ -5142,7 +5159,9 @@ var SessionManager = class {
         currentUsage: args.bundle.session.currentUsage,
         agentCommands: args.bundle.session.agentCommands,
         createdAt: args.preservedCreatedAt ?? now,
-        updatedAt: now
+        // Fallback path for historyMtimeIso (used when the history file
+        // is missing). Keep this consistent with the utimes stamp above.
+        updatedAt: args.bundle.session.updatedAt
       });
     });
   }
@@ -6060,6 +6079,9 @@ async function pruneStaleAgentVersions(registry, sessionManager) {
       if (activeVersions.has(version)) {
         continue;
       }
+      if (version.includes(".partial-")) {
+        continue;
+      }
       const versionDir = path8.join(agentDir, version);
       try {
         await fsp4.rm(versionDir, { recursive: true, force: true });
@@ -7708,6 +7730,16 @@ function registerAcpWsEndpoint(app, deps) {
       }
       state.attached.clear();
     });
+    const denyIfReadonly = (sessionId, method) => {
+      const att = state.attached.get(sessionId);
+      if (att?.readonly) {
+        const err = new Error(
+          `${method} not permitted on a read-only attachment`
+        );
+        err.code = JsonRpcErrorCodes.PermissionDenied;
+        throw err;
+      }
+    };
     connection.onRequest("initialize", async (raw) => {
       InitializeParams.parse(raw ?? {});
       return buildInitializeResult();
@@ -7734,7 +7766,8 @@ function registerAcpWsEndpoint(app, deps) {
       const { entries: replay } = await session.attach(client, "full");
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
-        clientId: client.clientId
+        clientId: client.clientId,
+        readonly: false
       });
       setImmediate(() => {
         void (async () => {
@@ -7760,11 +7793,46 @@ function registerAcpWsEndpoint(app, deps) {
     connection.onRequest("session/attach", async (raw) => {
       const params = SessionAttachParams.parse(raw);
       const hydraHints = extractHydraMeta(params._meta).resume;
+      const readonly = params.readonly === true;
       app.log.info(
-        `session/attach sessionId=${params.sessionId} hasResumeHints=${!!hydraHints}`
+        `session/attach sessionId=${params.sessionId} hasResumeHints=${!!hydraHints} readonly=${readonly}`
       );
       const lookupId = hydraHints ? params.sessionId : await deps.manager.resolveCanonicalId(params.sessionId) ?? params.sessionId;
       let session = deps.manager.get(lookupId);
+      if (!session && readonly) {
+        const fromDisk = await deps.manager.loadFromDisk(lookupId);
+        if (!fromDisk) {
+          const err = new Error(
+            `session ${params.sessionId} not found`
+          );
+          err.code = JsonRpcErrorCodes.SessionNotFound;
+          throw err;
+        }
+        const history = await deps.manager.loadHistory(lookupId);
+        const viewerClientId = params.clientId ?? `cli_${nanoid2(8)}`;
+        state.attached.set(fromDisk.hydraSessionId, {
+          sessionId: fromDisk.hydraSessionId,
+          clientId: viewerClientId,
+          readonly: true
+        });
+        app.log.info(
+          `session/attach OK (viewer) sessionId=${fromDisk.hydraSessionId} clientId=${viewerClientId} attachedCount=${state.attached.size} replayed=${history.length}`
+        );
+        for (const entry of history) {
+          await connection.notify(entry.method, entry.params).catch(() => void 0);
+        }
+        return {
+          sessionId: fromDisk.hydraSessionId,
+          clientId: viewerClientId,
+          connectedClients: [viewerClientId],
+          // No Session.attach() ran, so no history policy was applied —
+          // the viewer always gets full history. Report "full" so the
+          // wire shape matches the normal attach response.
+          historyPolicy: "full",
+          replayed: history.length,
+          _meta: buildViewerResponseMeta(fromDisk)
+        };
+      }
       if (!session) {
         const fromDisk = await deps.manager.loadFromDisk(lookupId);
         let resurrectParams = fromDisk;
@@ -7808,10 +7876,11 @@ function registerAcpWsEndpoint(app, deps) {
       );
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
-        clientId: client.clientId
+        clientId: client.clientId,
+        readonly
       });
       app.log.info(
-        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} requestedPolicy=${params.historyPolicy} appliedPolicy=${appliedPolicy} replayed=${replay.length}`
+        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} requestedPolicy=${params.historyPolicy} appliedPolicy=${appliedPolicy} replayed=${replay.length} readonly=${readonly}`
       );
       for (const note of replay) {
         await connection.notify(note.method, note.params);
@@ -7855,6 +7924,7 @@ function registerAcpWsEndpoint(app, deps) {
     });
     connection.onRequest("session/prompt", async (raw) => {
       const params = SessionPromptParams.parse(raw);
+      denyIfReadonly(params.sessionId, "session/prompt");
       const att = state.attached.get(params.sessionId);
       if (!att) {
         app.log.warn(
@@ -7903,6 +7973,12 @@ function registerAcpWsEndpoint(app, deps) {
       if (!att) {
         return;
       }
+      if (att.readonly) {
+        app.log.warn(
+          `session/cancel dropped (readonly attachment) sessionId=${params.sessionId}`
+        );
+        return;
+      }
       const session = deps.manager.get(params.sessionId);
       if (!session) {
         return;
@@ -7915,11 +7991,14 @@ function registerAcpWsEndpoint(app, deps) {
     };
     connection.onNotification("session/cancel", handleCancelParams);
     connection.onRequest("session/cancel", async (raw) => {
+      const params = SessionCancelParams.parse(raw);
+      denyIfReadonly(params.sessionId, "session/cancel");
       handleCancelParams(raw);
       return null;
     });
     connection.onRequest("hydra-acp/cancel_prompt", async (raw) => {
       const params = CancelPromptParams.parse(raw);
+      denyIfReadonly(params.sessionId, "hydra-acp/cancel_prompt");
       const session = deps.manager.get(params.sessionId);
       if (!session) {
         const err = new Error(`session ${params.sessionId} not found`);
@@ -7930,6 +8009,7 @@ function registerAcpWsEndpoint(app, deps) {
     });
     connection.onRequest("hydra-acp/update_prompt", async (raw) => {
       const params = UpdatePromptParams.parse(raw);
+      denyIfReadonly(params.sessionId, "hydra-acp/update_prompt");
       const session = deps.manager.get(params.sessionId);
       if (!session) {
         const err = new Error(`session ${params.sessionId} not found`);
@@ -7940,6 +8020,7 @@ function registerAcpWsEndpoint(app, deps) {
     });
     connection.onRequest("hydra-acp/amend_prompt", async (raw) => {
       const params = AmendPromptParams.parse(raw);
+      denyIfReadonly(params.sessionId, "hydra-acp/amend_prompt");
       const att = state.attached.get(params.sessionId);
       if (!att) {
         const err = new Error("not attached to session");
@@ -7979,7 +8060,8 @@ function registerAcpWsEndpoint(app, deps) {
       const { entries: replay } = await session.attach(client, "pending_only");
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
-        clientId: client.clientId
+        clientId: client.clientId,
+        readonly: false
       });
       for (const note of replay) {
         await connection.notify(note.method, note.params);
@@ -7998,6 +8080,10 @@ function registerAcpWsEndpoint(app, deps) {
       };
     });
     connection.onRequest("session/set_model", async (rawParams) => {
+      const sessionIdField = rawParams?.sessionId;
+      if (typeof sessionIdField === "string") {
+        denyIfReadonly(sessionIdField, "session/set_model");
+      }
       const decision = decideSetModel(rawParams, deps.manager);
       if (decision.kind === "error") {
         app.log.warn(decision.logMessage);
@@ -8031,6 +8117,7 @@ function registerAcpWsEndpoint(app, deps) {
         err.code = JsonRpcErrorCodes.MethodNotFound;
         throw err;
       }
+      denyIfReadonly(sessionId, method);
       const session = deps.manager.get(sessionId);
       if (!session) {
         const err = new Error(`session ${sessionId} not found`);
@@ -8169,6 +8256,38 @@ function decideSetModel(rawParams, manager) {
     logMessage: `session/set_model accepted sessionId=${params.sessionId} modelId=${JSON.stringify(params.modelId)}`
   };
 }
+function buildViewerResponseMeta(fromDisk) {
+  const ours = {
+    upstreamSessionId: fromDisk.upstreamSessionId,
+    agentId: fromDisk.agentId,
+    cwd: fromDisk.cwd
+  };
+  if (fromDisk.title !== void 0) {
+    ours.name = fromDisk.title;
+  }
+  if (fromDisk.agentArgs && fromDisk.agentArgs.length > 0) {
+    ours.agentArgs = fromDisk.agentArgs;
+  }
+  if (fromDisk.currentModel !== void 0) {
+    ours.currentModel = fromDisk.currentModel;
+  }
+  if (fromDisk.currentMode !== void 0) {
+    ours.currentMode = fromDisk.currentMode;
+  }
+  if (fromDisk.currentUsage !== void 0) {
+    ours.currentUsage = fromDisk.currentUsage;
+  }
+  if (fromDisk.agentCommands && fromDisk.agentCommands.length > 0) {
+    ours.availableCommands = fromDisk.agentCommands;
+  }
+  if (fromDisk.agentModes && fromDisk.agentModes.length > 0) {
+    ours.availableModes = fromDisk.agentModes;
+  }
+  if (fromDisk.agentModels && fromDisk.agentModels.length > 0) {
+    ours.availableModels = fromDisk.agentModels;
+  }
+  return { [HYDRA_META_KEY]: ours };
+}
 function buildResponseMeta(session) {
   const ours = {
     upstreamSessionId: session.upstreamSessionId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hydra-acp/cli",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "description": "Multi-client ACP session daemon: spawn agents, attach over WSS, multiplex sessions across editors.",
   "license": "MIT",
   "type": "module",