@hydra-acp/cli 0.1.12 → 0.1.14

package/dist/cli.js

@@ -749,6 +749,11 @@ var init_hydra_commands = __esm({
         name: "hydra agent",
         argsHint: "<agent>",
         description: "Swap the agent backing this session, preserving context"
+      },
+      {
+        verb: "kill",
+        name: "hydra kill",
+        description: "Close this session (kills the agent; record is kept so it can be resumed later)"
       }
     ];
     VERB_INDEX = new Map(HYDRA_COMMANDS.map((c) => [c.verb, c]));
@@ -1635,6 +1640,8 @@ var init_session = __esm({
             return this.runTitleCommand(arg);
           case "agent":
             return this.runAgentCommand(arg);
+          case "kill":
+            return this.runKillCommand();
           default: {
             const err = new Error(
               `no dispatcher for /hydra verb ${verb}`
@@ -1746,6 +1753,17 @@ var init_session = __esm({
           return { stopReason: "end_turn" };
         });
       }
+      // Close this session in-place. Bypasses enqueuePrompt deliberately so a
+      // mid-turn /hydra kill takes effect immediately — agent.kill() will tear
+      // down any in-flight request as a side effect. The record is kept
+      // (deleteRecord:false) so the session goes cold and can be resurrected.
+      // Returns end_turn so the prompt() caller's response resolves normally,
+      // but every attached client has already received hydra-acp/session_closed
+      // by the time this returns.
+      async runKillCommand() {
+        await this.close({ deleteRecord: false });
+        return { stopReason: "end_turn" };
+      }
       // Walk the persisted history and produce a labeled transcript suitable
       // for handing to a fresh agent. Includes user prompts, agent replies,
       // and tool-call outcomes; skips hydra-synthesized markers (so multi-hop
@@ -2058,7 +2076,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       }
       async enqueuePrompt(task) {
         return new Promise((resolve5, reject) => {
-          const run2 = async () => {
+          const run3 = async () => {
             try {
               const result = await task();
               resolve5(result);
@@ -2066,7 +2084,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
               reject(err);
             }
           };
-          this.promptQueue.push(run2);
+          this.promptQueue.push(run3);
           void this.drainQueue();
         });
       }
@@ -3410,8 +3428,15 @@ async function pickSession(term, opts) {
   let total = 1 + visible.length;
   let selectedIdx = 0;
   let scrollOffset = 0;
+  if (opts.currentSessionId !== void 0) {
+    const idx = visible.findIndex((s) => s.sessionId === opts.currentSessionId);
+    if (idx >= 0) {
+      selectedIdx = idx + 1;
+    }
+  }
   let searchActive = false;
   let searchTerm = "";
+  let cwdOnly = false;
   let mode = "normal";
   let pendingAction = null;
   let transientStatus = null;
@@ -3440,10 +3465,14 @@ async function pickSession(term, opts) {
     computeLayout();
   };
   const applyFilter = () => {
+    let base = allSessions;
+    if (cwdOnly) {
+      base = base.filter((s) => s.cwd === opts.cwd);
+    }
     if (searchActive && searchTerm.length > 0) {
-      visible = allSessions.filter((s) => matchesSearch(s, searchTerm));
+      visible = base.filter((s) => matchesSearch(s, searchTerm));
     } else {
-      visible = allSessions;
+      visible = base;
     }
     rebuildRows();
     if (searchActive) {
@@ -3488,16 +3517,19 @@ async function pickSession(term, opts) {
   const formatIndicator = () => {
     const above = scrollOffset;
     const below = Math.max(0, visible.length - scrollOffset - viewportSize);
-    if (above === 0 && below === 0) {
-      return "";
-    }
     const parts = [];
+    if (cwdOnly) {
+      parts.push("cwd-only");
+    }
     if (above > 0) {
       parts.push(`\u2191 ${above} above`);
     }
     if (below > 0) {
       parts.push(`\u2193 ${below} below`);
     }
+    if (parts.length === 0) {
+      return "";
+    }
     return `  ${parts.join(" \xB7 ")}`;
   };
   const shortId2 = (sessionId) => stripHydraSessionPrefix(sessionId);
@@ -3721,6 +3753,38 @@ async function pickSession(term, opts) {
           renderFromScratch();
           return;
         }
+        if (name === "n" || name === "N") {
+          move(1);
+          return;
+        }
+        if (name === "p" || name === "P") {
+          move(-1);
+          return;
+        }
+        if (name === "c" || name === "C") {
+          cleanup();
+          resolve5({ kind: "new" });
+          return;
+        }
+        if (name === "q" || name === "Q") {
+          cleanup();
+          resolve5({ kind: "abort" });
+          return;
+        }
+        if (name === "o" || name === "O") {
+          const keepId = selectedIdx > 0 ? visible[selectedIdx - 1]?.sessionId : void 0;
+          cwdOnly = !cwdOnly;
+          applyFilter();
+          if (keepId !== void 0) {
+            const idx = visible.findIndex((s) => s.sessionId === keepId);
+            if (idx >= 0) {
+              selectedIdx = idx + 1;
+              adjustScroll();
+            }
+          }
+          renderFromScratch();
+          return;
+        }
         if (name === "r" || name === "R") {
           const currentId = selectedIdx > 0 ? visible[selectedIdx - 1]?.sessionId : void 0;
           void refresh(currentId);
@@ -3823,7 +3887,7 @@ function readTermWidth(term) {
   return term.width ?? 80;
 }
 function formatNewSessionLabel(cwd, maxWidth) {
-  const prefix = "+ New session in ";
+  const prefix = "New session in ";
   const budget = Math.max(1, maxWidth - prefix.length);
   return prefix + truncateMiddle(shortenHomePath(cwd), budget);
 }
@@ -3859,6 +3923,115 @@ var init_picker = __esm({
   }
 });
 
+// src/tui/attachments.ts
+import path9 from "path";
+function mimeFromExtension(p) {
+  return EXTENSION_TO_MIME[path9.extname(p).toLowerCase()] ?? null;
+}
+function isSupportedImagePath(p) {
+  return mimeFromExtension(p) !== null;
+}
+function parseDataUriImage(uri) {
+  const match = uri.match(/^data:(image\/[a-z0-9.+\-]+);base64,([A-Za-z0-9+/=]+)$/);
+  if (!match) {
+    return null;
+  }
+  const mimeType = match[1].toLowerCase();
+  if (!SUPPORTED_MIMES.has(mimeType)) {
+    return null;
+  }
+  const data = match[2];
+  const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
+  const sizeBytes = Math.floor(data.length * 3 / 4) - padding;
+  return { mimeType, data, sizeBytes };
+}
+function isSupportedDataUriImage(uri) {
+  return parseDataUriImage(uri) !== null;
+}
+function formatSize(bytes) {
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  }
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(0)}KB`;
+  }
+  return `${bytes}B`;
+}
+function parseImageDropPaste(raw) {
+  const text = raw.trim();
+  if (text.length === 0) {
+    return null;
+  }
+  const tokens = [];
+  let i = 0;
+  while (i < text.length) {
+    while (i < text.length && /\s/.test(text[i] ?? "")) {
+      i++;
+    }
+    if (i >= text.length) {
+      break;
+    }
+    const ch = text[i];
+    let token = "";
+    if (ch === "'" || ch === '"') {
+      const quote = ch;
+      i++;
+      while (i < text.length && text[i] !== quote) {
+        token += text[i];
+        i++;
+      }
+      if (i >= text.length) {
+        return null;
+      }
+      i++;
+    } else {
+      while (i < text.length && !/\s/.test(text[i] ?? "")) {
+        if (text[i] === "\\" && i + 1 < text.length) {
+          token += text[i + 1];
+          i += 2;
+        } else {
+          token += text[i];
+          i++;
+        }
+      }
+    }
+    if (token.startsWith("data:")) {
+      if (!isSupportedDataUriImage(token)) {
+        return null;
+      }
+      tokens.push(token);
+      continue;
+    }
+    let normalized = token;
+    if (normalized.startsWith("file://")) {
+      normalized = decodeURI(normalized.slice("file://".length));
+    }
+    if (!normalized.startsWith("/")) {
+      return null;
+    }
+    if (!isSupportedImagePath(normalized)) {
+      return null;
+    }
+    tokens.push(normalized);
+  }
+  return tokens.length > 0 ? tokens : null;
+}
+var MAX_ATTACHMENT_BYTES, EXTENSION_TO_MIME, SUPPORTED_MIMES;
+var init_attachments = __esm({
+  "src/tui/attachments.ts"() {
+    "use strict";
+    MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+    EXTENSION_TO_MIME = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp"
+    };
+    SUPPORTED_MIMES = new Set(Object.values(EXTENSION_TO_MIME));
+  }
+});
+
 // src/tui/screen.ts
 import stringWidth from "string-width";
 import wrapAnsi from "wrap-ansi";
@@ -3867,7 +4040,8 @@ function formattedLineSig(zone, width, line, highlight2 = null, activeCol = null
   if (!line) {
     return `${zone}|${width}|empty|${highlight2 ?? ""}|${active}`;
   }
-  return `${zone}|${width}|${line.prefix ?? ""}|${line.prefixStyle ?? ""}|${line.body}|${line.bodyStyle ?? ""}|${line.ansi ? "1" : "0"}|${line.fillRow ? "1" : "0"}|${highlight2 ?? ""}|${active}`;
+  const img = line.iterm2Image ? `i${line.iterm2Image.heightCells}:${line.iterm2Image.data.length}` : "";
+  return `${zone}|${width}|${line.prefix ?? ""}|${line.prefixStyle ?? ""}|${line.body}|${line.bodyStyle ?? ""}|${line.ansi ? "1" : "0"}|${line.fillRow ? "1" : "0"}|${highlight2 ?? ""}|${active}|${img}`;
 }
 function computePromptVisualRows(buffer, room) {
   const rows = [];
@@ -4115,6 +4289,14 @@ function* segmentForWidth(text) {
     i = runEnd;
   }
 }
+function buildIterm2ImageEscape(base64, heightCells, insideTmux) {
+  const inner = `\x1B]1337;File=inline=1;height=${heightCells};preserveAspectRatio=1:${base64}\x07`;
+  if (!insideTmux) {
+    return inner;
+  }
+  const doubled = inner.replace(/\x1b/g, "\x1B\x1B");
+  return `\x1BPtmux;${doubled}\x1B\\`;
+}
 function wrap(text, width, opts = {}) {
   if (width <= 0) {
     return [text];
@@ -4364,6 +4546,8 @@ function mapKeyName(name) {
       return "ctrl-s";
     case "CTRL_U":
       return "ctrl-u";
+    case "CTRL_V":
+      return "ctrl-v";
     case "CTRL_W":
       return "ctrl-w";
     case "CTRL_Y":
@@ -4374,13 +4558,14 @@ function mapKeyName(name) {
       return null;
   }
 }
-var HEADER_ROWS, BANNER_ROWS, SEPARATOR_ROWS, MAX_PROMPT_ROWS, MAX_QUEUED_ROWS, MAX_PERMISSION_ROWS, MAX_COMPLETION_ROWS, CONFIRM_PROMPT_ROWS, DEFAULT_CONTENT_REPAINT_THROTTLE_MS, DEFAULT_MAX_SCROLLBACK_LINES, Screen, NON_ASCII, SEGMENTER, TK_MARKUP_STYLE_CHAR, shortId;
+var HEADER_ROWS, BANNER_ROWS, SEPARATOR_ROWS, MAX_PROMPT_ROWS, MAX_QUEUED_ROWS, MAX_PERMISSION_ROWS, MAX_COMPLETION_ROWS, MAX_CHIP_ROWS, CONFIRM_PROMPT_ROWS, DEFAULT_CONTENT_REPAINT_THROTTLE_MS, DEFAULT_MAX_SCROLLBACK_LINES, Screen, NON_ASCII, SEGMENTER, TK_MARKUP_STYLE_CHAR, shortId;
 var init_screen = __esm({
   "src/tui/screen.ts"() {
     "use strict";
     init_agent_display();
     init_paths();
     init_session();
+    init_attachments();
     HEADER_ROWS = 2;
     BANNER_ROWS = 1;
     SEPARATOR_ROWS = 1;
@@ -4388,6 +4573,7 @@ var init_screen = __esm({
     MAX_QUEUED_ROWS = 5;
     MAX_PERMISSION_ROWS = 12;
     MAX_COMPLETION_ROWS = 6;
+    MAX_CHIP_ROWS = 4;
     CONFIRM_PROMPT_ROWS = 2;
     DEFAULT_CONTENT_REPAINT_THROTTLE_MS = 1e3;
     DEFAULT_MAX_SCROLLBACK_LINES = 1e4;
@@ -4407,6 +4593,12 @@ var init_screen = __esm({
       lastPromptRows = 0;
       queuedTexts = [];
       lastQueueEditingIndex = -1;
+      // Attachments on the current draft, pushed by the app whenever the
+      // dispatcher mutates. The chip zone (drawAttachmentChipZone) renders
+      // one row per attachment plus, in iTerm2-capable terminals, an inline
+      // thumbnail. Capped at MAX_CHIP_ROWS in the visible zone — additional
+      // chips collapse into an overflow row.
+      attachments = [];
       repaintPaused = 0;
       repaintPending = false;
       lastRepaintAt = 0;
@@ -4469,7 +4661,7 @@ var init_screen = __esm({
       banner = {
         status: "ready",
         planMode: false,
-        hint: "\u21E7\u21E5 plan \xB7 \u2325\u23CE newline \xB7 \u2303P pick \xB7 \u2303C cancel \xB7 \u2303D detach",
+        hint: "\u21E7\u21E5 plan \xB7 \u2325\u23CE newline \xB7 \u2303V paste \xB7 \u2303P pick \xB7 \u2303C cancel \xB7 \u2303D detach",
         queued: 0
       };
       header = { agent: "?", cwd: "?", sessionId: "?" };
@@ -4600,7 +4792,12 @@ var init_screen = __esm({
             this.pasteActive = false;
             const pasted = Buffer.from(this.pasteBuffer, "binary").toString("utf-8").replace(/\r\n?/g, "\n");
             this.pasteBuffer = "";
-            this.onKey([{ type: "paste", text: pasted }]);
+            const paths2 = parseImageDropPaste(pasted);
+            if (paths2 !== null) {
+              this.onKey([{ type: "attachment-paths", paths: paths2 }]);
+            } else {
+              this.onKey([{ type: "paste", text: pasted }]);
+            }
             continue;
           }
           const startIdx = text.indexOf(startMarker);
@@ -5351,7 +5548,7 @@ var init_screen = __esm({
       }
       scrollbackVisibleRows() {
         const top = HEADER_ROWS + SEPARATOR_ROWS;
-        const bottom = this.term.height - this.promptRows() - BANNER_ROWS - SEPARATOR_ROWS - this.queuedRows() - this.completionRows();
+        const bottom = this.term.height - this.promptRows() - BANNER_ROWS - SEPARATOR_ROWS - this.chipRows() - this.queuedRows() - this.completionRows();
         return Math.max(0, bottom - top + 1);
       }
       maxScrollOffset() {
@@ -5433,6 +5630,7 @@ var init_screen = __esm({
         this.drawScrollback();
         this.drawCompletionZone();
         this.drawQueuedZone();
+        this.drawAttachmentChipZone();
         const promptRows = this.promptRows();
         const separatorRow = h - promptRows - BANNER_ROWS;
         this.drawSeparator(separatorRow);
@@ -5524,6 +5722,16 @@ var init_screen = __esm({
       queuedRows() {
         return Math.min(MAX_QUEUED_ROWS, this.queuedTexts.length);
       }
+      chipRows() {
+        return Math.min(MAX_CHIP_ROWS, this.attachments.length);
+      }
+      setAttachments(attachments) {
+        if (this.attachments.length === attachments.length && this.attachments.every((a, i) => a === attachments[i])) {
+          return;
+        }
+        this.attachments = [...attachments];
+        this.repaint();
+      }
       completionRows() {
         if (this.permissionPrompt) {
           return 0;
@@ -5539,7 +5747,8 @@ var init_screen = __esm({
         const promptRows = this.promptRows();
         const separatorRow = this.term.height - promptRows - BANNER_ROWS;
         const queuedRows = this.queuedRows();
-        const completionBottom = separatorRow - 1 - queuedRows;
+        const chipRows = this.chipRows();
+        const completionBottom = separatorRow - 1 - queuedRows - chipRows;
         const completionTop = completionBottom - rows + 1;
         let nameWidth = 0;
         for (const item of this.completions.slice(0, rows)) {
@@ -5572,6 +5781,58 @@ var init_screen = __esm({
           });
         }
       }
+      // Chip zone: one row per attached image, sitting between the queued
+      // zone and the separator (closest to the user's draft). Each row
+      // shows "📎 <name> · <size>" plus, in iTerm2-capable terminals, a
+      // tiny inline thumbnail at the end. Overflow collapses into a
+      // single "+ N more attached" row.
+      drawAttachmentChipZone() {
+        const rows = this.chipRows();
+        if (rows === 0) {
+          return;
+        }
+        const w = this.term.width;
+        const promptRows = this.promptRows();
+        const separatorRow = this.term.height - promptRows - BANNER_ROWS;
+        const chipBottom = separatorRow - 1;
+        const chipTop = chipBottom - rows + 1;
+        const iterm = this.isIterm2();
+        for (let i = 0; i < rows; i++) {
+          const row = chipTop + i;
+          const isLast = i === rows - 1 && this.attachments.length > MAX_CHIP_ROWS;
+          const overflow = this.attachments.length - MAX_CHIP_ROWS;
+          const att = this.attachments[i];
+          const label = att ? `${att.name ?? "image"} \xB7 ${formatSize(att.sizeBytes)}` : "";
+          const sig = isLast ? `chip|${w}|overflow|${overflow}` : att ? `chip|${w}|${iterm ? "i" : "t"}|${label}|${att.sizeBytes}` : `chip|${w}|empty`;
+          this.paintRow(row, sig, () => {
+            if (isLast) {
+              this.term.dim(`  \u{1F4CE} + ${overflow + 1} more attached`);
+              return;
+            }
+            if (!att) {
+              return;
+            }
+            this.term("  ").yellow(`\u{1F4CE} ${label}`);
+            if (iterm) {
+              this.term(" ");
+              this.writeIterm2Image(att.data, 1);
+            }
+          });
+        }
+      }
+      isIterm2() {
+        const env = process.env;
+        return env.LC_TERMINAL === "iTerm2" || env.TERM_PROGRAM === "iTerm.app";
+      }
+      // Emits the iTerm2 OSC 1337 inline image escape at the current
+      // cursor position. Wraps in DCS-passthrough when tmux is detected
+      // (requires `set -g allow-passthrough on` in the user's tmux conf).
+      // Caller is responsible for knowing iTerm2 is the active terminal.
+      writeIterm2Image(base64, heightCells) {
+        process.stdout.write(
+          buildIterm2ImageEscape(base64, heightCells, Boolean(process.env.TMUX))
+        );
+      }
       drawQueuedZone() {
         const rows = this.queuedRows();
         if (rows === 0) {
@@ -5580,7 +5841,8 @@ var init_screen = __esm({
         const w = this.term.width;
         const promptRows = this.promptRows();
         const separatorRow = this.term.height - promptRows - BANNER_ROWS;
-        const queuedBottom = separatorRow - 1;
+        const chipRows = this.chipRows();
+        const queuedBottom = separatorRow - 1 - chipRows;
         const queuedTop = queuedBottom - rows + 1;
         const editingIndex = this.dispatcher.state().queueIndex;
         for (let i = 0; i < rows; i++) {
@@ -5729,6 +5991,8 @@ var init_screen = __esm({
             }
           } else if (this.banner.status === "disconnected") {
             this.term.brightRed(`${dot} ${this.banner.status}`);
+          } else if (this.banner.status === "cold") {
+            this.term.brightMagenta(`${dot} ${this.banner.status}`);
           } else {
             this.term.brightGreen(`${dot} ${this.banner.status}`);
           }
@@ -5883,6 +6147,9 @@ var init_screen = __esm({
           if (line.ansi) {
             wrappedLine.ansi = true;
           }
+          if (i === 0 && line.iterm2Image) {
+            wrappedLine.iterm2Image = line.iterm2Image;
+          }
           if (id !== void 0 && chunk.length > 0) {
             const found = line.body.indexOf(chunk, scanPos);
             const colOffset = found === -1 ? scanPos : found;
@@ -5928,6 +6195,12 @@ var init_screen = __esm({
         if (line.ansi || line.body.includes("^")) {
           this.term.styleReset();
         }
+        if (line.iterm2Image && this.isIterm2()) {
+          this.writeIterm2Image(
+            line.iterm2Image.data,
+            line.iterm2Image.heightCells
+          );
+        }
       }
     };
     NON_ASCII = /[^\x20-\x7e]/;
@@ -5972,6 +6245,17 @@ var init_input = __esm({
       // here so ^Y can yank it back. Standard readline keeps a stack; we
       // only keep one slot because that's what 99% of yank uses look like.
       killBuffer = "";
+      // Images attached to the current draft. Cleared in the same paths
+      // that clear the text buffer (clearBuffer, after send). Queue
+      // navigation snapshots/restores them alongside savedDraft so up/down
+      // through queued items doesn't drop chips.
+      attachments = [];
+      // Snapshot of `attachments` taken when the user starts walking
+      // history/queue with chips already attached. Restored alongside the
+      // text draft when the walk ends. Distinct from savedDraft because
+      // queue slots (which may carry their own attachments — though we
+      // don't surface that yet) shouldn't blend with the current draft's.
+      savedAttachments = null;
       constructor(opts = {}) {
         this.history = [...opts.history ?? []];
         this.planMode = opts.planMode ?? false;
@@ -5984,9 +6268,22 @@ var init_input = __esm({
           planMode: this.planMode,
           historyIndex: this.historyIndex,
           queueIndex: this.queueIndex,
+          attachments: [...this.attachments],
           historySearchQuery: this.historySearch?.query ?? null
         };
       }
+      // App calls this after asynchronously acquiring an image (drag-drop
+      // file read, clipboard shellout). The dispatcher just records it;
+      // chip rendering and capability gating live in the app/screen layer.
+      addAttachment(attachment) {
+        this.attachments.push(attachment);
+      }
+      removeAttachment(index) {
+        if (index < 0 || index >= this.attachments.length) {
+          return;
+        }
+        this.attachments.splice(index, 1);
+      }
       setTurnRunning(running) {
         this.turnRunning = running;
       }
@@ -6017,13 +6314,17 @@ var init_input = __esm({
       }
       // Public seed for the buffer (used for Escape pre-fill). Treated like a
       // fresh draft: nav state and any saved draft are cleared, cursor lands
-      // at the end so the user can edit immediately.
-      setBuffer(text) {
+      // at the end so the user can edit immediately. Attachments restore
+      // alongside the text so a cancelled turn's chips land back in the
+      // draft together with the typed prompt.
+      setBuffer(text, attachments = []) {
         this.loadEntry(text);
         this.historyIndex = -1;
         this.queueIndex = -1;
         this.savedDraft = null;
+        this.savedAttachments = null;
         this.historySearch = null;
+        this.attachments = [...attachments];
       }
       feed(event) {
         if (this.historySearch !== null) {
@@ -6069,6 +6370,9 @@ var init_input = __esm({
           this.insertText(event.text);
           return [];
         }
+        if (event.type === "attachment-paths") {
+          return [];
+        }
         return this.handleKey(event.name);
       }
       handleKey(name) {
@@ -6145,6 +6449,8 @@ var init_input = __esm({
           case "ctrl-u":
             this.killLine();
             return [];
+          case "ctrl-v":
+            return [{ type: "attachment-request", source: "clipboard" }];
           case "ctrl-w":
             this.killWord();
             return [];
@@ -6177,7 +6483,9 @@ var init_input = __esm({
         this.historyIndex = -1;
         this.queueIndex = -1;
         this.savedDraft = null;
+        this.savedAttachments = null;
         this.historySearch = null;
+        this.attachments = [];
       }
       insertChar(ch) {
         if (ch.length === 0) {
@@ -6329,6 +6637,8 @@ var init_input = __esm({
             row: this.row,
             col: this.col
           };
+          this.savedAttachments = [...this.attachments];
+          this.attachments = [];
           if (this.queue.length > 0) {
             this.queueIndex = this.queue.length - 1;
             this.loadEntry(this.queue[this.queueIndex] ?? "");
@@ -6401,6 +6711,8 @@ var init_input = __esm({
           this.row = this.savedDraft.row;
           this.col = this.savedDraft.col;
           this.savedDraft = null;
+          this.attachments = this.savedAttachments ?? [];
+          this.savedAttachments = null;
         } else {
           this.clearBuffer();
         }
@@ -6554,18 +6866,20 @@ var init_input = __esm({
         const text = this.bufferText();
         if (this.queueIndex >= 0 && this.queueIndex < this.queue.length) {
           const index = this.queueIndex;
+          const attachments2 = [...this.attachments];
           this.clearBuffer();
           if (text.trim().length === 0) {
             return [{ type: "queue-remove", index }];
           }
-          return [{ type: "queue-edit", index, text }];
+          return [{ type: "queue-edit", index, text, attachments: attachments2 }];
         }
-        if (text.trim().length === 0) {
+        if (text.trim().length === 0 && this.attachments.length === 0) {
           return [];
         }
         const planMode = this.planMode;
+        const attachments = [...this.attachments];
         this.clearBuffer();
-        return [{ type: "send", text, planMode }];
+        return [{ type: "send", text, planMode, attachments }];
       }
       // Home: jump to the very start of the prompt buffer. If we're already
       // there, fall through to scrolling the scrollback to its top.
@@ -6590,19 +6904,20 @@ var init_input = __esm({
         return [{ type: "scroll-to-bottom" }];
       }
       handleCtrlC() {
-        if (!this.bufferIsEmpty()) {
-          this.buffer = [""];
-          this.row = 0;
-          this.col = 0;
-          if (this.queueIndex === -1) {
-            this.historyIndex = -1;
-            this.savedDraft = null;
-          }
-          return [];
-        }
         if (this.queueIndex >= 0) {
+          const index = this.queueIndex;
           this.queueIndex = -1;
           this.restoreDraft();
+          return [{ type: "queue-remove", index }];
+        }
+        if (!this.bufferIsEmpty() || this.attachments.length > 0) {
+          this.buffer = [""];
+          this.row = 0;
+          this.col = 0;
+          this.attachments = [];
+          this.historyIndex = -1;
+          this.savedDraft = null;
+          this.savedAttachments = null;
           return [];
         }
         if (this.turnRunning) {
@@ -6614,6 +6929,232 @@ var init_input = __esm({
   }
 });
 
+// src/tui/clipboard.ts
+import { spawn as nodeSpawn } from "child_process";
+import fs14 from "fs/promises";
+import os4 from "os";
+import path10 from "path";
+async function readClipboard(envIn = {}) {
+  const env = { ...defaultEnv, ...envIn };
+  if (env.platform === "darwin") {
+    return readMacOS(env);
+  }
+  if (env.platform === "linux") {
+    return readLinux(env);
+  }
+  return {
+    ok: false,
+    reason: `clipboard paste is not supported on ${env.platform}`
+  };
+}
+async function readMacOS(env) {
+  const tmpPath = path10.join(
+    env.tmpdir(),
+    `hydra-clipboard-${Date.now()}-${process.pid}.png`
+  );
+  const script = [
+    "set png_data to the clipboard as \xABclass PNGf\xBB",
+    `set out_file to (open for access (POSIX file "${tmpPath}") with write permission)`,
+    "write png_data to out_file",
+    "close access out_file"
+  ];
+  const args = [];
+  for (const line of script) {
+    args.push("-e", line);
+  }
+  try {
+    await run2(env.spawn, "osascript", args);
+    const img = await readFileAsAttachment(tmpPath, true);
+    if (img.ok) {
+      return img;
+    }
+    if (img.reason.startsWith("clipboard image is")) {
+      return img;
+    }
+  } catch {
+    await fs14.unlink(tmpPath).catch(() => void 0);
+  }
+  try {
+    const buf = await runCapture(env.spawn, "pbpaste", []);
+    if (buf.length === 0) {
+      return { ok: false, reason: "clipboard is empty" };
+    }
+    return { ok: true, kind: "text", text: normalizeText(buf.toString("utf-8")) };
+  } catch {
+    return { ok: false, reason: "clipboard read failed" };
+  }
+}
+async function readLinux(env) {
+  const tool = await detectLinuxTool(env);
+  if (!tool) {
+    return {
+      ok: false,
+      reason: "install wl-clipboard (Wayland) or xclip (X11) to paste from the clipboard"
+    };
+  }
+  try {
+    const buf = await runCapture(env.spawn, tool.cmd, tool.imageArgs);
+    if (buf.length > 0) {
+      if (buf.length > MAX_ATTACHMENT_BYTES) {
+        return {
+          ok: false,
+          reason: `clipboard image is ${formatSize(buf.length)}, max ${formatSize(MAX_ATTACHMENT_BYTES)}`
+        };
+      }
+      return {
+        ok: true,
+        kind: "image",
+        attachment: {
+          mimeType: "image/png",
+          data: buf.toString("base64"),
+          sizeBytes: buf.length
+        }
+      };
+    }
+  } catch {
+  }
+  try {
+    const buf = await runCapture(env.spawn, tool.cmd, tool.textArgs);
+    if (buf.length === 0) {
+      return { ok: false, reason: "clipboard is empty" };
+    }
+    return {
+      ok: true,
+      kind: "text",
+      text: normalizeText(buf.toString("utf-8"))
+    };
+  } catch {
+    return { ok: false, reason: "clipboard read failed" };
+  }
+}
+async function detectLinuxTool(env) {
+  if (env.env.WAYLAND_DISPLAY && await which(env, "wl-paste")) {
+    return {
+      cmd: "wl-paste",
+      imageArgs: ["-t", "image/png"],
+      // -n: drop trailing newline wl-paste adds by default. We further
+      // normalize line endings below, but this avoids a spurious
+      // empty trailing row from a single-line clipboard text.
+      textArgs: ["-n"]
+    };
+  }
+  if (env.env.DISPLAY && await which(env, "xclip")) {
+    return {
+      cmd: "xclip",
+      imageArgs: ["-selection", "clipboard", "-t", "image/png", "-o"],
+      textArgs: ["-selection", "clipboard", "-o"]
+    };
+  }
+  return null;
+}
+function normalizeText(text) {
+  return text.replace(/\r\n?/g, "\n");
+}
+async function which(env, cmd) {
+  try {
+    await run2(env.spawn, "which", [cmd]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readFileAsAttachment(p, unlinkAfter) {
+  try {
+    const buf = await fs14.readFile(p);
+    if (unlinkAfter) {
+      await fs14.unlink(p).catch(() => void 0);
+    }
+    if (buf.length === 0) {
+      return { ok: false, reason: "no image on clipboard" };
+    }
+    if (buf.length > MAX_ATTACHMENT_BYTES) {
+      return {
+        ok: false,
+        reason: `clipboard image is ${formatSize(buf.length)}, max ${formatSize(MAX_ATTACHMENT_BYTES)}`
+      };
+    }
+    const mimeType = mimeFromExtension(p) ?? "image/png";
+    return {
+      ok: true,
+      kind: "image",
+      attachment: {
+        mimeType,
+        data: buf.toString("base64"),
+        sizeBytes: buf.length
+      }
+    };
+  } catch {
+    return { ok: false, reason: "failed to read clipboard image" };
+  }
+}
+function run2(spawn6, cmd, args) {
+  return new Promise((resolve5, 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();
+      } else {
+        reject(new Error(`${cmd} exited ${code}`));
+      }
+    });
+  });
+}
+function runCapture(spawn6, cmd, args) {
+  return new Promise((resolve5, reject) => {
+    const proc = spawn6(cmd, args);
+    const chunks = [];
+    let stdoutEnded = proc.stdout === null;
+    let closedCode = null;
+    let settled = false;
+    const settle = () => {
+      if (settled || !stdoutEnded || closedCode === null) {
+        return;
+      }
+      settled = true;
+      if (closedCode === 0) {
+        resolve5(Buffer.concat(chunks));
+      } else {
+        reject(new Error(`${cmd} exited ${closedCode}`));
+      }
+    };
+    proc.stdout?.on("data", (chunk) => {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    });
+    proc.stdout?.on("end", () => {
+      stdoutEnded = true;
+      settle();
+    });
+    proc.stderr?.on("data", () => void 0);
+    proc.on("error", (err) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      reject(err);
+    });
+    proc.on("close", (code) => {
+      closedCode = code ?? 0;
+      settle();
+    });
+  });
+}
+var defaultEnv;
+var init_clipboard = __esm({
+  "src/tui/clipboard.ts"() {
+    "use strict";
+    init_attachments();
+    defaultEnv = {
+      platform: process.platform,
+      env: process.env,
+      spawn: nodeSpawn,
+      tmpdir: os4.tmpdir
+    };
+  }
+});
+
 // src/tui/completion.ts
 function longestCommonPrefix(names) {
   if (names.length === 0) {
@@ -6948,8 +7489,29 @@ import chalk from "chalk";
 import { highlight, supportsLanguage } from "cli-highlight";
 function formatEvent(event) {
   switch (event.kind) {
-    case "user-text":
-      return formatBlock(event.text, "\u258E ", "user", void 0, event.sentBy, true);
+    case "user-text": {
+      const lines = formatBlock(
+        event.text,
+        "\u258E ",
+        "user",
+        void 0,
+        event.sentBy,
+        true
+      );
+      if (event.attachments && event.attachments.length > 0) {
+        for (const a of event.attachments) {
+          lines.push({
+            prefix: "\u258E ",
+            prefixStyle: "user",
+            body: `\u{1F4CE} ${a.name ?? "image"}`,
+            bodyStyle: "user",
+            fillRow: true,
+            iterm2Image: { data: a.data, heightCells: 5 }
+          });
+        }
+      }
+      return lines;
+    }
     case "agent-text":
       return formatBlock(event.text, "  ", "agent");
     case "agent-thought":
@@ -7279,6 +7841,8 @@ var init_format = __esm({
 import { appendFileSync, statSync, renameSync } from "fs";
 import { nanoid as nanoid3 } from "nanoid";
 import termkit from "terminal-kit";
+import fs15 from "fs/promises";
+import path11 from "path";
 async function runTuiApp(opts) {
   const config = await ensureConfig();
   logMaxBytes = config.tui.logMaxBytes;
@@ -7396,6 +7960,15 @@ async function runSession(term, config, opts, exitHint) {
     appendRender(event);
     maybeDismissPermissionByToolUpdate(update);
   });
+  conn.onNotification("hydra-acp/session_closed", () => {
+    if (pendingTurns > 0) {
+      adjustPendingTurns(-pendingTurns);
+    }
+    const screenReady = typeof screenRef !== "undefined" && screenRef !== null;
+    if (screenReady) {
+      screenRef.setBanner({ status: "cold", elapsedMs: void 0 });
+    }
+  });
   const handlePermissionResolved = (update) => {
     const u = update ?? {};
     const toolCallId = typeof u.toolCallId === "string" ? u.toolCallId : void 0;
@@ -7499,6 +8072,7 @@ async function runSession(term, config, opts, exitHint) {
   });
   let upstreamSessionId;
   let agentInfoName;
+  let agentAcceptsImages = true;
   try {
     const initResult = await conn.request("initialize", {
       protocolVersion: ACP_PROTOCOL_VERSION,
@@ -7509,6 +8083,10 @@ async function runSession(term, config, opts, exitHint) {
       clientInfo: { name: "hydra-acp-tui", version: HYDRA_VERSION }
     });
     agentInfoName = initResult?.agentInfo?.name;
+    const imageCap = initResult?.agentCapabilities?.promptCapabilities?.image;
+    if (imageCap === false) {
+      agentAcceptsImages = false;
+    }
   } catch {
   }
   let resolvedSessionId = ctx.sessionId;
@@ -7607,6 +8185,10 @@ async function runSession(term, config, opts, exitHint) {
         if (tryHandleCompletionKey(ev)) {
           continue;
         }
+        if (ev.type === "attachment-paths") {
+          void handleAttachmentPaths(ev.paths);
+          continue;
+        }
         const effects = dispatcher.feed(ev);
         for (const effect of effects) {
           handleEffect(effect);
@@ -7616,6 +8198,7 @@ async function runSession(term, config, opts, exitHint) {
       screen.setBannerSearchIndicator(
         dispatcher.state().historySearchQuery
       );
+      screen.setAttachments(dispatcher.state().attachments);
       screen.refreshPrompt();
     }
   });
@@ -7906,7 +8489,8 @@ async function runSession(term, config, opts, exitHint) {
     const choice = await pickSession(term, {
       cwd: resolvedCwd,
       sessions,
-      config
+      config,
+      currentSessionId: resolvedSessionId
     });
     if (choice.kind === "abort") {
       screen.start();
@@ -7937,13 +8521,17 @@ async function runSession(term, config, opts, exitHint) {
   const handleEffect = (effect) => {
     switch (effect.type) {
       case "send":
-        enqueuePrompt(effect.text, effect.planMode);
+        enqueuePrompt(effect.text, effect.planMode, effect.attachments);
         return;
       case "queue-edit": {
         const realIdx = effect.index + queueHeadOffset();
         const existing = promptQueue[realIdx];
         if (existing) {
-          promptQueue[realIdx] = { text: effect.text, planMode: existing.planMode };
+          promptQueue[realIdx] = {
+            text: effect.text,
+            planMode: existing.planMode,
+            attachments: effect.attachments
+          };
           refreshQueueDisplay();
         }
         return;
@@ -7962,7 +8550,10 @@ async function runSession(term, config, opts, exitHint) {
           const waitingEmpty = promptQueue.length <= headOffset;
           const bufferEmpty = dispatcher.state().buffer.every((line) => line === "");
           if (waitingEmpty && bufferEmpty) {
-            pendingPrefill = turnInFlight.text;
+            pendingPrefill = {
+              text: turnInFlight.text,
+              attachments: turnInFlight.attachments
+            };
           }
         }
         if (turnInFlight) {
@@ -8001,17 +8592,104 @@ async function runSession(term, config, opts, exitHint) {
         screen.enterScrollbackSearch();
         screen.updateScrollbackSearchTerm(effect.query);
         return;
+      case "attachment-request":
+        void handleClipboardAttachment();
+        return;
     }
   };
+  const handleAttachmentPaths = async (tokens) => {
+    if (!agentAcceptsImages) {
+      screen.notify("agent does not accept image attachments");
+      return;
+    }
+    let added = 0;
+    for (const token of tokens) {
+      if (token.startsWith("data:")) {
+        const parsed = parseDataUriImage(token);
+        if (!parsed) {
+          screen.notify("unsupported data: URI");
+          continue;
+        }
+        if (parsed.sizeBytes > MAX_ATTACHMENT_BYTES) {
+          screen.notify(
+            `image too large (${formatSize(parsed.sizeBytes)}, max ${formatSize(MAX_ATTACHMENT_BYTES)})`
+          );
+          continue;
+        }
+        dispatcher.addAttachment({
+          mimeType: parsed.mimeType,
+          data: parsed.data,
+          name: "pasted image",
+          sizeBytes: parsed.sizeBytes
+        });
+        added++;
+        continue;
+      }
+      const mimeType = mimeFromExtension(token);
+      if (!mimeType) {
+        screen.notify(`unsupported image type: ${path11.basename(token)}`);
+        continue;
+      }
+      try {
+        const buf = await fs15.readFile(token);
+        if (buf.length > MAX_ATTACHMENT_BYTES) {
+          screen.notify(
+            `image too large (${formatSize(buf.length)}, max ${formatSize(MAX_ATTACHMENT_BYTES)})`
+          );
+          continue;
+        }
+        dispatcher.addAttachment({
+          mimeType,
+          data: buf.toString("base64"),
+          name: path11.basename(token),
+          sizeBytes: buf.length
+        });
+        added++;
+      } catch (err) {
+        screen.notify(
+          `cannot read ${path11.basename(token)}: ${err.message}`
+        );
+      }
+    }
+    if (added > 0) {
+      screen.setAttachments(dispatcher.state().attachments);
+      screen.refreshPrompt();
+    }
+  };
+  const handleClipboardAttachment = async () => {
+    const result = await readClipboard();
+    if (!result.ok) {
+      screen.notify(result.reason);
+      return;
+    }
+    if (result.kind === "image") {
+      if (!agentAcceptsImages) {
+        screen.notify("agent does not accept image attachments");
+        return;
+      }
+      dispatcher.addAttachment(result.attachment);
+      screen.setAttachments(dispatcher.state().attachments);
+      screen.refreshPrompt();
+      return;
+    }
+    const effects = dispatcher.feed({ type: "paste", text: result.text });
+    for (const effect of effects) {
+      handleEffect(effect);
+    }
+    screen.refreshPrompt();
+  };
   const promptQueue = [];
   let workerActive = false;
   const refreshQueueDisplay = () => {
     const waiting = promptQueue.slice(workerActive ? 1 : 0);
-    screen.setQueuedPrompts(waiting.map((p) => p.text));
+    const displayTexts = waiting.map(
+      (p) => p.attachments.length > 0 ? `${p.text} \xB7 \u{1F4CE}\xD7${p.attachments.length}` : p.text
+    );
+    screen.setQueuedPrompts(displayTexts);
     screen.setBanner({ queued: waiting.length });
     dispatcher.setQueue(waiting.map((p) => p.text));
   };
-  const enqueuePrompt = (text, planMode) => {
+  const enqueuePrompt = (text, planMode, attachments) => {
     screen.scrollToBottom();
     if (handleBuiltinCommand(text)) {
       return;
@@ -8019,7 +8697,7 @@ async function runSession(term, config, opts, exitHint) {
     history = appendEntry(history, text);
     dispatcher.setHistory(history);
     saveHistory(historyFile, history).catch(() => void 0);
-    promptQueue.push({ text, planMode });
+    promptQueue.push({ text, planMode, attachments });
     refreshQueueDisplay();
     tickWorker();
   };
@@ -8186,31 +8864,38 @@ async function runSession(term, config, opts, exitHint) {
           break;
         }
         refreshQueueDisplay();
-        await processPrompt(next.text, next.planMode);
+        await processPrompt(next.text, next.planMode, next.attachments);
         promptQueue.shift();
       }
     } finally {
       workerActive = false;
       refreshQueueDisplay();
       if (pendingPrefill !== null) {
-        const text = pendingPrefill;
+        const { text, attachments } = pendingPrefill;
         pendingPrefill = null;
         const bufferEmpty = dispatcher.state().buffer.every((line) => line === "");
         if (bufferEmpty) {
-          dispatcher.setBuffer(text);
+          dispatcher.setBuffer(text, attachments);
           screen.refreshPrompt();
         }
       }
     }
   };
-  const processPrompt = async (text, planMode) => {
-    const userBlocks = [{ type: "text", text }];
+  const processPrompt = async (text, planMode, attachments) => {
+    const userBlocks = [];
+    if (text.length > 0) {
+      userBlocks.push({ type: "text", text });
+    }
+    for (const a of attachments) {
+      userBlocks.push({ type: "image", data: a.data, mimeType: a.mimeType });
+    }
     const promptArr = planMode ? [{ type: "text", text: PLAN_PREFIX_TEXT }, ...userBlocks] : userBlocks;
     adjustPendingTurns(1);
-    appendRender({ kind: "user-text", text });
+    appendRender({ kind: "user-text", text, attachments });
     let cancelled = false;
     turnInFlight = {
       text,
+      attachments,
       cancel: () => {
         if (cancelled) {
           return;
@@ -8707,6 +9392,8 @@ var init_app = __esm({
     init_picker();
     init_screen();
     init_input();
+    init_attachments();
+    init_clipboard();
     init_completion();
     init_render_update();
     init_format();

package/dist/index.d.ts

@@ -1777,6 +1777,7 @@ declare class Session {
     private runTitleRegen;
     private runInternalPrompt;
     private runAgentCommand;
+    private runKillCommand;
     private buildSwitchTranscript;
     seedFromImport(): Promise<void>;
     private broadcastAgentSwitch;

package/dist/index.js

@@ -1448,6 +1448,11 @@ var HYDRA_COMMANDS = [
     name: "hydra agent",
     argsHint: "<agent>",
     description: "Swap the agent backing this session, preserving context"
+  },
+  {
+    verb: "kill",
+    name: "hydra kill",
+    description: "Close this session (kills the agent; record is kept so it can be resumed later)"
   }
 ];
 var VERB_INDEX = new Map(HYDRA_COMMANDS.map((c) => [c.verb, c]));
@@ -2152,6 +2157,8 @@ var Session = class {
         return this.runTitleCommand(arg);
       case "agent":
         return this.runAgentCommand(arg);
+      case "kill":
+        return this.runKillCommand();
       default: {
         const err = new Error(
           `no dispatcher for /hydra verb ${verb}`
@@ -2263,6 +2270,17 @@ var Session = class {
       return { stopReason: "end_turn" };
     });
   }
+  // Close this session in-place. Bypasses enqueuePrompt deliberately so a
+  // mid-turn /hydra kill takes effect immediately — agent.kill() will tear
+  // down any in-flight request as a side effect. The record is kept
+  // (deleteRecord:false) so the session goes cold and can be resurrected.
+  // Returns end_turn so the prompt() caller's response resolves normally,
+  // but every attached client has already received hydra-acp/session_closed
+  // by the time this returns.
+  async runKillCommand() {
+    await this.close({ deleteRecord: false });
+    return { stopReason: "end_turn" };
+  }
   // Walk the persisted history and produce a labeled transcript suitable
   // for handing to a fresh agent. Includes user prompts, agent replies,
   // and tool-call outcomes; skips hydra-synthesized markers (so multi-hop

package/package.json

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