@hydra-acp/cli 0.1.11 → 0.1.13

package/dist/cli.js

@@ -264,7 +264,13 @@ var init_config = __esm({
       // Width cap on the cwd column in the `sessions list` output and the
       // TUI picker. Set higher if you keep deeply-nested working directories
       // and want them visible; the elastic title column shrinks to make room.
-      cwdColumnMaxWidth: z.number().int().positive().default(24)
+      cwdColumnMaxWidth: z.number().int().positive().default(24),
+      // When true (default), emit OSC 9;4 progress-bar control codes so the
+      // host terminal can show an indeterminate busy indicator (taskbar pulse
+      // on Windows Terminal, dock badge on KDE/Konsole, etc.) while a turn is
+      // running. Set false if your terminal renders this obnoxiously or you
+      // just don't want it.
+      progressIndicator: z.boolean().default(true)
     });
     ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
     ExtensionBody = z.object({
@@ -302,7 +308,8 @@ var init_config = __esm({
         maxScrollbackLines: 1e4,
         mouse: true,
         logMaxBytes: 5 * 1024 * 1024,
-        cwdColumnMaxWidth: 24
+        cwdColumnMaxWidth: 24,
+        progressIndicator: true
       })
     });
     HydraConfigReadOnly = HydraConfig.extend({
@@ -483,6 +490,11 @@ var init_types = __esm({
       // Last-known usage snapshot so list views can show per-session cost
       // (and tokens, in callers that care) without resurrecting cold sessions.
       currentUsage: SessionListUsage.optional(),
+      // Origin host (and origin upstream id) for imported sessions. Picker
+      // uses the host to fill in the UPSTREAM cell pre-first-attach;
+      // future "connect back to origin" callers would dial both.
+      importedFromMachine: z3.string().optional(),
+      importedFromUpstreamSessionId: z3.string().optional(),
       updatedAt: z3.string(),
       attachedClients: z3.number().int().nonnegative(),
       status: z3.enum(["live", "cold"]).default("live"),
@@ -737,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]));
@@ -1006,6 +1023,7 @@ var init_session = __esm({
       // and noisy state churn keep a quiet session alive forever.
       lastRecordedAt;
       spawnReplacementAgent;
+      logger;
       agentChangeHandlers = [];
       // Last available_commands_update we observed from the agent. Stored
       // so we can re-broadcast a merged (hydra ∪ agent) list whenever
@@ -1037,6 +1055,7 @@ var init_session = __esm({
         }
         this.idleTimeoutMs = init.idleTimeoutMs ?? 0;
         this.spawnReplacementAgent = init.spawnReplacementAgent;
+        this.logger = init.logger;
         if (init.firstPromptSeeded) {
           this.firstPromptSeeded = true;
         }
@@ -1366,6 +1385,9 @@ var init_session = __esm({
         if (this.closed) {
           return;
         }
+        this.logger?.info(
+          `session ${this.sessionId} closing deleteRecord=${opts.deleteRecord ?? false} regenTitle=${opts.regenTitle ?? false}`
+        );
         this.cancelIdleTimer();
         if (opts.regenTitle && this.firstPromptSeeded) {
           const timeoutMs = opts.regenTitleTimeoutMs ?? 5e3;
@@ -1618,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}`
@@ -1729,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
@@ -1920,6 +1955,10 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
           return;
         }
         const opts = this.firstPromptSeeded ? { deleteRecord: false, regenTitle: true } : { deleteRecord: true };
+        const idleSec = Math.round(idle / 1e3);
+        this.logger?.info(
+          `session ${this.sessionId} idle timeout fired after ${idleSec}s (window=${Math.round(this.idleTimeoutMs / 1e3)}s) \u2014 closing`
+        );
         void this.close(opts).catch(() => void 0);
       }
       cancelIdleTimer() {
@@ -2037,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);
@@ -2045,7 +2084,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
               reject(err);
             }
           };
-          this.promptQueue.push(run2);
+          this.promptQueue.push(run3);
           void this.drainQueue();
         });
       }
@@ -2096,6 +2135,8 @@ function recordFromMemorySession(args) {
     lineageId: args.lineageId,
     upstreamSessionId: args.upstreamSessionId,
     importedFromSessionId: args.importedFromSessionId,
+    importedFromUpstreamSessionId: args.importedFromUpstreamSessionId,
+    importedFromMachine: args.importedFromMachine,
     agentId: args.agentId,
     cwd: args.cwd,
     title: args.title,
@@ -2143,6 +2184,16 @@ var init_session_store = __esm({
       // origin's local id at export time, kept for debuggability and as a
       // breadcrumb in `sessions list` (informational, not used for routing).
       importedFromSessionId: z4.string().optional(),
+      // Origin's agent-side session id at export time. Carried as a
+      // breadcrumb and as the handle a future "connect back to origin"
+      // feature would dial. Absent when the origin record had no upstream
+      // bound (re-export of an imported, not-yet-attached session).
+      importedFromUpstreamSessionId: z4.string().optional(),
+      // Hostname of the machine that exported the bundle we imported
+      // (i.e. the most recent hop, not necessarily the true multi-hop
+      // origin). Surfaced in the picker so imported rows don't look like
+      // they materialized from nowhere.
+      importedFromMachine: z4.string().optional(),
       agentId: z4.string(),
       cwd: z4.string(),
       title: z4.string().optional(),
@@ -2358,6 +2409,7 @@ function encodeBundle(params) {
     session: {
       sessionId: params.record.sessionId,
       lineageId: params.record.lineageId,
+      ...params.record.upstreamSessionId ? { upstreamSessionId: params.record.upstreamSessionId } : {},
       agentId: params.record.agentId,
       cwd: params.record.cwd,
       ...params.record.title !== void 0 ? { title: params.record.title } : {},
@@ -2395,6 +2447,12 @@ var init_bundle = __esm({
       // Required on bundles — the export path backfills if the source
       // record was written before lineageId existed.
       lineageId: z5.string(),
+      // The exporter's agent-side session id at export time. Carried so
+      // importers can persist it as a breadcrumb (and, eventually, as the
+      // handle a "connect back to origin" feature would need). Omitted on
+      // bundles whose source record never bound to an agent (e.g. a
+      // re-export of an imported, not-yet-attached session).
+      upstreamSessionId: z5.string().optional(),
       agentId: z5.string(),
       cwd: z5.string(),
       title: z5.string().optional(),
@@ -2608,7 +2666,7 @@ var init_agent_display = __esm({
 function toRow(s, now = Date.now()) {
   return {
     session: stripHydraSessionPrefix(s.sessionId),
-    upstream: s.upstreamSessionId ?? "-",
+    upstream: formatUpstreamCell(s.upstreamSessionId, s.importedFromMachine),
     state: formatState(s.status, s.attachedClients),
     agent: formatAgentCell(s.agentId, s.currentUsage),
     age: formatRelativeAge(s.updatedAt, now),
@@ -2616,6 +2674,15 @@ function toRow(s, now = Date.now()) {
     cwd: shortenHomePath(s.cwd)
   };
 }
+function formatUpstreamCell(upstreamSessionId, importedFromMachine) {
+  if (upstreamSessionId && upstreamSessionId.length > 0) {
+    return upstreamSessionId;
+  }
+  if (importedFromMachine && importedFromMachine.length > 0) {
+    return `\u2190 ${importedFromMachine}`;
+  }
+  return "-";
+}
 function formatState(status, clients) {
   if (status === "cold") {
     return "COLD";
@@ -2955,11 +3022,11 @@ async function runSessionsImport(file, opts = {}) {
 function bundleToSummary(parsed) {
   return {
     sessionId: parsed.session.sessionId,
-    upstreamSessionId: "-",
     cwd: parsed.session.cwd,
     agentId: parsed.session.agentId,
     currentUsage: parsed.session.currentUsage,
     title: parsed.session.title,
+    importedFromMachine: parsed.exportedFrom.machine,
     attachedClients: 0,
     updatedAt: parsed.session.updatedAt,
     status: "cold"
@@ -2980,10 +3047,13 @@ function printBundleInfo(raw, cwdColumnMaxWidth) {
   const maxWidth = process.stdout.isTTY ? process.stdout.columns : void 0;
   process.stdout.write(formatRow(HEADER, widths, maxWidth, cwdColumnMaxWidth) + "\n");
   process.stdout.write(formatRow(row, widths, maxWidth, cwdColumnMaxWidth) + "\n");
+  const originUpstream = parsed.session.upstreamSessionId ?? "-";
   process.stdout.write(
     `
 lineage: ${parsed.session.lineageId}
 exported: ${parsed.exportedAt} from ${parsed.exportedFrom.machine} (hydra ${parsed.exportedFrom.hydraVersion})
+origin session: ${parsed.session.sessionId}
+origin upstream: ${originUpstream}
 history entries: ${parsed.history.length}` + (parsed.promptHistory ? `, prompt history: ${parsed.promptHistory.length}
 ` : "\n")
   );
@@ -3284,7 +3354,9 @@ async function listSessions(config, opts = {}, fetchImpl = fetch) {
     agentId: s.agentId,
     currentModel: s.currentModel,
     currentUsage: s.currentUsage,
-    title: s.title
+    title: s.title,
+    importedFromMachine: s.importedFromMachine,
+    importedFromUpstreamSessionId: s.importedFromUpstreamSessionId
   }));
 }
 async function killSession(config, id, fetchImpl = fetch) {
@@ -3356,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;
@@ -3386,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) {
@@ -3434,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);
@@ -3667,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);
@@ -3805,6 +3923,90 @@ 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 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++;
+        }
+      }
+    }
+    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;
+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"
+    };
+  }
+});
+
 // src/tui/screen.ts
 import stringWidth from "string-width";
 import wrapAnsi from "wrap-ansi";
@@ -3813,7 +4015,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 = [];
@@ -4061,6 +4264,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];
@@ -4310,6 +4521,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":
@@ -4320,13 +4533,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;
@@ -4334,6 +4548,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;
@@ -4353,6 +4568,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;
@@ -4415,7 +4636,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: "?" };
@@ -4436,6 +4657,12 @@ var init_screen = __esm({
       pasteBuffer = "";
       rawStdinHandler;
       mouseEnabled;
+      progressIndicatorEnabled;
+      // Last OSC 9;4 state we wrote (3 = indeterminate, 0 = remove). Used to
+      // suppress redundant writes when setBanner runs but `status` didn't
+      // actually change, and to re-emit on start() if a picker round-trip
+      // cleared the host terminal's indicator.
+      lastProgressState = 0;
       constructor(opts) {
         this.term = opts.term;
         this.dispatcher = opts.dispatcher;
@@ -4443,6 +4670,7 @@ var init_screen = __esm({
         this.contentRepaintThrottleMs = opts.repaintThrottleMs ?? DEFAULT_CONTENT_REPAINT_THROTTLE_MS;
         this.maxScrollbackLines = opts.maxScrollbackLines ?? DEFAULT_MAX_SCROLLBACK_LINES;
         this.mouseEnabled = opts.mouse ?? true;
+        this.progressIndicatorEnabled = opts.progressIndicator ?? true;
         this.resizeHandler = () => this.repaint();
         this.keyHandler = (name, _matches, data) => this.handleKey(name, data);
         this.mouseHandler = (name) => this.handleMouse(name);
@@ -4471,6 +4699,8 @@ var init_screen = __esm({
         }
         this.term.on("resize", this.resizeHandler);
         this.installBracketedPaste();
+        this.lastProgressState = 0;
+        this.writeProgressIndicator(this.banner.status === "busy" ? 3 : 0);
         this.repaint();
       }
       stop() {
@@ -4491,6 +4721,7 @@ var init_screen = __esm({
         this.term.grabInput(false);
         this.term.hideCursor(false);
         process.stdout.write("\x1B[?7h");
+        this.writeProgressIndicator(0);
         this.term.fullscreen(false);
         this.term("\n");
       }
@@ -4536,7 +4767,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);
@@ -4779,9 +5015,26 @@ var init_screen = __esm({
       }
       setBanner(banner) {
         this.banner = { ...this.banner, ...banner };
+        this.writeProgressIndicator(this.banner.status === "busy" ? 3 : 0);
         this.drawBanner();
         this.placeCursor();
       }
+      // OSC 9;4 progress-bar control. State 3 = indeterminate (pulsing
+      // taskbar / dock badge while a turn is running); state 0 = remove.
+      // ConEmu-flavor sequence — supported by Windows Terminal, WezTerm,
+      // Ghostty, Konsole, Black Box, Rio, and others; ignored harmlessly
+      // by terminals that don't implement it. Disabled entirely when
+      // tui.progressIndicator is false.
+      writeProgressIndicator(state) {
+        if (!this.progressIndicatorEnabled) {
+          return;
+        }
+        if (state === this.lastProgressState) {
+          return;
+        }
+        this.lastProgressState = state;
+        process.stdout.write(`\x1B]9;4;${state}\x1B\\`);
+      }
       // Transient right-side banner message. Cleared automatically after
       // durationMs (default 4s). Each call resets the timer, so rapid
       // successive notifications coalesce on the latest text. Active
@@ -5270,7 +5523,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() {
@@ -5352,6 +5605,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);
@@ -5443,6 +5697,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;
@@ -5458,7 +5722,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)) {
@@ -5491,6 +5756,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) {
@@ -5499,7 +5816,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++) {
@@ -5648,6 +5966,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}`);
           }
@@ -5802,6 +6122,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;
@@ -5847,6 +6170,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]/;
@@ -5891,6 +6220,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;
@@ -5903,9 +6243,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;
       }
@@ -5936,13 +6289,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) {
@@ -5988,6 +6345,9 @@ var init_input = __esm({
           this.insertText(event.text);
           return [];
         }
+        if (event.type === "attachment-paths") {
+          return [];
+        }
         return this.handleKey(event.name);
       }
       handleKey(name) {
@@ -6064,6 +6424,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 [];
@@ -6096,7 +6458,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) {
@@ -6248,6 +6612,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] ?? "");
@@ -6320,6 +6686,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();
         }
@@ -6473,18 +6841,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.
@@ -6509,13 +6879,15 @@ var init_input = __esm({
         return [{ type: "scroll-to-bottom" }];
       }
       handleCtrlC() {
-        if (!this.bufferIsEmpty()) {
+        if (!this.bufferIsEmpty() || this.attachments.length > 0) {
           this.buffer = [""];
           this.row = 0;
           this.col = 0;
+          this.attachments = [];
           if (this.queueIndex === -1) {
             this.historyIndex = -1;
             this.savedDraft = null;
+            this.savedAttachments = null;
           }
           return [];
         }
@@ -6533,6 +6905,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) {
@@ -6867,8 +7465,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":
@@ -7198,6 +7817,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;
@@ -7315,6 +7936,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;
@@ -7418,6 +8048,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,
@@ -7428,6 +8059,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;
@@ -7511,6 +8146,7 @@ async function runSession(term, config, opts, exitHint) {
     repaintThrottleMs: config.tui.repaintThrottleMs,
     maxScrollbackLines: config.tui.maxScrollbackLines,
     mouse: config.tui.mouse,
+    progressIndicator: config.tui.progressIndicator,
     onKey: (events) => {
       for (const ev of events) {
         if (pendingPermission && tryHandlePermissionKey(ev)) {
@@ -7525,6 +8161,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);
@@ -7534,6 +8174,7 @@ async function runSession(term, config, opts, exitHint) {
       screen.setBannerSearchIndicator(
         dispatcher.state().historySearchQuery
       );
+      screen.setAttachments(dispatcher.state().attachments);
       screen.refreshPrompt();
     }
   });
@@ -7824,7 +8465,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();
@@ -7855,13 +8497,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;
@@ -7880,7 +8526,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) {
@@ -7919,17 +8568,81 @@ async function runSession(term, config, opts, exitHint) {
         screen.enterScrollbackSearch();
         screen.updateScrollbackSearchTerm(effect.query);
         return;
+      case "attachment-request":
+        void handleClipboardAttachment();
+        return;
+    }
+  };
+  const handleAttachmentPaths = async (paths2) => {
+    if (!agentAcceptsImages) {
+      screen.notify("agent does not accept image attachments");
+      return;
+    }
+    let added = 0;
+    for (const p of paths2) {
+      const mimeType = mimeFromExtension(p);
+      if (!mimeType) {
+        screen.notify(`unsupported image type: ${path11.basename(p)}`);
+        continue;
+      }
+      try {
+        const buf = await fs15.readFile(p);
+        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(p),
+          sizeBytes: buf.length
+        });
+        added++;
+      } catch (err) {
+        screen.notify(`cannot read ${path11.basename(p)}: ${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;
@@ -7937,7 +8650,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();
   };
@@ -8104,31 +8817,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;
@@ -8625,6 +9345,8 @@ var init_app = __esm({
     init_picker();
     init_screen();
     init_input();
+    init_attachments();
+    init_clipboard();
     init_completion();
     init_render_update();
     init_format();
@@ -9408,12 +10130,14 @@ var AgentInstance = class _AgentInstance {
   killed = false;
   stderrTail = "";
   stderrTailBytes;
+  logger;
   exitHandlers = [];
   constructor(opts, child) {
     this.agentId = opts.agentId;
     this.cwd = opts.cwd;
     this.child = child;
     this.stderrTailBytes = opts.stderrTailBytes ?? DEFAULT_STDERR_TAIL_BYTES;
+    this.logger = opts.logger;
     if (!child.stdout || !child.stdin) {
       throw new Error("agent subprocess missing stdio");
     }
@@ -9422,7 +10146,15 @@ var AgentInstance = class _AgentInstance {
     child.stderr?.setEncoding("utf8");
     child.stderr?.on("data", (chunk) => {
       this.stderrTail = (this.stderrTail + chunk).slice(-this.stderrTailBytes);
-      process.stderr.write(`[${opts.agentId}] ${chunk}`);
+      if (this.logger) {
+        for (const line of chunk.split(/\r?\n/)) {
+          if (line.length > 0) {
+            this.logger.info(`[${opts.agentId}] ${line}`);
+          }
+        }
+      } else {
+        process.stderr.write(`[${opts.agentId}] ${chunk}`);
+      }
     });
     child.on("error", (err) => {
       const msg = this.formatFailure(err.message);
@@ -9430,9 +10162,16 @@ var AgentInstance = class _AgentInstance {
     });
     child.on("exit", (code, signal) => {
       this.exited = true;
-      if (!this.killed) {
+      if (this.killed) {
+        this.logger?.info(
+          `agent ${opts.agentId} pid=${child.pid} exited after kill code=${code} signal=${signal}`
+        );
+      } else {
         const reason = `agent ${opts.agentId} exited before responding (code=${code} signal=${signal})`;
         this.connection.fail(new Error(this.formatFailure(reason)));
+        this.logger?.warn(
+          `agent ${opts.agentId} pid=${child.pid} exited unexpectedly code=${code} signal=${signal}`
+        );
       }
       for (const handler of this.exitHandlers) {
         handler(code, signal);
@@ -9453,7 +10192,15 @@ stderr: ${tail}` : reason;
     const child = spawn3(opts.plan.command, opts.plan.args, {
       cwd: opts.cwd,
       env,
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      // setsid the agent into its own session/process group. The daemon
+      // already runs in its own setsid'd session, but macOS terminals
+      // (iTerm2, Terminal.app) sometimes still reach inherited child
+      // processes when the user closes a window — putting the agent
+      // one more session-boundary away keeps it alive across terminal
+      // restarts. The daemon still owns the pipes, so this.kill()
+      // continues to terminate it cleanly on idle/close.
+      detached: true
     });
     return new _AgentInstance(opts, child);
   }
@@ -9468,6 +10215,9 @@ stderr: ${tail}` : reason;
       return;
     }
     this.killed = true;
+    this.logger?.info(
+      `agent ${this.agentId} pid=${this.child.pid} kill requested signal=${signal}`
+    );
     await this.connection.close().catch(() => void 0);
     this.child.kill(signal);
   }
@@ -9653,6 +10403,7 @@ var SessionManager = class {
     this.histories = new HistoryStore({ maxEntries: this.sessionHistoryMaxEntries });
     this.idleTimeoutMs = options.idleTimeoutMs ?? 0;
     this.defaultModels = options.defaultModels ?? {};
+    this.logger = options.logger;
   }
   registry;
   sessions = /* @__PURE__ */ new Map();
@@ -9667,6 +10418,7 @@ var SessionManager = class {
   // concurrent snapshot updates (e.g. an agent emitting model + mode
   // back-to-back) don't lose writes via interleaved reads.
   metaWriteQueues = /* @__PURE__ */ new Map();
+  logger;
   async create(params) {
     const fresh = await this.bootstrapAgent({
       agentId: params.agentId,
@@ -9684,6 +10436,7 @@ var SessionManager = class {
       title: params.title,
       agentArgs: params.agentArgs,
       idleTimeoutMs: this.idleTimeoutMs,
+      logger: this.logger,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
@@ -9777,6 +10530,7 @@ var SessionManager = class {
       title: params.title,
       agentArgs: params.agentArgs,
       idleTimeoutMs: this.idleTimeoutMs,
+      logger: this.logger,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
@@ -9823,6 +10577,7 @@ var SessionManager = class {
       title: params.title,
       agentArgs: params.agentArgs,
       idleTimeoutMs: this.idleTimeoutMs,
+      logger: this.logger,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
@@ -10087,6 +10842,8 @@ var SessionManager = class {
         agentId: r.agentId,
         currentModel: r.currentModel,
         currentUsage: r.currentUsage,
+        importedFromMachine: r.importedFromMachine,
+        importedFromUpstreamSessionId: r.importedFromUpstreamSessionId,
         updatedAt: used,
         attachedClients: 0,
         status: "cold"
@@ -10194,6 +10951,8 @@ var SessionManager = class {
         lineageId: args.bundle.session.lineageId,
         upstreamSessionId: "",
         importedFromSessionId: args.bundle.session.sessionId,
+        importedFromUpstreamSessionId: args.bundle.session.upstreamSessionId,
+        importedFromMachine: args.bundle.exportedFrom.machine,
         agentId: args.bundle.session.agentId,
         cwd: args.cwd ?? args.bundle.session.cwd,
         title: args.bundle.session.title,
@@ -10316,6 +11075,8 @@ function mergeForPersistence(session, existing) {
     lineageId: existing?.lineageId ?? generateLineageId(),
     upstreamSessionId: session.upstreamSessionId,
     importedFromSessionId: existing?.importedFromSessionId,
+    importedFromUpstreamSessionId: existing?.importedFromUpstreamSessionId,
+    importedFromMachine: existing?.importedFromMachine,
     agentId: session.agentId,
     cwd: session.cwd,
     title: session.title,
@@ -11595,11 +12356,20 @@ async function startDaemon(config) {
     await auth(request, reply);
   });
   const registry = new Registry(config);
-  const spawner = (opts) => AgentInstance.spawn({ ...opts, stderrTailBytes: config.daemon.agentStderrTailBytes });
+  const agentLogger = {
+    info: (msg) => app.log.info(msg),
+    warn: (msg) => app.log.warn(msg)
+  };
+  const spawner = (opts) => AgentInstance.spawn({
+    ...opts,
+    stderrTailBytes: config.daemon.agentStderrTailBytes,
+    logger: agentLogger
+  });
   const manager = new SessionManager(registry, spawner, void 0, {
     idleTimeoutMs: config.daemon.sessionIdleTimeoutSeconds * 1e3,
     defaultModels: config.defaultModels,
-    sessionHistoryMaxEntries: config.daemon.sessionHistoryMaxEntries
+    sessionHistoryMaxEntries: config.daemon.sessionHistoryMaxEntries,
+    logger: agentLogger
   });
   const extensions = new ExtensionManager(extensionList(config));
   registerHealthRoutes(app, HYDRA_VERSION);
@@ -11836,6 +12606,7 @@ async function runDaemonStart(flags = {}) {
     };
     process.on("SIGINT", () => void shutdown());
     process.on("SIGTERM", () => void shutdown());
+    process.on("SIGHUP", () => void 0);
     return;
   }
   spawnDaemonDetached();