@hydra-acp/cli 0.1.31 → 0.1.33

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"
       })
     });
   }
@@ -819,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) => {
@@ -3074,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 };
@@ -3113,7 +3113,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
                     update
                   }).catch(() => void 0);
                 }
-                resolve5(result);
+                resolve6(result);
               });
             }).catch((err) => {
               settle(() => reject(err));
@@ -3129,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);
@@ -3155,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,
@@ -3164,7 +3164,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
             prompt: promptArray,
             enqueuedAt: Date.now(),
             cancelled: false,
-            resolve: resolve5,
+            resolve: resolve6,
             reject
           };
           this.promptQueue.push(entry);
@@ -4352,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();
         });
       });
     },
@@ -4846,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 {
@@ -4882,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);
@@ -5029,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);
@@ -5104,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);
@@ -5133,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) {
@@ -5667,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) {
@@ -5807,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";
@@ -5921,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") {
@@ -5976,7 +5976,7 @@ async function pickSession(term, opts) {
           if (session.agentId !== void 0) {
             result.agentId = session.agentId;
           }
-          resolve5(result);
+          resolve6(result);
           return;
         }
         if ((name === "k" || name === "K") && selectedIdx > 0) {
@@ -6062,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 = {
@@ -6077,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;
       }
     };
@@ -6185,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;
@@ -6832,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":
@@ -7097,7 +7273,7 @@ var init_screen = __esm({
         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();
@@ -7614,6 +7790,57 @@ uncaught: ${err.stack ?? err.message}
         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.
@@ -9101,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 [];
@@ -9683,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") {
@@ -9700,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`
   );
@@ -9724,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", []);
@@ -9839,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" };
@@ -9867,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}`));
       }
@@ -9882,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;
@@ -9894,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}`));
       }
@@ -9929,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",
@@ -10446,8 +10675,8 @@ 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":
@@ -10775,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) {
@@ -10811,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) => {
@@ -10845,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();
@@ -10939,7 +11168,23 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       sessionId: ctx.sessionId,
       historyPolicy: "full",
       clientInfo: { name: "hydra-acp-tui", version: HYDRA_VERSION },
-      ...opts.readonly === true ? { readonly: true } : {}
+      ...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) {
@@ -11200,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);
@@ -11518,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;
@@ -11560,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)})`
@@ -11574,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}`
         );
       }
     }
@@ -12297,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();
   };
@@ -12465,6 +12718,21 @@ async function resolveSession(term, config, serviceToken, opts) {
     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 ?? "",
@@ -12593,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`);
@@ -12618,6 +12886,7 @@ var init_app = __esm({
     init_history();
     init_discovery();
     init_picker();
+    init_import_cwd_prompt();
     init_screen();
     init_input();
     init_attachments();
@@ -12647,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"],
@@ -12673,11 +12943,12 @@ 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([
   "all",
+  "detach",
   "foreground",
   "help",
   "info",
@@ -12971,10 +13242,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(
@@ -13026,14 +13297,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(
@@ -13045,11 +13316,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) {
@@ -13167,7 +13438,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 {
@@ -13209,7 +13480,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"}`;
@@ -13537,13 +13808,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();
         });
       });
     },
@@ -14058,8 +14329,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 {
@@ -14982,9 +15253,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(() => {
@@ -14992,11 +15263,11 @@ var ExtensionManager = class {
               child.kill("SIGKILL");
             } catch {
             }
-            resolve5();
+            resolve6();
           }, STOP_GRACE_MS);
           child.on("exit", () => {
             clearTimeout(timer);
-            resolve5();
+            resolve6();
           });
         })
       );
@@ -15104,8 +15375,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");
@@ -15302,8 +15573,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 {
@@ -17174,9 +17445,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") {
@@ -17187,7 +17458,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;
   }
@@ -17222,10 +17493,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);
@@ -17305,6 +17576,7 @@ async function runDaemonStart(flags = {}) {
     return;
   }
   if (flagBool(flags, "foreground")) {
+    process.title = "hydra-daemon";
     const handle = await startDaemon(config, serviceToken);
     process.stdout.write(
       `hydra-acp daemon listening on ${config.daemon.host}:${config.daemon.port}
@@ -18031,7 +18303,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 = "";
@@ -18048,7 +18320,7 @@ async function promptPassword(prompt) {
         if (byte === 10 || byte === 13) {
           process.stdout.write("\n");
           cleanup();
-          resolve5(buffer);
+          resolve6(buffer);
           return;
         }
         if (byte === 3) {
@@ -18074,7 +18346,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) => {
@@ -18083,7 +18355,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) => {
@@ -18385,8 +18657,34 @@ function isResponse2(msg) {
   return !("method" in msg) && "id" in msg;
 }
 
+// src/core/process-title.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+var COMM_ANCHOR = "hydra";
+var defaultWriteComm = (text) => {
+  writeFileSync2("/proc/self/comm", text);
+};
+function setHydraProcessTitle(fullTitle, deps = {}) {
+  process.title = fullTitle;
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "linux") {
+    return;
+  }
+  const writeComm = deps.writeComm ?? defaultWriteComm;
+  try {
+    writeComm(COMM_ANCHOR);
+  } catch {
+  }
+}
+function buildTitleFromArgv(argv) {
+  if (argv.length === 0) {
+    return COMM_ANCHOR;
+  }
+  return `${COMM_ANCHOR} ${argv.join(" ")}`;
+}
+
 // src/shim/proxy.ts
 async function runShim(opts) {
+  setHydraProcessTitle(buildTitleFromArgv(process.argv.slice(2)));
   const config = await loadConfig();
   const serviceToken = await ensureServiceToken();
   await ensureDaemonReachable(config);
@@ -18626,6 +18924,309 @@ function injectHydraMeta(msg, additions) {
   };
 }
 
+// src/cli/commands/cat.ts
+init_connection();
+init_ws_stream();
+init_config();
+init_service_token();
+init_daemon_bootstrap();
+init_render_update();
+init_types();
+init_hydra_version();
+import { WebSocket as WebSocket2 } from "ws";
+
+// src/cli/commands/cat-chunker.ts
+function createChunker(opts) {
+  let buffer = "";
+  let dataArrivedSinceSchedule = false;
+  let scheduled = false;
+  let ended = false;
+  const flush = () => {
+    if (buffer.length === 0) {
+      return;
+    }
+    const out = buffer;
+    buffer = "";
+    opts.onChunk(out);
+  };
+  const scheduleCheck = () => {
+    if (scheduled) {
+      return;
+    }
+    scheduled = true;
+    dataArrivedSinceSchedule = false;
+    opts.scheduleFlushCheck(() => {
+      scheduled = false;
+      if (dataArrivedSinceSchedule) {
+        scheduleCheck();
+        return;
+      }
+      flush();
+    });
+  };
+  return {
+    feed(data) {
+      if (ended || data.length === 0) {
+        return;
+      }
+      buffer += data;
+      if (scheduled) {
+        dataArrivedSinceSchedule = true;
+      } else {
+        scheduleCheck();
+      }
+    },
+    eof() {
+      if (ended) {
+        return;
+      }
+      ended = true;
+      flush();
+    }
+  };
+}
+
+// src/cli/commands/cat.ts
+async function runCat(opts) {
+  setHydraProcessTitle(buildTitleFromArgv(process.argv.slice(2)));
+  if (process.stdin.isTTY && !opts.prompt && !opts.sessionId) {
+    process.stderr.write(
+      "hydra-acp cat: nothing to send. Pipe input on stdin, pass -p <text>, or attach to an existing session with --session-id.\n"
+    );
+    process.exit(2);
+    return;
+  }
+  const config = await loadConfig();
+  const serviceToken = await ensureServiceToken();
+  await ensureDaemonReachable(config);
+  const protocol = config.daemon.tls ? "wss" : "ws";
+  const url = `${protocol}://${config.daemon.host}:${config.daemon.port}/acp`;
+  const subprotocols = ["acp.v1", `hydra-acp-token.${serviceToken}`];
+  const ws = await openWs2(url, subprotocols);
+  const stream = wsToMessageStream(ws);
+  const conn = new JsonRpcConnection(stream);
+  const result = await runCatLoop({
+    conn,
+    opts,
+    stdin: process.stdin,
+    stdinIsTty: process.stdin.isTTY === true,
+    stdout: (chunk) => process.stdout.write(chunk),
+    stderr: (chunk) => {
+      process.stderr.write(chunk);
+    }
+  });
+  process.exit(result.exitCode);
+}
+async function runCatLoop(args) {
+  const { conn, opts, stdin, stdinIsTty, stdout, stderr } = args;
+  conn.setDefaultHandler(async () => {
+    return { error: { code: -32601, message: "method not implemented" } };
+  });
+  try {
+    await conn.request("initialize", {
+      protocolVersion: ACP_PROTOCOL_VERSION,
+      clientCapabilities: {
+        fs: { readTextFile: false, writeTextFile: false },
+        terminal: false
+      },
+      clientInfo: { name: "hydra-acp-cat", version: HYDRA_VERSION }
+    });
+  } catch {
+  }
+  const sessionId = await openOrAttachSession(conn, opts);
+  let turnHadOutput = false;
+  let lastCharWasNewline = true;
+  const writeStdout = (text) => {
+    if (text.length === 0) {
+      return;
+    }
+    stdout(text);
+    lastCharWasNewline = text.charCodeAt(text.length - 1) === 10;
+  };
+  const finalizeTurn = () => {
+    if (turnHadOutput && !lastCharWasNewline) {
+      writeStdout("\n");
+    }
+    turnHadOutput = false;
+  };
+  conn.onNotification("session/update", (params) => {
+    const update = params?.update;
+    const event = mapUpdate(update);
+    if (!event) {
+      return;
+    }
+    if (event.kind === "agent-text") {
+      turnHadOutput = true;
+      writeStdout(event.text);
+    } else if (event.kind === "turn-complete") {
+      finalizeTurn();
+    }
+  });
+  const sendChunk = async (text) => {
+    const promptBlocks = [];
+    if (opts.prompt) {
+      promptBlocks.push({ type: "text", text: opts.prompt });
+    }
+    if (text.length > 0) {
+      promptBlocks.push({ type: "text", text });
+    }
+    if (promptBlocks.length === 0) {
+      return;
+    }
+    try {
+      await conn.request("session/prompt", {
+        sessionId,
+        prompt: promptBlocks
+      });
+    } catch (err) {
+      stderr(`hydra-acp cat: prompt failed: ${err.message}
+`);
+      return;
+    }
+    finalizeTurn();
+  };
+  let exitCode = 0;
+  let resolveDone;
+  const done = new Promise((resolve6) => {
+    resolveDone = resolve6;
+  });
+  let settled = false;
+  const settle = async (code) => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    if (!opts.detach) {
+      conn.request("session/detach", { sessionId }).catch(() => void 0);
+    }
+    await conn.close().catch(() => void 0);
+    resolveDone({ exitCode: code });
+  };
+  conn.onClose((err) => {
+    if (err) {
+      stderr(`hydra-acp cat: ${err.message}
+`);
+      exitCode = 1;
+    }
+    if (!settled) {
+      settled = true;
+      resolveDone({ exitCode });
+    }
+  });
+  const chunkQueue = [];
+  let draining = false;
+  let stdinEnded = false;
+  const drainQueue = async () => {
+    if (draining) {
+      return;
+    }
+    draining = true;
+    try {
+      while (chunkQueue.length > 0) {
+        const next = chunkQueue.shift();
+        if (next === void 0) {
+          break;
+        }
+        await sendChunk(next);
+      }
+    } finally {
+      draining = false;
+      if (stdinEnded && chunkQueue.length === 0) {
+        await settle(exitCode);
+      }
+    }
+  };
+  const chunker = createChunker({
+    // setImmediate fires in the libuv "check" phase, after pending
+    // I/O has been polled and any back-to-back "data" events have
+    // been emitted. That makes it the natural hook for "the writer
+    // has paused, time to flush": if more bytes were sitting in the
+    // pipe buffer, Node would have emitted another "data" event
+    // before this fires, and the chunker would detect that and defer.
+    scheduleFlushCheck: (cb) => {
+      const h = setImmediate(cb);
+      return () => clearImmediate(h);
+    },
+    onChunk: (text) => {
+      chunkQueue.push(text);
+      void drainQueue();
+    }
+  });
+  if (stdinIsTty && !opts.sessionId) {
+    if (opts.prompt) {
+      await sendChunk("");
+    }
+    await settle(0);
+    return done;
+  }
+  if (typeof stdin.setEncoding === "function") {
+    stdin.setEncoding("utf8");
+  }
+  stdin.on("data", (data) => {
+    chunker.feed(typeof data === "string" ? data : data.toString("utf8"));
+  });
+  stdin.on("end", () => {
+    chunker.eof();
+    stdinEnded = true;
+    if (!draining && chunkQueue.length === 0) {
+      void settle(exitCode);
+    }
+  });
+  stdin.on("error", (err) => {
+    stderr(`hydra-acp cat: stdin error: ${err.message}
+`);
+    exitCode = 1;
+    stdinEnded = true;
+    if (!draining && chunkQueue.length === 0) {
+      void settle(exitCode);
+    }
+  });
+  return done;
+}
+async function openOrAttachSession(conn, opts) {
+  if (opts.sessionId) {
+    const attached = await conn.request("session/attach", {
+      sessionId: opts.sessionId,
+      historyPolicy: "pending_only",
+      clientInfo: { name: "hydra-acp-cat", version: HYDRA_VERSION }
+    });
+    return attached.sessionId;
+  }
+  const hydraMeta = {};
+  if (opts.name) {
+    hydraMeta.name = opts.name;
+  }
+  if (opts.model) {
+    hydraMeta.model = opts.model;
+  }
+  const cwd = opts.cwd ?? process.cwd();
+  const params = { cwd };
+  if (opts.agentId) {
+    params.agentId = opts.agentId;
+  }
+  if (Object.keys(hydraMeta).length > 0) {
+    params._meta = { [HYDRA_META_KEY]: hydraMeta };
+  }
+  const created = await conn.request("session/new", params);
+  void extractHydraMeta(created._meta);
+  return created.sessionId;
+}
+async function openWs2(url, subprotocols) {
+  return new Promise((resolve6, reject) => {
+    const ws = new WebSocket2(url, subprotocols);
+    const onOpen = () => {
+      ws.off("error", onError);
+      resolve6(ws);
+    };
+    const onError = (err) => {
+      ws.off("open", onOpen);
+      reject(err);
+    };
+    ws.once("open", onOpen);
+    ws.once("error", onError);
+  });
+}
+
 // src/cli.ts
 init_update_check();
 var suppressUpdateNotice = false;
@@ -18703,6 +19304,26 @@ async function main() {
       suppressUpdateNotice = true;
       await runShim({ sessionId, name, agentId: agentIdFromFlag, model });
       return;
+    case "cat": {
+      const promptFromShort = readShortPrompt(argv);
+      const longPrompt = typeof flags.prompt === "string" ? flags.prompt : void 0;
+      const prompt = promptFromShort ?? longPrompt;
+      const cwd = resolveOption(flags, "cwd");
+      const catOpts = {
+        prompt,
+        sessionId,
+        name,
+        model,
+        agentId: agentIdFromFlag,
+        detach: flags.detach === true
+      };
+      if (cwd !== void 0) {
+        catOpts.cwd = cwd;
+      }
+      suppressUpdateNotice = true;
+      await runCat(catOpts);
+      return;
+    }
     case "init":
       await runInit(flags);
       return;
@@ -18887,6 +19508,7 @@ async function dispatchTui(flags, base) {
     );
     process.exit(2);
   }
+  setHydraProcessTitle(buildTitleFromArgv(process.argv.slice(2)));
   const { runTui } = await Promise.resolve().then(() => (init_tui(), tui_exports));
   const tuiOpts = { resume, forceNew, readonly };
   if (base.sessionId !== void 0) {
@@ -18906,6 +19528,21 @@ async function dispatchTui(flags, base) {
   }
   await runTui(tuiOpts);
 }
+function readShortPrompt(argv) {
+  for (let i = 0; i < argv.length; i += 1) {
+    const tok = argv[i];
+    if (tok === void 0) {
+      continue;
+    }
+    if (tok === "-p") {
+      return argv[i + 1];
+    }
+    if (tok.startsWith("-p") && !tok.startsWith("--")) {
+      return tok.slice(2);
+    }
+  }
+  return void 0;
+}
 function bareResumeError() {
   process.stderr.write(
     "hydra-acp: --resume requires a session id. Use --resume <id> to attach to a specific session, or --reattach to pick the most recent one in cwd.\n"
@@ -18916,7 +19553,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 {
@@ -18932,6 +19569,19 @@ function printHelp() {
       "  hydra-acp                          Auto: TUI when stdout is a TTY, shim otherwise (the editor-spawned case)",
       "  hydra-acp shim                     Run as ACP shim explicitly (forces shim mode regardless of TTY)",
       "  hydra-acp tui [opts]               Run the terminal UI explicitly (see below for opts)",
+      "  hydra-acp cat [-p <prompt>] [--session-id <id>] [--detach] [--agent <id>] [--model <id>] [--name <label>]",
+      "                                     Pipe-friendly headless mode. Reads stdin and sends it",
+      "                                     as a prompt to a fresh session, streams the agent's",
+      "                                     response to stdout, exits when stdin closes. A bounded",
+      '                                     input (e.g. `cat file.log | hydra cat -p "..."`) goes in',
+      "                                     as one turn; a streaming input (e.g. `tail -f`) is",
+      "                                     chunked by the natural pauses in the writer. -p is an",
+      "                                     optional standing instruction prepended to every chunk;",
+      "                                     if stdin already contains the question, -p is not needed.",
+      "                                     With --session-id, attach to an existing session instead",
+      "                                     of creating a new one. With --detach, the session",
+      "                                     survives in the daemon for slack/browser/notifier",
+      "                                     extensions.",
       "  hydra-acp launch <agent> [agent-args...]",
       "                                     Shim mode, force daemon to spawn <agent>",
       "                                     from the registry. Args after <agent>",