@hydra-acp/cli 0.1.30 → 0.1.32

package/dist/cli.js

@@ -271,12 +271,12 @@ var init_config = __esm({
       // buffer. Oldest lines are dropped on overflow. The on-disk session
       // history is unaffected; this only bounds the TUI's local view buffer.
       maxScrollbackLines: z.number().int().positive().default(1e4),
-      // When true (default), the TUI captures mouse events so the wheel can
-      // drive scrollback. The cost: terminals route clicks to the app, so
-      // text selection requires shift+drag to bypass mouse reporting. Set
-      // false to disable capture — wheel scrollback stops working, but
-      // plain click-drag selects text via the terminal emulator.
-      mouse: z.boolean().default(true),
+      // When true, the TUI captures mouse events so the wheel can drive
+      // scrollback. The cost: terminals route clicks to the app, so text
+      // selection requires shift+drag to bypass mouse reporting. Default
+      // false — wheel scrollback stops working, but plain click-drag
+      // selects text via the terminal emulator. Set true to opt back in.
+      mouse: z.boolean().default(false),
       // Size at which the TUI's session/update debug log (tui.log) rotates
       // to tui.log.0 and resets. Bounds on-disk use at ~2x this value.
       logMaxBytes: z.number().int().positive().default(5 * 1024 * 1024),
@@ -291,13 +291,13 @@ var init_config = __esm({
       // just don't want it.
       progressIndicator: z.boolean().default(true),
       // What the unmodified Enter key does in the prompt composer.
-      //   "enqueue" (default) — Enter enqueues the prompt (sends immediately
-      //     when idle, queues behind an in-flight turn); Shift+Enter amends
-      //     the in-flight turn.
-      //   "amend" — flips the two: Enter amends the in-flight turn,
-      //     Shift+Enter enqueues. With no turn in flight either key just
-      //     enqueues, since there's nothing to amend.
-      defaultEnterAction: z.enum(["enqueue", "amend"]).default("enqueue")
+      //   "amend" (default) — Enter amends the in-flight turn; Shift+Enter
+      //     enqueues. With no turn in flight either key just enqueues,
+      //     since there's nothing to amend.
+      //   "enqueue" — flips the two: Enter enqueues the prompt (sends
+      //     immediately when idle, queues behind an in-flight turn);
+      //     Shift+Enter amends the in-flight turn.
+      defaultEnterAction: z.enum(["enqueue", "amend"]).default("amend")
     });
     ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
     ExtensionBody = z.object({
@@ -338,11 +338,11 @@ var init_config = __esm({
       tui: TuiConfig.default({
         repaintThrottleMs: 1e3,
         maxScrollbackLines: 1e4,
-        mouse: true,
+        mouse: false,
         logMaxBytes: 5 * 1024 * 1024,
         cwdColumnMaxWidth: 24,
         progressIndicator: true,
-        defaultEnterAction: "enqueue"
+        defaultEnterAction: "amend"
       })
     });
   }
@@ -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";
@@ -813,9 +819,9 @@ var init_connection = __esm({
         }
         const id = nanoid();
         const message = { jsonrpc: "2.0", id, method, params };
-        const response = new Promise((resolve5, reject) => {
+        const response = new Promise((resolve6, reject) => {
           this.pending.set(id, {
-            resolve: (result) => resolve5(result),
+            resolve: (result) => resolve6(result),
             reject
           });
           this.stream.send(message).catch((err) => {
@@ -3068,7 +3074,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         }
         const clientParams = this.rewriteForClient(params);
         const toolCallId = extractToolCallId(clientParams);
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           let settled = false;
           const outbound = [];
           const entry = { addClient: sendTo };
@@ -3107,7 +3113,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
                     update
                   }).catch(() => void 0);
                 }
-                resolve5(result);
+                resolve6(result);
               });
             }).catch((err) => {
               settle(() => reject(err));
@@ -3123,14 +3129,14 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       // in flight, but doesn't emit prompt_queue_* broadcasts — clients
       // shouldn't see hydra's housekeeping in their chip list.
       async enqueuePrompt(task) {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           const entry = {
             kind: "internal",
             messageId: generateMessageId(),
             enqueuedAt: Date.now(),
             cancelled: false,
             task,
-            resolve: resolve5,
+            resolve: resolve6,
             reject
           };
           this.promptQueue.push(entry);
@@ -3149,7 +3155,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         if (client.clientInfo?.name) originator.name = client.clientInfo.name;
         if (client.clientInfo?.version)
           originator.version = client.clientInfo.version;
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           const entry = {
             kind: "user",
             messageId,
@@ -3158,7 +3164,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
             prompt: promptArray,
             enqueuedAt: Date.now(),
             cancelled: false,
-            resolve: resolve5,
+            resolve: resolve6,
             reject
           };
           this.promptQueue.push(entry);
@@ -4346,13 +4352,13 @@ function wsToMessageStream(ws) {
         throw new Error("ws is closed");
       }
       const text = JSON.stringify(message);
-      await new Promise((resolve5, reject) => {
+      await new Promise((resolve6, reject) => {
         ws.send(text, (err) => {
           if (err) {
             reject(err);
             return;
           }
-          resolve5();
+          resolve6();
         });
       });
     },
@@ -4840,8 +4846,8 @@ async function runSessionsTranscript(idOrFile, outPath) {
 }
 async function readBundleFileIfExists(arg) {
   try {
-    const stat4 = await fs17.stat(arg);
-    if (!stat4.isFile()) {
+    const stat5 = await fs17.stat(arg);
+    if (!stat5.isFile()) {
       return null;
     }
   } catch {
@@ -4876,8 +4882,8 @@ async function runSessionsImport(file, opts = {}) {
   if (opts.cwd !== void 0) {
     const resolved = path11.resolve(opts.cwd);
     try {
-      const stat4 = await fs17.stat(resolved);
-      if (!stat4.isDirectory()) {
+      const stat5 = await fs17.stat(resolved);
+      if (!stat5.isDirectory()) {
         process.stderr.write(`--cwd ${resolved} is not a directory
 `);
         process.exit(1);
@@ -5023,11 +5029,11 @@ function isResponse(msg) {
   return !("method" in msg) && "id" in msg && msg.id !== void 0;
 }
 async function openWs(url, subprotocols) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const ws = new WebSocket(url, subprotocols);
     const onOpen = () => {
       ws.off("error", onError);
-      resolve5(wsToMessageStream(ws));
+      resolve6(wsToMessageStream(ws));
     };
     const onError = (err) => {
       ws.off("open", onOpen);
@@ -5098,8 +5104,8 @@ var init_resilient_ws = __esm({
           throw new Error("resilient ws stream not connected");
         }
         const id = message.id;
-        const promise = new Promise((resolve5, reject) => {
-          this.pendingRequests.set(id, { resolve: resolve5, reject });
+        const promise = new Promise((resolve6, reject) => {
+          this.pendingRequests.set(id, { resolve: resolve6, reject });
         });
         try {
           await this.current.send(message);
@@ -5127,8 +5133,8 @@ var init_resilient_ws = __esm({
             this.bindStream(stream);
             const wasFirst = this.firstConnect;
             this.firstConnect = false;
-            this.connectGate = new Promise((resolve5) => {
-              this.releaseConnectGate = resolve5;
+            this.connectGate = new Promise((resolve6) => {
+              this.releaseConnectGate = resolve6;
             });
             try {
               if (this.opts.onConnect) {
@@ -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" };
   }
@@ -5652,7 +5667,7 @@ async function pickSession(term, opts) {
   };
   renderFromScratch();
   term.hideCursor();
-  return await new Promise((resolve5) => {
+  return await new Promise((resolve6) => {
     let resolved = false;
     const onResize = () => {
       if (resolved) {
@@ -5792,7 +5807,7 @@ async function pickSession(term, opts) {
       if (mode === "help") {
         if (name === "CTRL_C") {
           cleanup();
-          resolve5({ kind: "abort" });
+          resolve6({ kind: "abort" });
           return;
         }
         mode = "normal";
@@ -5906,12 +5921,12 @@ async function pickSession(term, opts) {
         }
         if (name === "c" || name === "C") {
           cleanup();
-          resolve5({ kind: "new" });
+          resolve6({ kind: "new" });
           return;
         }
         if (name === "q" || name === "Q") {
           cleanup();
-          resolve5({ kind: "abort" });
+          resolve6({ kind: "abort" });
           return;
         }
         if (name === "o" || name === "O") {
@@ -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;
+          }
+          resolve6(result);
+          return;
+        }
         if ((name === "k" || name === "K") && selectedIdx > 0) {
           const session = visible[selectedIdx - 1];
           if (!session) {
@@ -6030,12 +6062,12 @@ async function pickSession(term, opts) {
         case "KP_ENTER": {
           cleanup();
           if (selectedIdx === 0) {
-            resolve5({ kind: "new" });
+            resolve6({ kind: "new" });
             return;
           }
           const session = visible[selectedIdx - 1];
           if (!session) {
-            resolve5({ kind: "abort" });
+            resolve6({ kind: "abort" });
             return;
           }
           const result = {
@@ -6045,14 +6077,14 @@ async function pickSession(term, opts) {
           if (session.agentId !== void 0) {
             result.agentId = session.agentId;
           }
-          resolve5(result);
+          resolve6(result);
           return;
         }
         case "ESCAPE":
         case "CTRL_C":
         case "CTRL_D":
           cleanup();
-          resolve5({ kind: "abort" });
+          resolve6({ kind: "abort" });
           return;
       }
     };
@@ -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"],
@@ -6152,10 +6185,184 @@ var init_picker = __esm({
   }
 });
 
+// src/core/cwd.ts
+import * as fs18 from "fs/promises";
+import * as path12 from "path";
+async function validateLocalCwd(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    return { ok: false, reason: "path is empty" };
+  }
+  const resolved = path12.resolve(expandHome(trimmed));
+  let stat5;
+  try {
+    stat5 = await fs18.stat(resolved);
+  } catch {
+    return { ok: false, reason: `${resolved} does not exist` };
+  }
+  if (!stat5.isDirectory()) {
+    return { ok: false, reason: `${resolved} is not a directory` };
+  }
+  return { ok: true, path: resolved };
+}
+var init_cwd = __esm({
+  "src/core/cwd.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/tui/import-cwd-prompt.ts
+import * as os4 from "os";
+async function promptForImportCwd(term, session, opts = {}) {
+  const defaultCwd = opts.defaultCwd ?? os4.homedir();
+  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>");
+  const shortId2 = stripHydraSessionPrefix(session.sessionId);
+  const fromMachine = session.importedFromMachine ?? "another machine";
+  const originalCwd = session.cwd;
+  let buffer = defaultCwd;
+  let errorLine = null;
+  let busy = false;
+  const render = () => {
+    term("\n");
+    term.bold.cyan("Imported session: ");
+    term(`${shortId2}
+`);
+    term.dim(`  from machine:   `);
+    term(`${fromMachine}
+`);
+    term.dim(`  original cwd:   `);
+    term(`${shortenHomePath(originalCwd)}
+`);
+    term("\n");
+    term(
+      "This session has never been launched on this machine. Pick a local\n"
+    );
+    term("cwd for the agent (Enter to accept, Esc to cancel):\n\n");
+    paintInput();
+    if (errorLine) {
+      term("\n");
+      term.red(`  ${errorLine}
+`);
+    }
+  };
+  const paintInput = () => {
+    term.bold("cwd: ");
+    term(buffer);
+    if (!busy) {
+      term.bgWhite(" ");
+    }
+  };
+  const repaintInput = () => {
+    term.column(1);
+    term.eraseLine();
+    paintInput();
+    if (errorLine !== null) {
+      term("\n");
+      term.eraseLine();
+      term.red(`  ${errorLine}`);
+      term.up(1);
+      term.column(1);
+    }
+  };
+  render();
+  return await new Promise((resolve6) => {
+    let resolved = false;
+    const cleanup = () => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      term.off("key", onKey);
+      term.grabInput(false);
+      term.hideCursor(false);
+      term("\n\n");
+    };
+    const finish = (value) => {
+      cleanup();
+      resolve6(value);
+    };
+    const onKey = (name, _matches, data) => {
+      if (busy) {
+        return;
+      }
+      if (name === "ENTER" || name === "KP_ENTER") {
+        const candidate = buffer;
+        busy = true;
+        errorLine = null;
+        repaintInput();
+        void validateLocalCwd(candidate).then((result) => {
+          busy = false;
+          if (result.ok) {
+            finish(result.path);
+            return;
+          }
+          errorLine = result.reason;
+          repaintInput();
+        });
+        return;
+      }
+      if (name === "ESCAPE" || name === "CTRL_C" || name === "CTRL_D") {
+        finish(null);
+        return;
+      }
+      if (name === "BACKSPACE") {
+        if (buffer.length > 0) {
+          buffer = buffer.slice(0, -1);
+          errorLine = null;
+          repaintInput();
+        }
+        return;
+      }
+      if (name === "CTRL_U") {
+        buffer = "";
+        errorLine = null;
+        repaintInput();
+        return;
+      }
+      if (name === "CTRL_W") {
+        const trimmedRight = buffer.replace(/[/\s]+$/, "");
+        const lastSep = Math.max(
+          trimmedRight.lastIndexOf("/"),
+          trimmedRight.lastIndexOf(" ")
+        );
+        buffer = lastSep >= 0 ? trimmedRight.slice(0, lastSep + 1) : "";
+        errorLine = null;
+        repaintInput();
+        return;
+      }
+      if (data?.isCharacter) {
+        buffer += name;
+        errorLine = null;
+        repaintInput();
+        return;
+      }
+    };
+    term.grabInput({});
+    term.on("key", onKey);
+  });
+}
+var init_import_cwd_prompt = __esm({
+  "src/tui/import-cwd-prompt.ts"() {
+    "use strict";
+    init_paths();
+    init_session();
+    init_cwd();
+  }
+});
+
 // src/tui/attachments.ts
-import path12 from "path";
+import path13 from "path";
 function mimeFromExtension(p) {
-  return EXTENSION_TO_MIME[path12.extname(p).toLowerCase()] ?? null;
+  return EXTENSION_TO_MIME[path13.extname(p).toLowerCase()] ?? null;
 }
 function isSupportedImagePath(p) {
   return mimeFromExtension(p) !== null;
@@ -6799,6 +7006,8 @@ function mapKeyName(name) {
       return "ctrl-v";
     case "CTRL_W":
       return "ctrl-w";
+    case "CTRL_X":
+      return "ctrl-x";
     case "CTRL_Y":
       return "ctrl-y";
     case "ESCAPE":
@@ -6807,6 +7016,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,19 +7248,34 @@ 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;
         this.onKey = opts.onKey;
         this.contentRepaintThrottleMs = opts.repaintThrottleMs ?? DEFAULT_CONTENT_REPAINT_THROTTLE_MS;
         this.maxScrollbackLines = opts.maxScrollbackLines ?? DEFAULT_MAX_SCROLLBACK_LINES;
-        this.mouseEnabled = opts.mouse ?? true;
+        this.mouseEnabled = opts.mouse ?? false;
         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 +7304,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 +7322,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 +7358,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 +7370,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 +7729,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;
         }
@@ -7420,6 +7790,57 @@ var init_screen = __esm({
         this.drawBanner();
         this.placeCursor();
       }
+      // Runtime toggle for terminal mouse capture. With capture on, the
+      // wheel drives scrollback but text selection requires shift+drag
+      // (terminals route mouse events to the app). With capture off, plain
+      // click-drag selects text but the wheel does nothing in the app —
+      // use PgUp/PgDn for scrollback instead. Bound to ^X so users can
+      // flip on demand without a config reload + restart. Idempotent.
+      //
+      // Re-issuing grabInput() reinstalls terminal-kit's own stdin "data"
+      // listener, so we have to redo the same listener swap that
+      // installBracketedPaste() did at startup — otherwise our raw handler
+      // and terminal-kit's both fire for every keystroke (each character
+      // appears twice in the prompt).
+      setMouseEnabled(enabled) {
+        if (this.mouseEnabled === enabled) {
+          return;
+        }
+        this.mouseEnabled = enabled;
+        if (!this.started) {
+          return;
+        }
+        if (enabled) {
+          this.term.grabInput({ mouse: "button" });
+          this.term.on("mouse", this.mouseHandler);
+        } else {
+          this.term.off("mouse", this.mouseHandler);
+          this.term.grabInput(true);
+        }
+        this.reclaimStdinAfterGrabInput();
+      }
+      // After a grabInput() re-issue, terminal-kit has put its own "data"
+      // listener back on stdin. Pull it back off and reinstall hydra's
+      // rawStdinHandler — keeping the captured terminal-kit handler so our
+      // bracketed-paste extractor can still delegate non-paste bytes to it.
+      // No-op if installBracketedPaste() hasn't run yet (start() does it
+      // before any toggle path can reach here).
+      reclaimStdinAfterGrabInput() {
+        if (this.terminalKitStdinHandler === null) {
+          return;
+        }
+        const t = this.term;
+        if (!t.stdin || typeof t.onStdin !== "function") {
+          return;
+        }
+        this.terminalKitStdinHandler = t.onStdin;
+        t.stdin.removeListener("data", t.onStdin);
+        t.stdin.removeListener("data", this.rawStdinHandler);
+        t.stdin.on("data", this.rawStdinHandler);
+      }
+      isMouseEnabled() {
+        return this.mouseEnabled;
+      }
       // Pushed by the app each onKey tick to reflect prompt-history
       // reverse-search state in the banner — the only place that mode's
       // query is visible. Pass null when not searching.
@@ -8243,6 +8664,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 +8917,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();
@@ -8901,6 +9328,8 @@ var init_input = __esm({
           case "ctrl-w":
             this.killWord();
             return [];
+          case "ctrl-x":
+            return [{ type: "toggle-mouse" }];
           case "ctrl-y":
             this.yank();
             return [];
@@ -9483,9 +9912,9 @@ var init_input = __esm({
 
 // src/tui/clipboard.ts
 import { spawn as nodeSpawn } from "child_process";
-import fs18 from "fs/promises";
-import os4 from "os";
-import path13 from "path";
+import fs19 from "fs/promises";
+import os5 from "os";
+import path14 from "path";
 async function readClipboard(envIn = {}) {
   const env = { ...defaultEnv, ...envIn };
   if (env.platform === "darwin") {
@@ -9500,7 +9929,7 @@ async function readClipboard(envIn = {}) {
   };
 }
 async function readMacOS(env) {
-  const tmpPath = path13.join(
+  const tmpPath = path14.join(
     env.tmpdir(),
     `hydra-clipboard-${Date.now()}-${process.pid}.png`
   );
@@ -9524,7 +9953,7 @@ async function readMacOS(env) {
       return img;
     }
   } catch {
-    await fs18.unlink(tmpPath).catch(() => void 0);
+    await fs19.unlink(tmpPath).catch(() => void 0);
   }
   try {
     const buf = await runCapture(env.spawn, "pbpaste", []);
@@ -9639,9 +10068,9 @@ async function which(env, cmd) {
 }
 async function readFileAsAttachment(p, unlinkAfter) {
   try {
-    const buf = await fs18.readFile(p);
+    const buf = await fs19.readFile(p);
     if (unlinkAfter) {
-      await fs18.unlink(p).catch(() => void 0);
+      await fs19.unlink(p).catch(() => void 0);
     }
     if (buf.length === 0) {
       return { ok: false, reason: "no image on clipboard" };
@@ -9667,14 +10096,14 @@ async function readFileAsAttachment(p, unlinkAfter) {
   }
 }
 function run2(spawn6, cmd, args) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const proc = spawn6(cmd, args);
     proc.stdout?.on("data", () => void 0);
     proc.stderr?.on("data", () => void 0);
     proc.on("error", reject);
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve5();
+        resolve6();
       } else {
         reject(new Error(`${cmd} exited ${code}`));
       }
@@ -9682,7 +10111,7 @@ function run2(spawn6, cmd, args) {
   });
 }
 function runCapture(spawn6, cmd, args) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const proc = spawn6(cmd, args);
     const chunks = [];
     let stdoutEnded = proc.stdout === null;
@@ -9694,7 +10123,7 @@ function runCapture(spawn6, cmd, args) {
       }
       settled = true;
       if (closedCode === 0) {
-        resolve5(Buffer.concat(chunks));
+        resolve6(Buffer.concat(chunks));
       } else {
         reject(new Error(`${cmd} exited ${closedCode}`));
       }
@@ -9729,7 +10158,7 @@ var init_clipboard = __esm({
       platform: process.platform,
       env: process.env,
       spawn: nodeSpawn,
-      tmpdir: os4.tmpdir
+      tmpdir: os5.tmpdir
     };
     SUPPORTED_IMAGE_MIMES = [
       "image/png",
@@ -10246,8 +10675,21 @@ var init_format = __esm({
 import { appendFileSync, statSync, renameSync } from "fs";
 import { nanoid as nanoid3 } from "nanoid";
 import termkit from "terminal-kit";
-import fs19 from "fs/promises";
-import path14 from "path";
+import fs20 from "fs/promises";
+import path15 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 +10708,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) {
@@ -10559,10 +11004,10 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     if (pendingPermission.toolCallId && toolCallId && pendingPermission.toolCallId !== toolCallId) {
       return;
     }
-    const resolve5 = pendingPermission.resolve;
+    const resolve6 = pendingPermission.resolve;
     pendingPermission = null;
     screen.setPermissionPrompt(null);
-    resolve5(result ?? { outcome: { outcome: "cancelled" } });
+    resolve6(result ?? { outcome: { outcome: "cancelled" } });
   };
   const maybeDismissPermissionByToolUpdate = (update) => {
     if (!pendingPermission?.toolCallId) {
@@ -10595,14 +11040,14 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     if (!pendingPermission) {
       return;
     }
-    const { options, resolve: resolve5 } = pendingPermission;
+    const { options, resolve: resolve6 } = pendingPermission;
     pendingPermission = null;
     screen.setPermissionPrompt(null);
     if (optionId === null) {
-      resolve5({ outcome: { outcome: "cancelled" } });
+      resolve6({ outcome: { outcome: "cancelled" } });
       return;
     }
-    resolve5({ outcome: { outcome: "selected", optionId } });
+    resolve6({ outcome: { outcome: "selected", optionId } });
     void options;
   };
   conn.onRequest("session/request_permission", async (params) => {
@@ -10629,12 +11074,12 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       ]);
       return { outcome: { outcome: "cancelled" } };
     }
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       pendingPermission = {
         title,
         options,
         selectedIndex: 0,
-        resolve: resolve5,
+        resolve: resolve6,
         toolCallId
       };
       refreshPermissionPrompt();
@@ -10695,6 +11140,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 +11167,31 @@ 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 } : {},
+      // Forward the user-chosen cwd for first-launch imported sessions
+      // via a full resume hint. upstreamSessionId is empty so the
+      // daemon routes through doResurrectFromImport (session-manager.ts)
+      // with the user-supplied cwd instead of silently falling back to
+      // $HOME in resolveImportCwd.
+      ...ctx.importAttachHint !== void 0 ? {
+        _meta: {
+          [HYDRA_META_KEY]: {
+            resume: {
+              upstreamSessionId: "",
+              agentId: ctx.importAttachHint.agentId,
+              cwd: ctx.importAttachHint.cwd
+            }
+          }
+        }
+      } : {}
     });
     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 +11231,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 +11255,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);
         }
       }
@@ -10977,8 +11445,8 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     }
   });
   let finishSession = null;
-  const sessionDone = new Promise((resolve5) => {
-    finishSession = resolve5;
+  const sessionDone = new Promise((resolve6) => {
+    finishSession = resolve6;
   });
   const cancelRemoteTurn = () => {
     conn.notify("session/cancel", { sessionId: resolvedSessionId }).catch(() => void 0);
@@ -11152,13 +11620,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 +11647,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);
@@ -11289,6 +11763,14 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
         toolsExpanded = !toolsExpanded;
         renderToolsBlock();
         return;
+      case "toggle-mouse": {
+        const next = !screen.isMouseEnabled();
+        screen.setMouseEnabled(next);
+        screen.notify(
+          next ? "mouse capture on \u2014 wheel scrolls; shift+drag to select text" : "mouse capture off \u2014 click-drag selects text; PgUp/PgDn scrolls"
+        );
+        return;
+      }
       case "show-help":
         toggleHelpModal();
         return;
@@ -11331,11 +11813,11 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       }
       const mimeType = mimeFromExtension(token);
       if (!mimeType) {
-        screen.notify(`unsupported image type: ${path14.basename(token)}`);
+        screen.notify(`unsupported image type: ${path15.basename(token)}`);
         continue;
       }
       try {
-        const buf = await fs19.readFile(token);
+        const buf = await fs20.readFile(token);
         if (buf.length > MAX_ATTACHMENT_BYTES) {
           screen.notify(
             `image too large (${formatSize(buf.length)}, max ${formatSize(MAX_ATTACHMENT_BYTES)})`
@@ -11345,13 +11827,13 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
         dispatcher.addAttachment({
           mimeType,
           data: buf.toString("base64"),
-          name: path14.basename(token),
+          name: path15.basename(token),
           sizeBytes: buf.length
         });
         added++;
       } catch (err) {
         screen.notify(
-          `cannot read ${path14.basename(token)}: ${err.message}`
+          `cannot read ${path15.basename(token)}: ${err.message}`
         );
       }
     }
@@ -12068,10 +12550,10 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
   }
   const resetInFlightUiState = () => {
     if (pendingPermission) {
-      const resolve5 = pendingPermission.resolve;
+      const resolve6 = pendingPermission.resolve;
       pendingPermission = null;
       screen.setPermissionPrompt(null);
-      resolve5({ outcome: { outcome: "cancelled" } });
+      resolve6({ outcome: { outcome: "cancelled" } });
     }
     closeAgentText();
   };
@@ -12235,6 +12717,22 @@ async function resolveSession(term, config, serviceToken, opts) {
   if (choice.kind === "new") {
     return newCtx(opts, cwd, config);
   }
+  opts.readonly = choice.readonly === true;
+  const chosen = sessions.find((s) => s.sessionId === choice.sessionId);
+  const isImportedFirstLaunch = chosen !== void 0 && !!chosen.importedFromMachine && !chosen.upstreamSessionId && !opts.readonly;
+  if (isImportedFirstLaunch) {
+    const promptedCwd = await promptForImportCwd(term, chosen);
+    if (promptedCwd === null) {
+      return null;
+    }
+    const agentId = choice.agentId ?? chosen.agentId ?? "";
+    return {
+      sessionId: choice.sessionId,
+      agentId,
+      cwd: promptedCwd,
+      importAttachHint: { agentId, cwd: promptedCwd }
+    };
+  }
   return {
     sessionId: choice.sessionId,
     agentId: choice.agentId ?? "",
@@ -12363,8 +12861,8 @@ function createInstallStatusLine(term, baseLabel) {
 }
 function rotateIfBig(target) {
   try {
-    const stat4 = statSync(target);
-    if (stat4.size < logMaxBytes) {
+    const stat5 = statSync(target);
+    if (stat5.size < logMaxBytes) {
       return;
     }
     renameSync(target, `${target}.0`);
@@ -12388,6 +12886,7 @@ var init_app = __esm({
     init_history();
     init_discovery();
     init_picker();
+    init_import_cwd_prompt();
     init_screen();
     init_input();
     init_attachments();
@@ -12417,6 +12916,7 @@ var init_app = __esm({
       ["^R / ^S", "history reverse / forward search"],
       ["PgUp / PgDn", "scroll scrollback"],
       ["Mouse wheel", "scroll scrollback (when mouse capture is on)"],
+      ["^X", "toggle mouse capture (wheel scroll vs. text selection)"],
       null,
       ["^C", "cancel turn (twice to exit)"],
       ["Esc", "cancel turn and prefill draft"],
@@ -12443,7 +12943,7 @@ var init_tui = __esm({
 // src/cli.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname6, resolve as resolve4 } from "path";
+import { dirname as dirname6, resolve as resolve5 } from "path";
 
 // src/cli/parse-args.ts
 var KNOWN_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
@@ -12454,6 +12954,7 @@ var KNOWN_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "json",
   "new",
   "reattach",
+  "readonly",
   "replace",
   "rotate-token",
   "version"
@@ -12740,10 +13241,10 @@ async function downloadTo(args) {
       logSink(formatProgress(args.agentId, received, total));
     }
   });
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve6, reject) => {
     nodeStream.on("error", reject);
     out.on("error", reject);
-    out.on("finish", () => resolve5());
+    out.on("finish", () => resolve6());
     nodeStream.pipe(out);
   });
   logSink(formatProgress(
@@ -12795,14 +13296,14 @@ async function extract(archivePath, dest) {
   throw new Error(`Unsupported archive format: ${archivePath}`);
 }
 function run(cmd, args) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const child = spawn(cmd, args, {
       stdio: ["ignore", "ignore", "inherit"]
     });
     child.on("error", reject);
     child.on("exit", (code, signal) => {
       if (code === 0) {
-        resolve5();
+        resolve6();
         return;
       }
       reject(
@@ -12814,11 +13315,11 @@ function run(cmd, args) {
   });
 }
 async function hasCommand(name) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const finder = process.platform === "win32" ? "where" : "which";
     const child = spawn(finder, [name], { stdio: "ignore" });
-    child.on("error", () => resolve5(false));
-    child.on("exit", (code) => resolve5(code === 0));
+    child.on("error", () => resolve6(false));
+    child.on("exit", (code) => resolve6(code === 0));
   });
 }
 async function fileExists(p) {
@@ -12936,7 +13437,7 @@ function runNpmInstall(args) {
 }
 async function runNpmInstallOnce(args, attempt) {
   try {
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const registryArgs = args.registry ? ["--registry", args.registry] : [];
       let child;
       try {
@@ -12978,7 +13479,7 @@ async function runNpmInstallOnce(args, attempt) {
       });
       child.on("exit", (code, signal) => {
         if (code === 0) {
-          resolve5();
+          resolve6();
           return;
         }
         const reason = code !== null ? `exit code ${code}` : `signal ${signal ?? "unknown"}`;
@@ -13306,13 +13807,13 @@ function ndjsonStreamFromStdio(stdout, stdin) {
         throw new Error("stream is closed");
       }
       const line = JSON.stringify(message) + "\n";
-      await new Promise((resolve5, reject) => {
+      await new Promise((resolve6, reject) => {
         stdin.write(line, (err) => {
           if (err) {
             reject(err);
             return;
           }
-          resolve5();
+          resolve6();
         });
       });
     },
@@ -13827,8 +14328,8 @@ var SessionManager = class {
   }
   async resolveImportCwd(cwd) {
     try {
-      const stat4 = await fs11.stat(cwd);
-      if (stat4.isDirectory()) {
+      const stat5 = await fs11.stat(cwd);
+      if (stat5.isDirectory()) {
         return cwd;
       }
     } catch {
@@ -13998,6 +14499,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) {
@@ -14744,9 +15252,9 @@ var ExtensionManager = class {
       } catch {
       }
       tasks.push(
-        new Promise((resolve5) => {
+        new Promise((resolve6) => {
           if (child.exitCode !== null || child.signalCode !== null) {
-            resolve5();
+            resolve6();
             return;
           }
           const timer = setTimeout(() => {
@@ -14754,11 +15262,11 @@ var ExtensionManager = class {
               child.kill("SIGKILL");
             } catch {
             }
-            resolve5();
+            resolve6();
           }, STOP_GRACE_MS);
           child.on("exit", () => {
             clearTimeout(timer);
-            resolve5();
+            resolve6();
           });
         })
       );
@@ -14866,8 +15374,8 @@ var ExtensionManager = class {
     if (child.exitCode !== null || child.signalCode !== null) {
       return;
     }
-    const exited = new Promise((resolve5) => {
-      entry.exitWaiters.push(resolve5);
+    const exited = new Promise((resolve6) => {
+      entry.exitWaiters.push(resolve6);
     });
     try {
       child.kill("SIGTERM");
@@ -15064,8 +15572,8 @@ var ExtensionManager = class {
       entry.pid = void 0;
       entry.lastExitCode = typeof code === "number" ? code : void 0;
       const waiters = entry.exitWaiters.splice(0);
-      for (const resolve5 of waiters) {
-        resolve5();
+      for (const resolve6 of waiters) {
+        resolve6();
       }
       if (this.stopping || entry.manuallyStopped) {
         try {
@@ -15176,6 +15684,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 });
@@ -16100,6 +16611,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();
@@ -16126,7 +16647,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 () => {
@@ -16152,11 +16674,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;
@@ -16200,10 +16757,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);
@@ -16247,6 +16805,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(
@@ -16295,6 +16854,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;
@@ -16307,11 +16872,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`);
@@ -16322,6 +16890,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`);
@@ -16332,6 +16901,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");
@@ -16371,7 +16941,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);
@@ -16390,6 +16961,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);
@@ -16423,6 +16998,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`);
@@ -16561,6 +17137,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,
@@ -16836,9 +17444,9 @@ import * as fs16 from "fs";
 import * as fsp6 from "fs/promises";
 async function runLogTail(logPath, argv, notFoundMessage) {
   const opts = parseLogTailFlags(argv);
-  let stat4;
+  let stat5;
   try {
-    stat4 = await fsp6.stat(logPath);
+    stat5 = await fsp6.stat(logPath);
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
@@ -16849,7 +17457,7 @@ async function runLogTail(logPath, argv, notFoundMessage) {
     }
     throw err;
   }
-  let position = await printTail(logPath, stat4.size, opts.tail);
+  let position = await printTail(logPath, stat5.size, opts.tail);
   if (!opts.follow) {
     return;
   }
@@ -16884,10 +17492,10 @@ async function runLogTail(logPath, argv, notFoundMessage) {
       }
     });
   });
-  await new Promise((resolve5) => {
+  await new Promise((resolve6) => {
     const finish = () => {
       watcher.close();
-      resolve5();
+      resolve6();
     };
     process.once("SIGINT", finish);
     process.once("SIGTERM", finish);
@@ -17693,7 +18301,7 @@ async function promptPassword(prompt) {
   if (!process.stdin.isTTY) {
     return readLineFromStdin();
   }
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const stdin = process.stdin;
     const wasRaw = stdin.isRaw === true;
     let buffer = "";
@@ -17710,7 +18318,7 @@ async function promptPassword(prompt) {
         if (byte === 10 || byte === 13) {
           process.stdout.write("\n");
           cleanup();
-          resolve5(buffer);
+          resolve6(buffer);
           return;
         }
         if (byte === 3) {
@@ -17736,7 +18344,7 @@ async function promptPassword(prompt) {
   });
 }
 function readLineFromStdin() {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let buffer = "";
     process.stdin.setEncoding("utf8");
     const onData = (chunk) => {
@@ -17745,7 +18353,7 @@ function readLineFromStdin() {
       if (nl !== -1) {
         process.stdin.removeListener("data", onData);
         process.stdin.removeListener("error", onError);
-        resolve5(buffer.slice(0, nl).replace(/\r$/, ""));
+        resolve6(buffer.slice(0, nl).replace(/\r$/, ""));
       }
     };
     const onError = (err) => {
@@ -18542,8 +19150,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;
   }
@@ -18571,7 +19186,7 @@ function readVersion() {
   try {
     const here = dirname6(fileURLToPath2(import.meta.url));
     const pkg = JSON.parse(
-      readFileSync2(resolve4(here, "../package.json"), "utf8")
+      readFileSync2(resolve5(here, "../package.json"), "utf8")
     );
     return pkg.version ?? "unknown";
   } catch {
@@ -18618,8 +19233,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",