@hydra-acp/cli 0.1.15 → 0.1.16

package/dist/cli.js

@@ -360,6 +360,12 @@ function extractHydraMeta(meta) {
   if (typeof obj.currentMode === "string") {
     out.currentMode = obj.currentMode;
   }
+  if (obj.currentUsage) {
+    const parsed = SessionListUsage.safeParse(obj.currentUsage);
+    if (parsed.success) {
+      out.currentUsage = parsed.data;
+    }
+  }
   if (typeof obj.turnStartedAt === "number" && obj.turnStartedAt > 0) {
     out.turnStartedAt = obj.turnStartedAt;
   }
@@ -1204,21 +1210,126 @@ var init_session = __esm({
         }
         this.clients.set(client.clientId, client);
         this.updatedAt = Date.now();
-        if (historyPolicy === "none" || historyPolicy === "pending_only") {
+        if (historyPolicy === "none") {
           return Promise.resolve({ entries: [], appliedPolicy: historyPolicy });
         }
+        if (historyPolicy === "pending_only") {
+          return Promise.resolve({
+            entries: this.buildStateSnapshotReplay(),
+            appliedPolicy: historyPolicy
+          });
+        }
         return this.loadReplay(historyPolicy, opts);
       }
       async loadReplay(historyPolicy, opts) {
         const all = await this.getHistorySnapshot();
+        const state = this.buildStateSnapshotReplay();
         if (historyPolicy === "after_message") {
           const cutoff = opts.afterMessageId ? findMessageIdIndex(all, opts.afterMessageId) : -1;
           if (cutoff < 0) {
-            return { entries: all, appliedPolicy: "full" };
+            return { entries: [...state, ...all], appliedPolicy: "full" };
+          }
+          return {
+            entries: [...state, ...all.slice(cutoff + 1)],
+            appliedPolicy: "after_message"
+          };
+        }
+        return { entries: [...state, ...all], appliedPolicy: "full" };
+      }
+      // Synthesizes one session/update notification per cached STATE_UPDATE_KIND
+      // so an attaching client receives the current snapshot through the
+      // standard ACP event channel. Without this, third-party clients would
+      // never see current_model/mode/usage/info/commands on resume — they're
+      // filtered out of recorded history (canonical state lives in meta.json
+      // and is *also* surfaced via the attach response _meta, but third-party
+      // clients can't read hydra's namespaced meta).
+      buildStateSnapshotReplay() {
+        const out = [];
+        const sessionId = this.sessionId;
+        const recordedAt = Date.now();
+        if (this.title !== void 0 && this.title.length > 0) {
+          out.push({
+            method: "session/update",
+            params: {
+              sessionId,
+              update: {
+                sessionUpdate: "session_info_update",
+                title: this.title
+              }
+            },
+            recordedAt
+          });
+        }
+        if (this.currentModel !== void 0 && this.currentModel.length > 0) {
+          out.push({
+            method: "session/update",
+            params: {
+              sessionId,
+              update: {
+                sessionUpdate: "current_model_update",
+                currentModel: this.currentModel
+              }
+            },
+            recordedAt
+          });
+        }
+        if (this.currentMode !== void 0 && this.currentMode.length > 0) {
+          out.push({
+            method: "session/update",
+            params: {
+              sessionId,
+              update: {
+                sessionUpdate: "current_mode_update",
+                currentMode: this.currentMode
+              }
+            },
+            recordedAt
+          });
+        }
+        const cmds = this.mergedAvailableCommands();
+        if (cmds.length > 0) {
+          out.push({
+            method: "session/update",
+            params: {
+              sessionId,
+              update: {
+                sessionUpdate: "available_commands_update",
+                availableCommands: cmds
+              }
+            },
+            recordedAt
+          });
+        }
+        if (this.currentUsage !== void 0) {
+          const u = this.currentUsage;
+          const update = {
+            sessionUpdate: "usage_update"
+          };
+          if (typeof u.used === "number") {
+            update.used = u.used;
+          }
+          if (typeof u.size === "number") {
+            update.size = u.size;
+          }
+          if (typeof u.costAmount === "number" || typeof u.costCurrency === "string") {
+            const cost = {};
+            if (typeof u.costAmount === "number") {
+              cost.amount = u.costAmount;
+            }
+            if (typeof u.costCurrency === "string") {
+              cost.currency = u.costCurrency;
+            }
+            update.cost = cost;
+          }
+          if (Object.keys(update).length > 1) {
+            out.push({
+              method: "session/update",
+              params: { sessionId, update },
+              recordedAt
+            });
           }
-          return { entries: all.slice(cutoff + 1), appliedPolicy: "after_message" };
         }
-        return { entries: all, appliedPolicy: "full" };
+        return out;
       }
       // Dispatch in-flight permission requests to a freshly-attached
       // client. Called by the daemon's WS handler *after* it finishes
@@ -2477,633 +2588,1252 @@ var init_bundle = __esm({
   }
 });
 
-// src/acp/ws-stream.ts
-function wsToMessageStream(ws) {
-  const messageHandlers = [];
-  const closeHandlers = [];
-  let closed = false;
-  const emitClose = (err) => {
-    if (closed) {
-      return;
-    }
-    closed = true;
-    for (const handler of closeHandlers) {
-      handler(err);
-    }
-  };
-  ws.on("message", (data, isBinary) => {
-    if (isBinary) {
-      return;
-    }
-    const text = data.toString("utf8");
-    try {
-      const parsed = JSON.parse(text);
-      for (const handler of messageHandlers) {
-        handler(parsed);
-      }
-    } catch (err) {
-      for (const handler of messageHandlers) {
-        handler({
-          jsonrpc: "2.0",
-          id: 0,
-          error: {
-            code: JsonRpcErrorCodes.ParseError,
-            message: `Failed to parse WS frame: ${err.message}`
-          }
-        });
-      }
-    }
-  });
-  ws.on("close", () => emitClose());
-  ws.on("error", (err) => emitClose(err));
-  return {
-    async send(message) {
-      if (closed) {
-        throw new Error("ws is closed");
-      }
-      const text = JSON.stringify(message);
-      await new Promise((resolve5, reject) => {
-        ws.send(text, (err) => {
-          if (err) {
-            reject(err);
-            return;
-          }
-          resolve5();
-        });
-      });
-    },
-    onMessage(handler) {
-      messageHandlers.push(handler);
-    },
-    onClose(handler) {
-      closeHandlers.push(handler);
-    },
-    async close() {
-      if (closed) {
-        return;
-      }
-      ws.close();
-      emitClose();
-    }
-  };
+// src/core/render-update.ts
+import stripAnsi from "strip-ansi";
+function sanitizeWireText(text) {
+  return stripAnsi(text).replace(STRIP_CONTROLS, "");
 }
-var init_ws_stream = __esm({
-  "src/acp/ws-stream.ts"() {
-    "use strict";
-    init_types();
-  }
-});
-
-// src/core/daemon-bootstrap.ts
-import { spawn as spawn5 } from "child_process";
-import { setTimeout as sleep } from "timers/promises";
-async function ensureDaemonReachable(config) {
-  if (await pingHealth(config)) {
-    return;
-  }
-  process.stderr.write("hydra-acp: daemon not running; starting it...\n");
-  spawnDaemonDetached();
-  await waitForDaemonReady(config);
+function sanitizeSingleLine(text) {
+  return sanitizeWireText(text).replace(/[\n\t]+/g, " ").replace(/  +/g, " ").trim();
 }
-async function pingHealth(config) {
-  const protocol = config.daemon.tls ? "https" : "http";
-  const url = `${protocol}://${config.daemon.host}:${config.daemon.port}/v1/health`;
-  try {
-    const response = await fetch(url, {
-      signal: AbortSignal.timeout(500)
-    });
-    return response.ok;
-  } catch {
-    return false;
+function mapUpdate(update) {
+  if (!update || typeof update !== "object") {
+    return null;
   }
-}
-function spawnDaemonDetached() {
-  const cliPath = process.argv[1];
-  if (!cliPath) {
-    throw new Error("Cannot determine hydra-acp binary path to spawn daemon");
+  const u = update;
+  const tag = u.sessionUpdate ?? u.kind;
+  if (typeof tag !== "string") {
+    return null;
   }
-  const child = spawn5(
-    process.execPath,
-    [cliPath, "daemon", "start", "--foreground"],
-    {
-      detached: true,
-      stdio: "ignore",
-      env: process.env
-    }
-  );
-  child.unref();
-}
-async function waitForDaemonReady(config, timeoutMs = 15e3) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (await pingHealth(config)) {
-      return;
-    }
-    await sleep(150);
+  switch (tag) {
+    case "agent_message_chunk":
+      return mapAgentText(u);
+    case "agent_thought_chunk":
+    case "agent_thought":
+      return mapAgentThought(u);
+    case "user_message_chunk":
+      return mapUserText(u);
+    case "prompt_received":
+      return mapPromptReceived(u);
+    case "tool_call":
+      return mapToolCall(u);
+    case "tool_call_update":
+      return mapToolCallUpdate(u);
+    case "plan":
+      return mapPlan(u);
+    case "current_mode_update":
+      return mapMode(u);
+    case "current_model_update":
+      return mapModel(u);
+    case "turn_complete":
+      return mapTurnComplete(u);
+    case "usage_update":
+      return mapUsage(u);
+    case "available_commands_update":
+      return mapAvailableCommands(u);
+    case "session_info_update":
+      return mapSessionInfo(u);
+    default:
+      return { kind: "unknown", sessionUpdate: tag, raw: update };
   }
-  throw new Error(
-    `hydra-acp daemon did not become ready within ${timeoutMs}ms`
-  );
 }
-var init_daemon_bootstrap = __esm({
-  "src/core/daemon-bootstrap.ts"() {
-    "use strict";
+function mapSessionInfo(u) {
+  const rawTitle = readString(u, "title");
+  const title = rawTitle !== void 0 ? sanitizeSingleLine(rawTitle) : void 0;
+  const meta = u._meta;
+  let agentId;
+  if (meta && typeof meta === "object" && !Array.isArray(meta)) {
+    const ns = meta["hydra-acp"];
+    if (ns && typeof ns === "object" && !Array.isArray(ns)) {
+      const candidate = ns.agentId;
+      if (typeof candidate === "string") {
+        agentId = candidate;
+      }
+    }
   }
-});
-
-// src/core/agent-display.ts
-function shortenModel(model) {
-  if (!model) {
-    return void 0;
+  if (title === void 0 && agentId === void 0) {
+    return null;
   }
-  const idx = model.lastIndexOf("/");
-  if (idx === -1) {
-    return model;
+  const event = { kind: "session-info" };
+  if (title !== void 0) {
+    event.title = title;
   }
-  return model.slice(idx + 1);
-}
-function formatAgentWithModel(agentId, model) {
-  const agent = agentId ?? "?";
-  const short = shortenModel(model);
-  if (!short) {
-    return agent;
+  if (agentId !== void 0) {
+    event.agentId = agentId;
   }
-  return `${agent}${AGENT_MODEL_SEP}${short}`;
+  return event;
 }
-function formatAgentCell(agentId, usage) {
-  const base = agentId ?? "?";
-  if (!usage || typeof usage.costAmount !== "number") {
-    return base;
-  }
-  const compact = formatCostCompact(usage.costAmount, usage.costCurrency);
-  if (compact === null) {
-    return base;
+function normalizeAdvertisedCommands(list) {
+  if (!Array.isArray(list)) {
+    return [];
   }
-  return `${base} ${compact}`;
-}
-function formatCost(amount, currency) {
-  const sign = currency === "USD" || currency === void 0 ? "$" : "";
-  const decimals = amount >= 1 ? 2 : 4;
-  return `${sign}${amount.toFixed(decimals)}${currency && currency !== "USD" ? ` ${currency}` : ""}`;
+  const out = [];
+  for (const raw of list) {
+    if (!raw || typeof raw !== "object") {
+      continue;
+    }
+    const c = raw;
+    if (typeof c.name !== "string" || c.name.length === 0) {
+      continue;
+    }
+    const rawName = c.name.startsWith("/") ? c.name : `/${c.name}`;
+    const cmd = { name: sanitizeSingleLine(rawName) };
+    if (typeof c.description === "string") {
+      cmd.description = sanitizeSingleLine(c.description);
+    }
+    out.push(cmd);
+  }
+  return out;
 }
-function formatCostCompact(amount, currency) {
-  const whole = Math.round(amount);
-  if (whole === 0) {
+function mapAvailableCommands(u) {
+  const list = u.availableCommands ?? u.commands;
+  if (!Array.isArray(list)) {
     return null;
   }
-  const sign = currency === "USD" || currency === void 0 ? "$" : "";
-  return `${sign}${whole}${currency && currency !== "USD" ? ` ${currency}` : ""}`;
+  return { kind: "available-commands", commands: normalizeAdvertisedCommands(list) };
 }
-var AGENT_MODEL_SEP;
-var init_agent_display = __esm({
-  "src/core/agent-display.ts"() {
-    "use strict";
-    AGENT_MODEL_SEP = "\u2022";
+function mapUsage(u) {
+  const event = { kind: "usage-update" };
+  if (typeof u.used === "number") {
+    event.used = u.used;
   }
-});
-
-// src/cli/session-row.ts
-function toRow(s, now = Date.now()) {
-  return {
-    session: stripHydraSessionPrefix(s.sessionId),
-    upstream: formatUpstreamCell(s.upstreamSessionId, s.importedFromMachine),
-    state: formatState(s.status, s.attachedClients),
-    agent: formatAgentCell(s.agentId, s.currentUsage),
-    age: formatRelativeAge(s.updatedAt, now),
-    title: s.title ?? "-",
-    cwd: shortenHomePath(s.cwd)
-  };
-}
-function formatUpstreamCell(upstreamSessionId, importedFromMachine) {
-  if (upstreamSessionId && upstreamSessionId.length > 0) {
-    return upstreamSessionId;
+  if (typeof u.size === "number") {
+    event.size = u.size;
   }
-  if (importedFromMachine && importedFromMachine.length > 0) {
-    return `\u2190 ${importedFromMachine}`;
+  if (u.cost && typeof u.cost === "object") {
+    const cost = u.cost;
+    if (typeof cost.amount === "number") {
+      event.costAmount = cost.amount;
+    }
+    if (typeof cost.currency === "string") {
+      event.costCurrency = cost.currency;
+    }
   }
-  return "-";
+  return event;
 }
-function formatState(status, clients) {
-  if (status === "cold") {
-    return "COLD";
+function mapAgentText(u) {
+  const text = extractContentText(u.content);
+  if (text === null) {
+    return null;
   }
-  return `LIVE(${clients})`;
+  return { kind: "agent-text", text };
 }
-function computeWidths(rows) {
-  return {
-    session: maxLen(HEADER.session, rows.map((r) => r.session)),
-    upstream: maxLen(HEADER.upstream, rows.map((r) => r.upstream)),
-    state: maxLen(HEADER.state, rows.map((r) => r.state)),
-    agent: maxLen(HEADER.agent, rows.map((r) => r.agent)),
-    age: maxLen(HEADER.age, rows.map((r) => r.age)),
-    cwd: maxLen(HEADER.cwd, rows.map((r) => r.cwd)),
-    title: maxLen(HEADER.title, rows.map((r) => r.title))
-  };
+function mapAgentThought(u) {
+  const text = typeof u.text === "string" ? sanitizeWireText(u.text) : extractContentText(u.content);
+  if (text === null) {
+    return null;
+  }
+  return { kind: "agent-thought", text };
 }
-function formatRelativeAge(iso, now) {
-  if (!iso) {
-    return "?";
+function mapUserText(u) {
+  const meta = u._meta;
+  if (meta && typeof meta === "object" && !Array.isArray(meta)) {
+    const hydra = meta["hydra-acp"];
+    if (hydra && typeof hydra === "object" && !Array.isArray(hydra) && hydra.compatFor === "prompt_received") {
+      return null;
+    }
   }
-  const t = Date.parse(iso);
-  if (Number.isNaN(t)) {
-    return "?";
+  const text = extractContentText(u.content);
+  if (text === null) {
+    return null;
   }
-  const diff = Math.max(0, now - t);
-  const sec = Math.floor(diff / 1e3);
-  if (sec < 60) {
-    return "<1m";
+  return { kind: "user-text", text };
+}
+function mapPromptReceived(u) {
+  const promptText = extractPromptText2(u.prompt);
+  if (promptText === null) {
+    return null;
   }
-  const min = Math.floor(sec / 60);
-  if (min < 60) {
-    return `${min}m`;
+  return { kind: "user-text", text: promptText };
+}
+function mapToolCall(u) {
+  const toolCallId = readString(u, "toolCallId") ?? readString(u, "id");
+  if (!toolCallId) {
+    return null;
   }
-  const hr = Math.floor(min / 60);
-  if (hr < 24) {
-    return `${hr}h`;
+  const rawTitle = readString(u, "title") ?? readString(u, "name") ?? readString(u, "label") ?? "tool call";
+  const title = sanitizeSingleLine(rawTitle);
+  const status = readString(u, "status");
+  const rawKind = readString(u, "kind");
+  const event = { kind: "tool-call", toolCallId, title };
+  if (status !== void 0) {
+    event.status = status;
   }
-  const day = Math.floor(hr / 24);
-  if (day < 14) {
-    return `${day}d`;
+  if (rawKind !== void 0) {
+    event.rawKind = rawKind;
   }
-  const week = Math.floor(day / 7);
-  if (week < 9) {
-    return `${week}w`;
+  return event;
+}
+function mapToolCallUpdate(u) {
+  const toolCallId = readString(u, "toolCallId") ?? readString(u, "id");
+  if (!toolCallId) {
+    return null;
   }
-  const month = Math.floor(day / 30);
-  if (month < 12) {
-    return `${month}mo`;
+  const rawTitle = readString(u, "title");
+  const title = rawTitle !== void 0 ? sanitizeSingleLine(rawTitle) : void 0;
+  const status = readString(u, "status");
+  const meaningful = title !== void 0 || status === "completed" || status === "failed" || status === "rejected" || status === "cancelled";
+  if (!meaningful) {
+    return null;
   }
-  const year = Math.floor(day / 365);
-  return `${year}y`;
+  const event = { kind: "tool-call-update", toolCallId };
+  if (title !== void 0) {
+    event.title = title;
+  }
+  if (status !== void 0) {
+    event.status = status;
+  }
+  return event;
 }
-function maxLen(headerCell, values) {
-  let max = headerCell.length;
-  for (const v of values) {
-    if (v.length > max) {
-      max = v.length;
+function mapPlan(u) {
+  const entries = u.entries;
+  if (!Array.isArray(entries)) {
+    return null;
+  }
+  const normalized = [];
+  for (const raw of entries) {
+    if (!raw || typeof raw !== "object") {
+      continue;
+    }
+    const e = raw;
+    const content = typeof e.content === "string" ? sanitizeSingleLine(e.content) : void 0;
+    if (!content) {
+      continue;
+    }
+    const entry = { content };
+    if (typeof e.status === "string") {
+      entry.status = e.status;
+    }
+    if (typeof e.priority === "string") {
+      entry.priority = e.priority;
     }
+    normalized.push(entry);
   }
-  return max;
+  return { kind: "plan", entries: normalized };
 }
-function formatRow(r, w, maxWidth, cwdMaxWidth = DEFAULT_CWD_MAX_WIDTH) {
-  const fixed = [
-    r.session.padEnd(w.session),
-    r.upstream.padEnd(w.upstream),
-    r.state.padEnd(w.state),
-    r.agent.padEnd(w.agent),
-    r.age.padStart(w.age)
-  ].join(SEP);
-  if (maxWidth === void 0) {
-    return [fixed, r.cwd.padEnd(w.cwd), r.title].join(SEP);
+function mapMode(u) {
+  const mode = readString(u, "currentMode") ?? readString(u, "mode");
+  if (!mode) {
+    return null;
   }
-  const budget = maxWidth - fixed.length - SEP.length;
-  if (budget <= 0) {
-    return fixed.slice(0, maxWidth);
+  return { kind: "mode-changed", mode: sanitizeSingleLine(mode) };
+}
+function mapModel(u) {
+  const model = readString(u, "currentModel") ?? readString(u, "model");
+  if (!model) {
+    return null;
   }
-  const cwdCap = Math.min(w.cwd, cwdMaxWidth);
-  const cwdAlloc = Math.min(cwdCap, Math.max(0, budget - SEP.length - 1));
-  const cwdCell = truncateMiddle(r.cwd, cwdAlloc).padEnd(cwdAlloc);
-  const titleBudget = Math.max(0, budget - cwdAlloc - SEP.length);
-  const titleCell = truncateRight(r.title, titleBudget);
-  return [fixed, cwdCell, titleCell].join(SEP);
+  return { kind: "model-changed", model: sanitizeSingleLine(model) };
 }
-function truncateRight(s, max) {
-  if (max <= 0) {
-    return "";
+function mapTurnComplete(u) {
+  const stopReason = readString(u, "stopReason");
+  return stopReason !== void 0 ? { kind: "turn-complete", stopReason } : { kind: "turn-complete" };
+}
+function extractContentText(content) {
+  if (typeof content === "string") {
+    return sanitizeWireText(content);
   }
-  if (s.length <= max) {
-    return s;
+  if (!content || typeof content !== "object") {
+    return null;
   }
-  if (max === 1) {
-    return "\u2026";
+  const c = content;
+  if (c.type === "text" && typeof c.text === "string") {
+    return sanitizeWireText(c.text);
   }
-  return s.slice(0, max - 1) + "\u2026";
-}
-function truncateMiddle(s, max) {
-  if (max <= 0) {
-    return "";
+  if (typeof c.text === "string") {
+    return sanitizeWireText(c.text);
   }
-  if (s.length <= max) {
-    return s;
+  return null;
+}
+function extractPromptText2(prompt) {
+  if (!Array.isArray(prompt)) {
+    return null;
   }
-  if (max === 1) {
-    return "\u2026";
+  const parts = [];
+  for (const block of prompt) {
+    const text = extractContentText(block);
+    if (text !== null) {
+      parts.push(text);
+    }
   }
-  const head = Math.ceil((max - 1) / 2);
-  const tail = max - 1 - head;
-  return s.slice(0, head) + "\u2026" + s.slice(s.length - tail);
+  if (parts.length === 0) {
+    return null;
+  }
+  return parts.join("");
 }
-var HEADER, SEP, DEFAULT_CWD_MAX_WIDTH;
-var init_session_row = __esm({
-  "src/cli/session-row.ts"() {
+function readString(u, key) {
+  const v = u[key];
+  return typeof v === "string" ? v : void 0;
+}
+var STRIP_CONTROLS;
+var init_render_update = __esm({
+  "src/core/render-update.ts"() {
     "use strict";
-    init_agent_display();
-    init_paths();
-    init_session();
-    HEADER = {
-      session: "SESSION",
-      upstream: "UPSTREAM",
-      state: "STATE",
-      agent: "AGENT",
-      age: "AGE",
-      title: "TITLE",
-      cwd: "CWD"
-    };
-    SEP = "  ";
-    DEFAULT_CWD_MAX_WIDTH = 24;
+    STRIP_CONTROLS = /[\x00-\x08\x0b-\x1f\x7f]/g;
   }
 });
 
-// src/cli/commands/sessions.ts
-import * as fs13 from "fs/promises";
-import * as path8 from "path";
-async function runSessionsList(opts = {}) {
-  const config = await loadConfig();
-  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
-  const url = new URL(`${baseUrl}/v1/sessions`);
-  const response = await fetch(url.toString(), {
-    headers: { Authorization: `Bearer ${config.daemon.authToken}` }
-  });
-  if (!response.ok) {
-    process.stderr.write(`Daemon returned HTTP ${response.status}
-`);
-    process.exit(1);
-  }
-  const body = await response.json();
-  if (body.sessions.length === 0) {
-    process.stdout.write("No active sessions.\n");
-    return;
-  }
-  const sorted = body.sessions.slice().sort((a, b) => {
-    const liveDiff = (b.status === "live" ? 1 : 0) - (a.status === "live" ? 1 : 0);
-    if (liveDiff !== 0) {
-      return liveDiff;
-    }
-    return String(b.updatedAt || "").localeCompare(String(a.updatedAt || ""));
-  });
-  let visible = sorted;
-  let truncated = 0;
-  if (!opts.all) {
-    const liveCount = sorted.filter((s) => s.status !== "cold").length;
-    const limit = config.sessionListColdLimit;
-    const coldSlice = sorted.slice(liveCount, liveCount + limit);
-    const hiddenCold = sorted.length - liveCount - coldSlice.length;
-    visible = [...sorted.slice(0, liveCount), ...coldSlice];
-    truncated = hiddenCold;
-  }
-  const now = Date.now();
-  const rows = visible.map((s) => toRow(s, now));
-  const widths = computeWidths(rows);
-  const maxWidth = process.stdout.isTTY ? process.stdout.columns : void 0;
-  const cwdMax = config.tui.cwdColumnMaxWidth;
-  process.stdout.write(formatRow(HEADER, widths, maxWidth, cwdMax) + "\n");
-  for (const r of rows) {
-    process.stdout.write(formatRow(r, widths, maxWidth, cwdMax) + "\n");
-  }
-  if (truncated > 0) {
-    process.stdout.write(
-      `
-... ${truncated} more cold session${truncated === 1 ? "" : "s"} hidden. Use --all to show.
-`
-    );
+// src/core/transcript.ts
+function bundleToMarkdown(bundle) {
+  const events = collectEvents(bundle);
+  const toolFinalStates = collectToolFinalStates(events);
+  const out = [];
+  emitHeader(out, bundle);
+  emitBody(out, events, toolFinalStates);
+  let text = out.join("\n");
+  if (!text.endsWith("\n")) {
+    text += "\n";
   }
+  return text;
 }
-async function runSessionsKill(id) {
-  if (!id) {
-    process.stderr.write("Usage: hydra-acp sessions kill <session-id>\n");
-    process.exit(2);
-  }
-  const config = await loadConfig();
-  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
-  const response = await fetch(`${baseUrl}/v1/sessions/${id}/kill`, {
-    method: "POST",
-    headers: { Authorization: `Bearer ${config.daemon.authToken}` }
-  });
-  if (!response.ok && response.status !== 204) {
-    process.stderr.write(`Daemon returned HTTP ${response.status}
-`);
-    process.exit(1);
+function collectEvents(bundle) {
+  const out = [];
+  for (const entry of bundle.history) {
+    if (entry.method !== "session/update") {
+      continue;
+    }
+    const params = entry.params;
+    if (!params || typeof params !== "object") {
+      continue;
+    }
+    const event = mapUpdate(params.update);
+    if (event === null) {
+      continue;
+    }
+    out.push({ event, recordedAt: entry.recordedAt });
   }
-  process.stdout.write(`Killed ${id}
-`);
+  return out;
 }
-async function runSessionsRemove(id) {
-  if (!id) {
-    process.stderr.write("Usage: hydra-acp sessions remove <session-id>\n");
-    process.exit(2);
-  }
-  const config = await loadConfig();
-  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
-  const response = await fetch(`${baseUrl}/v1/sessions/${id}`, {
-    method: "DELETE",
-    headers: { Authorization: `Bearer ${config.daemon.authToken}` }
-  });
-  if (!response.ok && response.status !== 204) {
-    process.stderr.write(`Daemon returned HTTP ${response.status}
-`);
-    process.exit(1);
+function collectToolFinalStates(events) {
+  const out = /* @__PURE__ */ new Map();
+  for (const { event } of events) {
+    if (event.kind === "tool-call") {
+      const existing = out.get(event.toolCallId);
+      out.set(event.toolCallId, {
+        title: event.title,
+        status: event.status ?? existing?.status ?? "pending"
+      });
+      continue;
+    }
+    if (event.kind === "tool-call-update") {
+      const existing = out.get(event.toolCallId) ?? {
+        title: "tool call",
+        status: "pending"
+      };
+      out.set(event.toolCallId, {
+        title: event.title ?? existing.title,
+        status: event.status ?? existing.status
+      });
+    }
   }
-  process.stdout.write(`Removed ${id}
-`);
+  return out;
 }
-async function runSessionsExport(id, outPath) {
-  if (!id) {
-    process.stderr.write(
-      "Usage: hydra-acp sessions export <session-id> [--out <file>]\n"
-    );
-    process.exit(2);
-  }
-  const config = await loadConfig();
-  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
-  const response = await fetch(
-    `${baseUrl}/v1/sessions/${encodeURIComponent(id)}/export`,
-    {
-      headers: { Authorization: `Bearer ${config.daemon.authToken}` }
-    }
+function emitHeader(out, bundle) {
+  const session = bundle.session;
+  const shortId2 = stripHydraSessionPrefix(session.sessionId);
+  const title = session.title?.trim() || `Hydra session ${shortId2}`;
+  out.push(`# ${escapeInline(title)}`);
+  out.push("");
+  const lines = [];
+  lines.push(`- **Session:** \`${shortId2}\` (lineage \`${session.lineageId}\`)`);
+  const agentBits = [session.agentId];
+  if (session.currentModel) {
+    agentBits.push(`model: ${session.currentModel}`);
+  }
+  if (session.currentMode) {
+    agentBits.push(`mode: ${session.currentMode}`);
+  }
+  lines.push(`- **Agent:** ${agentBits.filter(Boolean).join(" \xB7 ")}`);
+  lines.push(`- **Cwd:** ${session.cwd}`);
+  lines.push(
+    `- **Exported:** ${bundle.exportedAt} from ${bundle.exportedFrom.machine} (hydra ${bundle.exportedFrom.hydraVersion})`
   );
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    process.stderr.write(`Daemon returned HTTP ${response.status}: ${text}
-`);
-    process.exit(1);
-  }
-  const body = await response.text();
-  if (!outPath) {
-    process.stdout.write(body);
-    if (!body.endsWith("\n")) {
-      process.stdout.write("\n");
+  const usage = session.currentUsage;
+  if (usage && (usage.used !== void 0 || usage.costAmount !== void 0)) {
+    const usageBits = [];
+    if (usage.used !== void 0) {
+      const denom = usage.size !== void 0 ? `${formatNumber(usage.size)}` : void 0;
+      usageBits.push(
+        denom ? `${formatNumber(usage.used)} / ${denom} tokens` : `${formatNumber(usage.used)} tokens`
+      );
     }
-    return;
+    if (usage.costAmount !== void 0) {
+      const currency = usage.costCurrency ?? "USD";
+      usageBits.push(`$${usage.costAmount.toFixed(2)} ${currency}`);
+    }
+    lines.push(`- **Usage:** ${usageBits.join(" \xB7 ")}`);
   }
-  const resolved = outPath === "." ? deriveFilenameFrom(response, id) : outPath;
-  await fs13.mkdir(path8.dirname(path8.resolve(resolved)), { recursive: true });
-  await fs13.writeFile(resolved, body, { encoding: "utf8", mode: 384 });
-  process.stdout.write(`Wrote ${resolved}
-`);
+  out.push(lines.join("\n"));
+  out.push("");
 }
-async function runSessionsImport(file, opts = {}) {
-  if (!file) {
-    process.stderr.write(
-      "Usage: hydra-acp sessions import <file>|- [--replace] [--cwd <path>] [--info]\n"
-    );
-    process.exit(2);
+function emitBody(out, events, toolFinalStates) {
+  if (!events.some((e) => isVisible(e.event))) {
+    out.push("_No conversation history recorded._");
+    out.push("");
+    return;
   }
-  let cwdOverride;
-  if (opts.cwd !== void 0) {
-    const resolved = path8.resolve(opts.cwd);
-    try {
-      const stat4 = await fs13.stat(resolved);
-      if (!stat4.isDirectory()) {
-        process.stderr.write(`--cwd ${resolved} is not a directory
-`);
-        process.exit(1);
+  const seenToolIds = /* @__PURE__ */ new Set();
+  let turn = 0;
+  let agentBuffer = "";
+  let inTurn = false;
+  const flushAgent = () => {
+    if (agentBuffer.length === 0) {
+      return;
+    }
+    out.push(agentBuffer.trimEnd());
+    out.push("");
+    agentBuffer = "";
+  };
+  const startTurnIfNeeded = () => {
+    if (inTurn) {
+      return;
+    }
+    turn += 1;
+    out.push("---");
+    out.push("");
+    out.push(`## Turn ${turn}`);
+    out.push("");
+    inTurn = true;
+  };
+  for (const { event } of events) {
+    switch (event.kind) {
+      case "user-text": {
+        flushAgent();
+        turn += 1;
+        out.push("---");
+        out.push("");
+        out.push(`## Turn ${turn}`);
+        out.push("");
+        out.push("**User:**");
+        out.push("");
+        for (const line of event.text.split("\n")) {
+          out.push(`> ${escapeInline(line)}`);
+        }
+        out.push("");
+        out.push("**Assistant:**");
+        out.push("");
+        inTurn = true;
+        break;
       }
-    } catch {
-      process.stderr.write(`--cwd ${resolved} does not exist
-`);
-      process.exit(1);
+      case "agent-text":
+        startTurnIfNeeded();
+        agentBuffer += event.text;
+        break;
+      case "agent-thought": {
+        startTurnIfNeeded();
+        flushAgent();
+        const lines = event.text.split("\n");
+        for (const line of lines) {
+          out.push(`> _${escapeInline(line)}_`);
+        }
+        out.push("");
+        break;
+      }
+      case "tool-call": {
+        startTurnIfNeeded();
+        flushAgent();
+        if (seenToolIds.has(event.toolCallId)) {
+          break;
+        }
+        seenToolIds.add(event.toolCallId);
+        const final = toolFinalStates.get(event.toolCallId) ?? {
+          title: event.title,
+          status: event.status ?? "pending"
+        };
+        out.push(`- ${statusGlyph(final.status)} ${formatToolLine(final)}`);
+        out.push("");
+        break;
+      }
+      case "tool-call-update":
+        break;
+      case "plan": {
+        startTurnIfNeeded();
+        flushAgent();
+        out.push("**Plan:**");
+        out.push("");
+        for (const entry of event.entries) {
+          const checked = entry.status === "completed" ? "[x]" : "[ ]";
+          out.push(`- ${checked} ${escapeInline(entry.content)}`);
+        }
+        out.push("");
+        break;
+      }
+      case "mode-changed":
+        startTurnIfNeeded();
+        flushAgent();
+        out.push(`_mode: ${escapeInline(event.mode)}_`);
+        out.push("");
+        break;
+      case "model-changed":
+        startTurnIfNeeded();
+        flushAgent();
+        out.push(`_model: ${escapeInline(event.model)}_`);
+        out.push("");
+        break;
+      case "turn-complete":
+        flushAgent();
+        break;
+      case "usage-update":
+      case "available-commands":
+      case "session-info":
+      case "unknown":
+        break;
     }
-    cwdOverride = resolved;
   }
-  let body;
-  if (file === "-") {
-    body = await readStdin();
-  } else {
-    body = await fs13.readFile(file, "utf8");
+  flushAgent();
+}
+function isVisible(event) {
+  switch (event.kind) {
+    case "usage-update":
+    case "available-commands":
+    case "session-info":
+    case "unknown":
+    case "turn-complete":
+      return false;
+    default:
+      return true;
   }
-  let bundle;
-  try {
-    bundle = JSON.parse(body);
-  } catch (err) {
-    process.stderr.write(`Failed to parse bundle: ${err.message}
-`);
-    process.exit(1);
+}
+function formatToolLine(state) {
+  const status = state.status;
+  const suffix = status === "completed" || status === void 0 ? "" : ` _(${status})_`;
+  return `${escapeInline(state.title)}${suffix}`;
+}
+function statusGlyph(status) {
+  switch (status) {
+    case "completed":
+      return "\u2713";
+    case "failed":
+      return "\u2717";
+    case "cancelled":
+    case "rejected":
+      return "\u2298";
+    case "in_progress":
+      return "\u21BB";
+    default:
+      return "\xB7";
   }
-  if (opts.info === true) {
-    const inspectConfig = await loadConfigReadOnly();
-    printBundleInfo(bundle, inspectConfig.tui.cwdColumnMaxWidth);
-    return;
+}
+function escapeInline(text) {
+  return text.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function formatNumber(n) {
+  return n.toLocaleString("en-US");
+}
+var init_transcript = __esm({
+  "src/core/transcript.ts"() {
+    "use strict";
+    init_render_update();
+    init_session();
   }
-  const config = await loadConfig();
-  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
-  const response = await fetch(`${baseUrl}/v1/sessions/import`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${config.daemon.authToken}`
-    },
-    body: JSON.stringify({
-      bundle,
-      replace: opts.replace === true,
-      ...cwdOverride !== void 0 ? { cwd: cwdOverride } : {}
-    })
+});
+
+// src/acp/ws-stream.ts
+function wsToMessageStream(ws) {
+  const messageHandlers = [];
+  const closeHandlers = [];
+  let closed = false;
+  const emitClose = (err) => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    for (const handler of closeHandlers) {
+      handler(err);
+    }
+  };
+  ws.on("message", (data, isBinary) => {
+    if (isBinary) {
+      return;
+    }
+    const text = data.toString("utf8");
+    try {
+      const parsed = JSON.parse(text);
+      for (const handler of messageHandlers) {
+        handler(parsed);
+      }
+    } catch (err) {
+      for (const handler of messageHandlers) {
+        handler({
+          jsonrpc: "2.0",
+          id: 0,
+          error: {
+            code: JsonRpcErrorCodes.ParseError,
+            message: `Failed to parse WS frame: ${err.message}`
+          }
+        });
+      }
+    }
   });
-  if (response.status === 409) {
-    const detail = await response.json().catch(() => ({}));
-    process.stderr.write(
-      `Bundle already imported as ${detail.existingSessionId ?? "unknown"}. Use --replace to overwrite.
-`
-    );
-    process.exit(1);
-  }
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    process.stderr.write(`Daemon returned HTTP ${response.status}: ${text}
-`);
-    process.exit(1);
-  }
-  const result = await response.json();
-  process.stdout.write(
-    result.replaced ? `Replaced ${result.sessionId} (from ${result.importedFromSessionId})
-` : `Imported as ${result.sessionId} (from ${result.importedFromSessionId})
-`
-  );
-}
-function bundleToSummary(parsed) {
+  ws.on("close", () => emitClose());
+  ws.on("error", (err) => emitClose(err));
   return {
-    sessionId: parsed.session.sessionId,
-    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"
+    async send(message) {
+      if (closed) {
+        throw new Error("ws is closed");
+      }
+      const text = JSON.stringify(message);
+      await new Promise((resolve5, reject) => {
+        ws.send(text, (err) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve5();
+        });
+      });
+    },
+    onMessage(handler) {
+      messageHandlers.push(handler);
+    },
+    onClose(handler) {
+      closeHandlers.push(handler);
+    },
+    async close() {
+      if (closed) {
+        return;
+      }
+      ws.close();
+      emitClose();
+    }
   };
 }
-function printBundleInfo(raw, cwdColumnMaxWidth) {
-  let parsed;
+var init_ws_stream = __esm({
+  "src/acp/ws-stream.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// src/core/daemon-bootstrap.ts
+import { spawn as spawn5 } from "child_process";
+import { setTimeout as sleep } from "timers/promises";
+async function ensureDaemonReachable(config) {
+  if (await pingHealth(config)) {
+    return;
+  }
+  process.stderr.write("hydra-acp: daemon not running; starting it...\n");
+  spawnDaemonDetached();
+  await waitForDaemonReady(config);
+}
+async function pingHealth(config) {
+  const protocol = config.daemon.tls ? "https" : "http";
+  const url = `${protocol}://${config.daemon.host}:${config.daemon.port}/v1/health`;
   try {
-    parsed = decodeBundle(raw);
-  } catch (err) {
-    process.stderr.write(`Not a valid bundle: ${err.message}
-`);
-    process.exit(1);
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(500)
+    });
+    return response.ok;
+  } catch {
+    return false;
   }
-  const summary = bundleToSummary(parsed);
-  const row = toRow(summary);
-  const widths = computeWidths([row]);
-  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")
-  );
 }
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+function spawnDaemonDetached() {
+  const cliPath = process.argv[1];
+  if (!cliPath) {
+    throw new Error("Cannot determine hydra-acp binary path to spawn daemon");
   }
-  return Buffer.concat(chunks).toString("utf8");
+  const child = spawn5(
+    process.execPath,
+    [cliPath, "daemon", "start", "--foreground"],
+    {
+      detached: true,
+      stdio: "ignore",
+      env: process.env
+    }
+  );
+  child.unref();
 }
-function deriveFilenameFrom(response, id) {
-  const cd = response.headers.get("content-disposition");
-  if (cd) {
-    const match = cd.match(/filename="([^"]+)"/);
-    if (match) {
-      return match[1];
+async function waitForDaemonReady(config, timeoutMs = 15e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await pingHealth(config)) {
+      return;
     }
+    await sleep(150);
   }
-  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return `hydra-${id}-${stamp}.hydra`;
-}
-function httpBase(host, port, tls) {
-  const protocol = tls ? "https" : "http";
-  return `${protocol}://${host}:${port}`;
+  throw new Error(
+    `hydra-acp daemon did not become ready within ${timeoutMs}ms`
+  );
 }
-var init_sessions = __esm({
-  "src/cli/commands/sessions.ts"() {
+var init_daemon_bootstrap = __esm({
+  "src/core/daemon-bootstrap.ts"() {
     "use strict";
-    init_config();
-    init_bundle();
-    init_session_row();
   }
 });
 
-// src/shim/resilient-ws.ts
-import { setTimeout as sleep3 } from "timers/promises";
-import { WebSocket } from "ws";
-function isResponse(msg) {
-  return !("method" in msg) && "id" in msg && msg.id !== void 0;
+// src/core/agent-display.ts
+function shortenModel(model) {
+  if (!model) {
+    return void 0;
+  }
+  const idx = model.lastIndexOf("/");
+  if (idx === -1) {
+    return model;
+  }
+  return model.slice(idx + 1);
 }
-async function openWs(url, subprotocols) {
-  return new Promise((resolve5, reject) => {
-    const ws = new WebSocket(url, subprotocols);
-    const onOpen = () => {
-      ws.off("error", onError);
-      resolve5(wsToMessageStream(ws));
-    };
-    const onError = (err) => {
-      ws.off("open", onOpen);
+function formatAgentWithModel(agentId, model) {
+  const agent = agentId ?? "?";
+  const short = shortenModel(model);
+  if (!short) {
+    return agent;
+  }
+  return `${agent}${AGENT_MODEL_SEP}${short}`;
+}
+function formatAgentCell(agentId, usage) {
+  const base = agentId ?? "?";
+  if (!usage || typeof usage.costAmount !== "number") {
+    return base;
+  }
+  const compact = formatCostCompact(usage.costAmount, usage.costCurrency);
+  if (compact === null) {
+    return base;
+  }
+  return `${base} ${compact}`;
+}
+function formatCost(amount, currency) {
+  const sign = currency === "USD" || currency === void 0 ? "$" : "";
+  const decimals = amount >= 1 ? 2 : 4;
+  return `${sign}${amount.toFixed(decimals)}${currency && currency !== "USD" ? ` ${currency}` : ""}`;
+}
+function formatCostCompact(amount, currency) {
+  const whole = Math.round(amount);
+  if (whole === 0) {
+    return null;
+  }
+  const sign = currency === "USD" || currency === void 0 ? "$" : "";
+  return `${sign}${whole}${currency && currency !== "USD" ? ` ${currency}` : ""}`;
+}
+var AGENT_MODEL_SEP;
+var init_agent_display = __esm({
+  "src/core/agent-display.ts"() {
+    "use strict";
+    AGENT_MODEL_SEP = "\u2022";
+  }
+});
+
+// src/cli/session-row.ts
+function toRow(s, now = Date.now()) {
+  return {
+    session: stripHydraSessionPrefix(s.sessionId),
+    upstream: formatUpstreamCell(s.upstreamSessionId, s.importedFromMachine),
+    state: formatState(s.status, s.attachedClients),
+    agent: formatAgentCell(s.agentId, s.currentUsage),
+    age: formatRelativeAge(s.updatedAt, now),
+    title: s.title ?? "-",
+    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";
+  }
+  return `LIVE(${clients})`;
+}
+function computeWidths(rows) {
+  return {
+    session: maxLen(HEADER.session, rows.map((r) => r.session)),
+    upstream: maxLen(HEADER.upstream, rows.map((r) => r.upstream)),
+    state: maxLen(HEADER.state, rows.map((r) => r.state)),
+    agent: maxLen(HEADER.agent, rows.map((r) => r.agent)),
+    age: maxLen(HEADER.age, rows.map((r) => r.age)),
+    cwd: maxLen(HEADER.cwd, rows.map((r) => r.cwd)),
+    title: maxLen(HEADER.title, rows.map((r) => r.title))
+  };
+}
+function formatRelativeAge(iso, now) {
+  if (!iso) {
+    return "?";
+  }
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) {
+    return "?";
+  }
+  const diff = Math.max(0, now - t);
+  const sec = Math.floor(diff / 1e3);
+  if (sec < 60) {
+    return "<1m";
+  }
+  const min = Math.floor(sec / 60);
+  if (min < 60) {
+    return `${min}m`;
+  }
+  const hr = Math.floor(min / 60);
+  if (hr < 24) {
+    return `${hr}h`;
+  }
+  const day = Math.floor(hr / 24);
+  if (day < 14) {
+    return `${day}d`;
+  }
+  const week = Math.floor(day / 7);
+  if (week < 9) {
+    return `${week}w`;
+  }
+  const month = Math.floor(day / 30);
+  if (month < 12) {
+    return `${month}mo`;
+  }
+  const year = Math.floor(day / 365);
+  return `${year}y`;
+}
+function maxLen(headerCell, values) {
+  let max = headerCell.length;
+  for (const v of values) {
+    if (v.length > max) {
+      max = v.length;
+    }
+  }
+  return max;
+}
+function formatRow(r, w, maxWidth, cwdMaxWidth = DEFAULT_CWD_MAX_WIDTH) {
+  const fixed = [
+    r.session.padEnd(w.session),
+    r.upstream.padEnd(w.upstream),
+    r.state.padEnd(w.state),
+    r.agent.padEnd(w.agent),
+    r.age.padStart(w.age)
+  ].join(SEP);
+  if (maxWidth === void 0) {
+    return [fixed, r.cwd.padEnd(w.cwd), r.title].join(SEP);
+  }
+  const budget = maxWidth - fixed.length - SEP.length;
+  if (budget <= 0) {
+    return fixed.slice(0, maxWidth);
+  }
+  const cwdCap = Math.min(w.cwd, cwdMaxWidth);
+  const cwdAlloc = Math.min(cwdCap, Math.max(0, budget - SEP.length - 1));
+  const cwdCell = truncateMiddle(r.cwd, cwdAlloc).padEnd(cwdAlloc);
+  const titleBudget = Math.max(0, budget - cwdAlloc - SEP.length);
+  const titleCell = truncateRight(r.title, titleBudget);
+  return [fixed, cwdCell, titleCell].join(SEP);
+}
+function truncateRight(s, max) {
+  if (max <= 0) {
+    return "";
+  }
+  if (s.length <= max) {
+    return s;
+  }
+  if (max === 1) {
+    return "\u2026";
+  }
+  return s.slice(0, max - 1) + "\u2026";
+}
+function truncateMiddle(s, max) {
+  if (max <= 0) {
+    return "";
+  }
+  if (s.length <= max) {
+    return s;
+  }
+  if (max === 1) {
+    return "\u2026";
+  }
+  const head = Math.ceil((max - 1) / 2);
+  const tail = max - 1 - head;
+  return s.slice(0, head) + "\u2026" + s.slice(s.length - tail);
+}
+var HEADER, SEP, DEFAULT_CWD_MAX_WIDTH;
+var init_session_row = __esm({
+  "src/cli/session-row.ts"() {
+    "use strict";
+    init_agent_display();
+    init_paths();
+    init_session();
+    HEADER = {
+      session: "SESSION",
+      upstream: "UPSTREAM",
+      state: "STATE",
+      agent: "AGENT",
+      age: "AGE",
+      title: "TITLE",
+      cwd: "CWD"
+    };
+    SEP = "  ";
+    DEFAULT_CWD_MAX_WIDTH = 24;
+  }
+});
+
+// src/cli/commands/sessions.ts
+import * as fs13 from "fs/promises";
+import * as path8 from "path";
+async function runSessionsList(opts = {}) {
+  const config = await loadConfig();
+  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const url = new URL(`${baseUrl}/v1/sessions`);
+  const response = await fetch(url.toString(), {
+    headers: { Authorization: `Bearer ${config.daemon.authToken}` }
+  });
+  if (!response.ok) {
+    process.stderr.write(`Daemon returned HTTP ${response.status}
+`);
+    process.exit(1);
+  }
+  const body = await response.json();
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(body.sessions, null, 2) + "\n");
+    return;
+  }
+  if (body.sessions.length === 0) {
+    process.stdout.write("No active sessions.\n");
+    return;
+  }
+  const sorted = body.sessions.slice().sort((a, b) => {
+    const liveDiff = (b.status === "live" ? 1 : 0) - (a.status === "live" ? 1 : 0);
+    if (liveDiff !== 0) {
+      return liveDiff;
+    }
+    return String(b.updatedAt || "").localeCompare(String(a.updatedAt || ""));
+  });
+  let visible = sorted;
+  let truncated = 0;
+  if (!opts.all) {
+    const liveCount = sorted.filter((s) => s.status !== "cold").length;
+    const limit = config.sessionListColdLimit;
+    const coldSlice = sorted.slice(liveCount, liveCount + limit);
+    const hiddenCold = sorted.length - liveCount - coldSlice.length;
+    visible = [...sorted.slice(0, liveCount), ...coldSlice];
+    truncated = hiddenCold;
+  }
+  const now = Date.now();
+  const rows = visible.map((s) => toRow(s, now));
+  const widths = computeWidths(rows);
+  const maxWidth = process.stdout.isTTY ? process.stdout.columns : void 0;
+  const cwdMax = config.tui.cwdColumnMaxWidth;
+  process.stdout.write(formatRow(HEADER, widths, maxWidth, cwdMax) + "\n");
+  for (const r of rows) {
+    process.stdout.write(formatRow(r, widths, maxWidth, cwdMax) + "\n");
+  }
+  if (truncated > 0) {
+    process.stdout.write(
+      `
+... ${truncated} more cold session${truncated === 1 ? "" : "s"} hidden. Use --all to show.
+`
+    );
+  }
+}
+async function runSessionsKill(id) {
+  if (!id) {
+    process.stderr.write("Usage: hydra-acp sessions kill <session-id>\n");
+    process.exit(2);
+  }
+  const config = await loadConfig();
+  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetch(`${baseUrl}/v1/sessions/${id}/kill`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${config.daemon.authToken}` }
+  });
+  if (!response.ok && response.status !== 204) {
+    process.stderr.write(`Daemon returned HTTP ${response.status}
+`);
+    process.exit(1);
+  }
+  process.stdout.write(`Killed ${id}
+`);
+}
+async function runSessionsRemove(id) {
+  if (!id) {
+    process.stderr.write("Usage: hydra-acp sessions remove <session-id>\n");
+    process.exit(2);
+  }
+  const config = await loadConfig();
+  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetch(`${baseUrl}/v1/sessions/${id}`, {
+    method: "DELETE",
+    headers: { Authorization: `Bearer ${config.daemon.authToken}` }
+  });
+  if (!response.ok && response.status !== 204) {
+    process.stderr.write(`Daemon returned HTTP ${response.status}
+`);
+    process.exit(1);
+  }
+  process.stdout.write(`Removed ${id}
+`);
+}
+async function runSessionsExport(id, outPath) {
+  if (!id) {
+    process.stderr.write(
+      "Usage: hydra-acp sessions export <session-id> [--out <file>]\n"
+    );
+    process.exit(2);
+  }
+  const config = await loadConfig();
+  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetch(
+    `${baseUrl}/v1/sessions/${encodeURIComponent(id)}/export`,
+    {
+      headers: { Authorization: `Bearer ${config.daemon.authToken}` }
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    process.stderr.write(`Daemon returned HTTP ${response.status}: ${text}
+`);
+    process.exit(1);
+  }
+  const body = await response.text();
+  if (!outPath) {
+    process.stdout.write(body);
+    if (!body.endsWith("\n")) {
+      process.stdout.write("\n");
+    }
+    return;
+  }
+  const resolved = outPath === "." ? deriveFilenameFrom(response, id) : outPath;
+  await fs13.mkdir(path8.dirname(path8.resolve(resolved)), { recursive: true });
+  await fs13.writeFile(resolved, body, { encoding: "utf8", mode: 384 });
+  process.stdout.write(`Wrote ${resolved}
+`);
+}
+async function runSessionsTranscript(idOrFile, outPath) {
+  if (!idOrFile) {
+    process.stderr.write(
+      "Usage: hydra-acp sessions transcript <session-id>|<file> [--out <file>|.]\n"
+    );
+    process.exit(2);
+  }
+  let body;
+  let defaultName;
+  const localFile = await readBundleFileIfExists(idOrFile);
+  if (localFile !== null) {
+    const bundle = decodeBundleOrExit(localFile.raw);
+    body = bundleToMarkdown(bundle);
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    defaultName = `${path8.basename(idOrFile, path8.extname(idOrFile))}-${stamp}.md`;
+  } else {
+    const config = await loadConfig();
+    const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+    const response = await fetch(
+      `${baseUrl}/v1/sessions/${encodeURIComponent(idOrFile)}/transcript`,
+      {
+        headers: { Authorization: `Bearer ${config.daemon.authToken}` }
+      }
+    );
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      process.stderr.write(`Daemon returned HTTP ${response.status}: ${text}
+`);
+      process.exit(1);
+    }
+    body = await response.text();
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    defaultName = `hydra-${idOrFile}-${stamp}.md`;
+  }
+  if (!outPath) {
+    process.stdout.write(body);
+    if (!body.endsWith("\n")) {
+      process.stdout.write("\n");
+    }
+    return;
+  }
+  const resolved = outPath === "." ? defaultName : outPath;
+  await fs13.mkdir(path8.dirname(path8.resolve(resolved)), { recursive: true });
+  await fs13.writeFile(resolved, body, { encoding: "utf8", mode: 384 });
+  process.stdout.write(`Wrote ${resolved}
+`);
+}
+async function readBundleFileIfExists(arg) {
+  try {
+    const stat4 = await fs13.stat(arg);
+    if (!stat4.isFile()) {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  const text = await fs13.readFile(arg, "utf8");
+  try {
+    return { raw: JSON.parse(text) };
+  } catch (err) {
+    process.stderr.write(`Failed to parse bundle file: ${err.message}
+`);
+    process.exit(1);
+  }
+}
+function decodeBundleOrExit(raw) {
+  try {
+    return decodeBundle(raw);
+  } catch (err) {
+    process.stderr.write(`Not a valid bundle: ${err.message}
+`);
+    process.exit(1);
+  }
+}
+async function runSessionsImport(file, opts = {}) {
+  if (!file) {
+    process.stderr.write(
+      "Usage: hydra-acp sessions import <file>|- [--replace] [--cwd <path>] [--info]\n"
+    );
+    process.exit(2);
+  }
+  let cwdOverride;
+  if (opts.cwd !== void 0) {
+    const resolved = path8.resolve(opts.cwd);
+    try {
+      const stat4 = await fs13.stat(resolved);
+      if (!stat4.isDirectory()) {
+        process.stderr.write(`--cwd ${resolved} is not a directory
+`);
+        process.exit(1);
+      }
+    } catch {
+      process.stderr.write(`--cwd ${resolved} does not exist
+`);
+      process.exit(1);
+    }
+    cwdOverride = resolved;
+  }
+  let body;
+  if (file === "-") {
+    body = await readStdin();
+  } else {
+    body = await fs13.readFile(file, "utf8");
+  }
+  let bundle;
+  try {
+    bundle = JSON.parse(body);
+  } catch (err) {
+    process.stderr.write(`Failed to parse bundle: ${err.message}
+`);
+    process.exit(1);
+  }
+  if (opts.info === true) {
+    const inspectConfig = await loadConfigReadOnly();
+    printBundleInfo(bundle, inspectConfig.tui.cwdColumnMaxWidth);
+    return;
+  }
+  const config = await loadConfig();
+  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetch(`${baseUrl}/v1/sessions/import`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.daemon.authToken}`
+    },
+    body: JSON.stringify({
+      bundle,
+      replace: opts.replace === true,
+      ...cwdOverride !== void 0 ? { cwd: cwdOverride } : {}
+    })
+  });
+  if (response.status === 409) {
+    const detail = await response.json().catch(() => ({}));
+    process.stderr.write(
+      `Bundle already imported as ${detail.existingSessionId ?? "unknown"}. Use --replace to overwrite.
+`
+    );
+    process.exit(1);
+  }
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    process.stderr.write(`Daemon returned HTTP ${response.status}: ${text}
+`);
+    process.exit(1);
+  }
+  const result = await response.json();
+  process.stdout.write(
+    result.replaced ? `Replaced ${result.sessionId} (from ${result.importedFromSessionId})
+` : `Imported as ${result.sessionId} (from ${result.importedFromSessionId})
+`
+  );
+}
+function bundleToSummary(parsed) {
+  return {
+    sessionId: parsed.session.sessionId,
+    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"
+  };
+}
+function printBundleInfo(raw, cwdColumnMaxWidth) {
+  let parsed;
+  try {
+    parsed = decodeBundle(raw);
+  } catch (err) {
+    process.stderr.write(`Not a valid bundle: ${err.message}
+`);
+    process.exit(1);
+  }
+  const summary = bundleToSummary(parsed);
+  const row = toRow(summary);
+  const widths = computeWidths([row]);
+  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")
+  );
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function deriveFilenameFrom(response, id) {
+  const cd = response.headers.get("content-disposition");
+  if (cd) {
+    const match = cd.match(/filename="([^"]+)"/);
+    if (match) {
+      return match[1];
+    }
+  }
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return `hydra-${id}-${stamp}.hydra`;
+}
+function httpBase(host, port, tls) {
+  const protocol = tls ? "https" : "http";
+  return `${protocol}://${host}:${port}`;
+}
+var init_sessions = __esm({
+  "src/cli/commands/sessions.ts"() {
+    "use strict";
+    init_config();
+    init_bundle();
+    init_transcript();
+    init_session_row();
+  }
+});
+
+// src/shim/resilient-ws.ts
+import { setTimeout as sleep3 } from "timers/promises";
+import { WebSocket } from "ws";
+function isResponse(msg) {
+  return !("method" in msg) && "id" in msg && msg.id !== void 0;
+}
+async function openWs(url, subprotocols) {
+  return new Promise((resolve5, reject) => {
+    const ws = new WebSocket(url, subprotocols);
+    const onOpen = () => {
+      ws.off("error", onError);
+      resolve5(wsToMessageStream(ws));
+    };
+    const onError = (err) => {
+      ws.off("open", onOpen);
       reject(err);
     };
     ws.once("open", onOpen);
@@ -3324,6 +4054,58 @@ var init_resilient_ws = __esm({
   }
 });
 
+// src/core/update-check.ts
+function disabled() {
+  if (process.env.NO_UPDATE_NOTIFIER === "1") {
+    return true;
+  }
+  if (process.argv.includes("--no-update-notifier")) {
+    return true;
+  }
+  return false;
+}
+async function getPendingUpdate() {
+  if (cached !== void 0) {
+    return cached;
+  }
+  if (disabled()) {
+    cached = null;
+    return cached;
+  }
+  try {
+    const mod = await import("update-notifier");
+    const updateNotifier = mod.default ?? mod;
+    const notifier = updateNotifier({
+      pkg: { name: PKG_NAME, version: HYDRA_VERSION },
+      updateCheckInterval: 1e3 * 60 * 60 * 24
+    });
+    const u = notifier.update;
+    if (u && typeof u.latest === "string" && typeof u.current === "string" && u.latest !== u.current) {
+      cached = {
+        current: u.current,
+        latest: u.latest,
+        type: typeof u.type === "string" ? u.type : "unknown"
+      };
+    } else {
+      cached = null;
+    }
+  } catch {
+    cached = null;
+  }
+  return cached;
+}
+function formatUpdateNoticeLine(info) {
+  return `hydra-acp ${info.latest} available (current ${info.current}) \xB7 run: npm update -g ${PKG_NAME}`;
+}
+var PKG_NAME, cached;
+var init_update_check = __esm({
+  "src/core/update-check.ts"() {
+    "use strict";
+    init_hydra_version();
+    PKG_NAME = "@hydra-acp/cli";
+  }
+});
+
 // src/tui/discovery.ts
 async function listSessions(config, opts = {}, fetchImpl = fetch) {
   const base = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
@@ -4558,7 +5340,7 @@ function mapKeyName(name) {
       return null;
   }
 }
-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 SESSIONBAR_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";
@@ -4566,7 +5348,7 @@ var init_screen = __esm({
     init_paths();
     init_session();
     init_attachments();
-    HEADER_ROWS = 2;
+    SESSIONBAR_ROWS = 1;
     BANNER_ROWS = 1;
     SEPARATOR_ROWS = 1;
     MAX_PROMPT_ROWS = 8;
@@ -4664,7 +5446,7 @@ var init_screen = __esm({
         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: "?" };
+      sessionbar = { agent: "?", cwd: "?", sessionId: "?" };
       lastWindowTitle = null;
       resizeHandler;
       keyHandler;
@@ -5015,8 +5797,8 @@ var init_screen = __esm({
         this.trimScrollback();
         this.scheduleRepaint();
       }
-      setHeader(header) {
-        this.header = { ...this.header, ...header };
+      setSessionbar(sessionbar) {
+        this.sessionbar = { ...this.sessionbar, ...sessionbar };
         this.syncWindowTitle();
         this.repaint();
       }
@@ -5024,8 +5806,8 @@ var init_screen = __esm({
       // the host terminal via OSC 2. Supported by xterm/foot/iTerm2/Alacritty/
       // most modern emulators; ignored harmlessly elsewhere.
       syncWindowTitle() {
-        const title = this.header.title?.trim();
-        const fallback = shortId(this.header.sessionId) || "hydra";
+        const title = this.sessionbar.title?.trim();
+        const fallback = shortId(this.sessionbar.sessionId) || "hydra";
         const raw = title && title.length > 0 ? title : fallback;
         const clean = raw.replace(/[\x00-\x1f\x7f]/g, "").slice(0, 200);
         if (clean === this.lastWindowTitle) {
@@ -5547,8 +6329,10 @@ var init_screen = __esm({
         return Math.max(1, this.scrollbackVisibleRows() - 2);
       }
       scrollbackVisibleRows() {
-        const top = HEADER_ROWS + SEPARATOR_ROWS;
-        const bottom = this.term.height - this.promptRows() - BANNER_ROWS - SEPARATOR_ROWS - this.chipRows() - this.queuedRows() - this.completionRows();
+        const top = 1;
+        const bottom = this.term.height - this.promptRows() - SESSIONBAR_ROWS - SEPARATOR_ROWS - // separator between banner and sessionbar
+        BANNER_ROWS - SEPARATOR_ROWS - // separator above prompt
+        this.chipRows() - this.queuedRows() - this.completionRows();
         return Math.max(0, bottom - top + 1);
       }
       maxScrollOffset() {
@@ -5625,30 +6409,32 @@ var init_screen = __esm({
           this.lastFrameW = w;
           this.lastFrameH = h;
         }
-        this.drawHeader();
-        this.drawSeparator(HEADER_ROWS);
         this.drawScrollback();
         this.drawCompletionZone();
         this.drawQueuedZone();
         this.drawAttachmentChipZone();
         const promptRows = this.promptRows();
-        const separatorRow = h - promptRows - BANNER_ROWS;
-        this.drawSeparator(separatorRow);
+        const separatorAbovePromptRow = h - promptRows - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS;
+        this.drawSeparator(separatorAbovePromptRow);
         this.drawPrompt();
         this.drawBanner();
+        this.drawSeparator(h - SESSIONBAR_ROWS);
+        this.drawSessionbar();
         this.placeCursor();
         this.lastPromptRows = promptRows;
       }
-      drawHeader() {
+      drawSessionbar() {
         const w = this.term.width;
-        const usage = formatUsage(this.header.usage);
-        const sid = shortId(this.header.sessionId);
-        const title = this.header.title?.trim();
-        const agentCell = formatAgentWithModel(this.header.agent, this.header.model);
-        const cwdDisplay = shortenHomePath(this.header.cwd);
-        const sig = `hdr|${w}|${agentCell}|${cwdDisplay}|${sid}|${title ?? ""}|${usage ?? ""}`;
-        this.paintRow(1, sig, () => {
-          const fixed = "hydra \xB7 ".length + agentCell.length + " \xB7 ".length + " \xB7 ".length + sid.length + (title ? " \xB7 ".length : 0) + (usage ? usage.length + 3 : 0);
+        const row = this.term.height;
+        const sid = shortId(this.sessionbar.sessionId);
+        const title = this.sessionbar.title?.trim();
+        const agentCell = formatAgentWithModel(this.sessionbar.agent, this.sessionbar.model);
+        const cwdDisplay = shortenHomePath(this.sessionbar.cwd);
+        const usage = formatUsage(this.sessionbar.usage);
+        const sig = `sbar|${w}|${sid}|${agentCell}|${cwdDisplay}|${title ?? ""}|${usage ?? ""}`;
+        this.paintRow(row, sig, () => {
+          const usageReserve = usage ? usage.length + 3 : 0;
+          const fixed = sid.length + " \xB7 ".length + agentCell.length + " \xB7 ".length + (title ? " \xB7 ".length : 0) + usageReserve;
           const variableRoom = Math.max(8, w - fixed);
           let cwdRoom;
           let titleRoom;
@@ -5660,13 +6446,13 @@ var init_screen = __esm({
             titleRoom = 0;
             cwdRoom = variableRoom;
           }
-          this.term.bold("hydra")(" \xB7 ").cyan.noFormat(agentCell)(" \xB7 ").dim.noFormat(truncate(cwdDisplay, cwdRoom))(" \xB7 ").yellow(sid);
+          this.term.yellow(sid)(" \xB7 ").cyan.noFormat(agentCell)(" \xB7 ").dim.noFormat(truncate(cwdDisplay, cwdRoom));
           if (title) {
             this.term(" \xB7 ").bold.noFormat(truncate(title, titleRoom));
           }
           if (usage) {
             const col = Math.max(1, w - usage.length + 1);
-            this.term.moveTo(col, 1).eraseLineAfter();
+            this.term.moveTo(col, row).eraseLineAfter();
             this.term.dim.noFormat(usage);
           }
         });
@@ -5679,7 +6465,7 @@ var init_screen = __esm({
       }
       drawScrollback() {
         const w = this.term.width;
-        const top = HEADER_ROWS + SEPARATOR_ROWS;
+        const top = 1;
         const visibleRows = this.scrollbackVisibleRows();
         if (visibleRows <= 0) {
           return;
@@ -5745,7 +6531,7 @@ var init_screen = __esm({
         }
         const w = this.term.width;
         const promptRows = this.promptRows();
-        const separatorRow = this.term.height - promptRows - BANNER_ROWS;
+        const separatorRow = this.term.height - promptRows - SESSIONBAR_ROWS - SEPARATOR_ROWS - BANNER_ROWS;
         const queuedRows = this.queuedRows();
         const chipRows = this.chipRows();
         const completionBottom = separatorRow - 1 - queuedRows - chipRows;
@@ -5793,7 +6579,7 @@ var init_screen = __esm({
         }
         const w = this.term.width;
         const promptRows = this.promptRows();
-        const separatorRow = this.term.height - promptRows - BANNER_ROWS;
+        const separatorRow = this.term.height - promptRows - SESSIONBAR_ROWS - SEPARATOR_ROWS - BANNER_ROWS;
         const chipBottom = separatorRow - 1;
         const chipTop = chipBottom - rows + 1;
         const iterm = this.isIterm2();
@@ -5840,7 +6626,7 @@ var init_screen = __esm({
         }
         const w = this.term.width;
         const promptRows = this.promptRows();
-        const separatorRow = this.term.height - promptRows - BANNER_ROWS;
+        const separatorRow = this.term.height - promptRows - SESSIONBAR_ROWS - SEPARATOR_ROWS - BANNER_ROWS;
         const chipRows = this.chipRows();
         const queuedBottom = separatorRow - 1 - chipRows;
         const queuedTop = queuedBottom - rows + 1;
@@ -5882,7 +6668,7 @@ var init_screen = __esm({
         const state = this.dispatcher.state();
         const visualRows = computePromptVisualRows(state.buffer, room);
         const layout = computePromptLayout(visualRows, state, MAX_PROMPT_ROWS);
-        const top = this.term.height - layout.rendered - BANNER_ROWS + 1;
+        const top = this.term.height - layout.rendered - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS + 1;
         for (let i = 0; i < layout.rendered; i++) {
           const vr = visualRows[layout.windowStart + i];
           const row = top + i;
@@ -5918,7 +6704,7 @@ var init_screen = __esm({
           return;
         }
         const w = this.term.width;
-        const top = this.term.height - CONFIRM_PROMPT_ROWS - BANNER_ROWS + 1;
+        const top = this.term.height - CONFIRM_PROMPT_ROWS - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS + 1;
         this.paintRow(top, `confirm|q|${w}|${spec.question}`, () => {
           this.term.brightYellow(` ? ${truncate(spec.question, w - 4)}`);
         });
@@ -5933,7 +6719,7 @@ var init_screen = __esm({
         }
         const w = this.term.width;
         const rows = this.permissionRows();
-        const top = this.term.height - rows - BANNER_ROWS + 1;
+        const top = this.term.height - rows - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS + 1;
         let row = top;
         const writeRow = (sig, paint) => {
           if (row >= top + rows) {
@@ -5975,7 +6761,7 @@ var init_screen = __esm({
         });
       }
       drawBanner() {
-        const row = this.term.height;
+        const row = this.term.height - SESSIONBAR_ROWS - SEPARATOR_ROWS;
         const w = this.term.width;
         const elapsedStr = this.banner.status === "busy" && this.banner.elapsedMs !== void 0 && this.banner.elapsedMs >= 1e3 ? formatElapsed(this.banner.elapsedMs) : "";
         const right = this.bannerRightContent();
@@ -6024,13 +6810,14 @@ var init_screen = __esm({
       placeCursor() {
         if (this.permissionPrompt) {
           const rows = this.permissionRows();
-          const top2 = this.term.height - rows - BANNER_ROWS + 1;
+          const top2 = this.term.height - rows - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS + 1;
           const optionRow = top2 + 3 + this.permissionPrompt.selectedIndex;
-          this.term.moveTo(2, Math.min(optionRow, this.term.height - BANNER_ROWS));
+          const lastUsableRow = this.term.height - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS;
+          this.term.moveTo(2, Math.min(optionRow, lastUsableRow));
           return;
         }
         if (this.confirmPrompt) {
-          const top2 = this.term.height - CONFIRM_PROMPT_ROWS - BANNER_ROWS + 1;
+          const top2 = this.term.height - CONFIRM_PROMPT_ROWS - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS + 1;
           this.term.moveTo(2, top2);
           return;
         }
@@ -6044,12 +6831,13 @@ var init_screen = __esm({
         const state = this.dispatcher.state();
         const visualRows = computePromptVisualRows(state.buffer, room);
         const layout = computePromptLayout(visualRows, state, MAX_PROMPT_ROWS);
-        const top = this.term.height - layout.rendered - BANNER_ROWS + 1;
+        const top = this.term.height - layout.rendered - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS + 1;
         const row = top + Math.max(0, layout.cursorVisualRow - layout.windowStart);
         const col = layout.cursorVisualCol + 3;
+        const lastPromptRow = this.term.height - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS;
         this.term.moveTo(
           Math.min(col, this.term.width),
-          Math.min(row, this.term.height - BANNER_ROWS)
+          Math.min(row, lastPromptRow)
         );
       }
       promptRows() {
@@ -6741,746 +7529,461 @@ var init_input = __esm({
           };
           return [];
         }
-        const matchIndices = this.findHistoryMatches(query);
-        if (matchIndices.length === 0) {
-          return [{ type: "escalate-search", query }];
-        }
-        this.historySearch = {
-          query,
-          matchIndices,
-          cursor: 0,
-          savedDraft: {
-            buffer: [...this.buffer],
-            row: this.row,
-            col: this.col
-          }
-        };
-        this.loadEntry(this.history[matchIndices[0]] ?? "");
-        return [];
-      }
-      // ^R advance. At the oldest match with a non-empty query, falls
-      // through to scrollback search (same escalate path as a never-
-      // matched startHistorySearch). With an empty query at the oldest
-      // match (i.e. the user walked all history with no filter), advance
-      // is a no-op so the buffer stays on the oldest entry.
-      advanceHistorySearch() {
-        if (this.historySearch === null) {
-          return [];
-        }
-        const search = this.historySearch;
-        const atOldest = search.cursor >= search.matchIndices.length - 1;
-        if (atOldest) {
-          if (search.query.length === 0) {
-            return [];
-          }
-          const query = search.query;
-          const draft = search.savedDraft;
-          this.historySearch = null;
-          this.buffer = [...draft.buffer];
-          this.row = draft.row;
-          this.col = draft.col;
-          return [{ type: "escalate-search", query }];
-        }
-        search.cursor += 1;
-        const idx = search.matchIndices[search.cursor];
-        this.loadEntry(this.history[idx] ?? "");
-        return [];
-      }
-      // ^S retreat — walk toward newer matches. No-op at the newest match
-      // (no wrap, mirroring ^R no-wrap at the oldest).
-      retreatHistorySearch() {
-        if (this.historySearch === null) {
-          return;
-        }
-        if (this.historySearch.cursor === 0) {
-          return;
-        }
-        this.historySearch.cursor -= 1;
-        const idx = this.historySearch.matchIndices[this.historySearch.cursor];
-        this.loadEntry(this.history[idx] ?? "");
-      }
-      // Backspace / typing within search mode mutates the query and
-      // re-searches. When the new query is empty, restore the saved
-      // draft buffer (typically empty) and stay in search mode — the
-      // user can keep typing. When the new query has matches, load the
-      // top one. When the new query has no matches, escalate to scrollback
-      // search so the typed term applies there instead.
-      mutateHistorySearchQuery(newQuery) {
-        if (this.historySearch === null) {
-          return [];
-        }
-        if (newQuery.length === 0) {
-          this.historySearch.query = "";
-          this.historySearch.matchIndices = [];
-          this.historySearch.cursor = 0;
-          const draft = this.historySearch.savedDraft;
-          this.buffer = [...draft.buffer];
-          this.row = draft.row;
-          this.col = draft.col;
-          return [];
-        }
-        const matchIndices = this.findHistoryMatches(newQuery);
-        if (matchIndices.length === 0) {
-          const draft = this.historySearch.savedDraft;
-          this.historySearch = null;
-          this.buffer = [...draft.buffer];
-          this.row = draft.row;
-          this.col = draft.col;
-          return [{ type: "escalate-search", query: newQuery }];
-        }
-        this.historySearch.query = newQuery;
-        this.historySearch.matchIndices = matchIndices;
-        this.historySearch.cursor = 0;
-        this.loadEntry(this.history[matchIndices[0]] ?? "");
-        return [];
-      }
-      findHistoryMatches(query) {
-        const out = [];
-        for (let i = this.history.length - 1; i >= 0; i--) {
-          const entry = this.history[i] ?? "";
-          if (query.length === 0 || entry.toLowerCase().includes(query)) {
-            out.push(i);
-          }
-        }
-        return out;
-      }
-      cancelHistorySearch() {
-        if (this.historySearch === null) {
-          return;
-        }
-        const draft = this.historySearch.savedDraft;
-        this.historySearch = null;
-        this.buffer = [...draft.buffer];
-        this.row = draft.row;
-        this.col = draft.col;
-      }
-      loadEntry(text) {
-        this.buffer = text.split("\n");
-        if (this.buffer.length === 0) {
-          this.buffer = [""];
-        }
-        this.row = this.buffer.length - 1;
-        this.col = (this.buffer[this.row] ?? "").length;
-      }
-      send() {
-        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, attachments: attachments2 }];
-        }
-        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, 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.
-      handleHome() {
-        if (this.row !== 0 || this.col !== 0) {
-          this.row = 0;
-          this.col = 0;
-          return [];
+        const matchIndices = this.findHistoryMatches(query);
+        if (matchIndices.length === 0) {
+          return [{ type: "escalate-search", query }];
         }
-        return [{ type: "scroll-to-top" }];
+        this.historySearch = {
+          query,
+          matchIndices,
+          cursor: 0,
+          savedDraft: {
+            buffer: [...this.buffer],
+            row: this.row,
+            col: this.col
+          }
+        };
+        this.loadEntry(this.history[matchIndices[0]] ?? "");
+        return [];
       }
-      // End: jump to the end of the last line of the prompt buffer. Already
-      // there → scroll the scrollback to the bottom (newest).
-      handleEnd() {
-        const lastRow = this.buffer.length - 1;
-        const lastCol = (this.buffer[lastRow] ?? "").length;
-        if (this.row !== lastRow || this.col !== lastCol) {
-          this.row = lastRow;
-          this.col = lastCol;
+      // ^R advance. At the oldest match with a non-empty query, falls
+      // through to scrollback search (same escalate path as a never-
+      // matched startHistorySearch). With an empty query at the oldest
+      // match (i.e. the user walked all history with no filter), advance
+      // is a no-op so the buffer stays on the oldest entry.
+      advanceHistorySearch() {
+        if (this.historySearch === null) {
           return [];
         }
-        return [{ type: "scroll-to-bottom" }];
-      }
-      handleCtrlC() {
-        if (this.queueIndex >= 0) {
-          const index = this.queueIndex;
-          this.queueIndex = -1;
-          this.restoreDraft();
-          return [{ type: "queue-remove", index }];
+        const search = this.historySearch;
+        const atOldest = search.cursor >= search.matchIndices.length - 1;
+        if (atOldest) {
+          if (search.query.length === 0) {
+            return [];
+          }
+          const query = search.query;
+          const draft = search.savedDraft;
+          this.historySearch = null;
+          this.buffer = [...draft.buffer];
+          this.row = draft.row;
+          this.col = draft.col;
+          return [{ type: "escalate-search", query }];
         }
-        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 [];
+        search.cursor += 1;
+        const idx = search.matchIndices[search.cursor];
+        this.loadEntry(this.history[idx] ?? "");
+        return [];
+      }
+      // ^S retreat — walk toward newer matches. No-op at the newest match
+      // (no wrap, mirroring ^R no-wrap at the oldest).
+      retreatHistorySearch() {
+        if (this.historySearch === null) {
+          return;
         }
-        if (this.turnRunning) {
-          return [{ type: "cancel" }];
+        if (this.historySearch.cursor === 0) {
+          return;
         }
-        return [{ type: "exit" }];
-      }
-    };
-  }
-});
-
-// 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)}`
-        };
+        this.historySearch.cursor -= 1;
+        const idx = this.historySearch.matchIndices[this.historySearch.cursor];
+        this.loadEntry(this.history[idx] ?? "");
       }
-      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
+      // Backspace / typing within search mode mutates the query and
+      // re-searches. When the new query is empty, restore the saved
+      // draft buffer (typically empty) and stay in search mode — the
+      // user can keep typing. When the new query has matches, load the
+      // top one. When the new query has no matches, escalate to scrollback
+      // search so the typed term applies there instead.
+      mutateHistorySearchQuery(newQuery) {
+        if (this.historySearch === null) {
+          return [];
+        }
+        if (newQuery.length === 0) {
+          this.historySearch.query = "";
+          this.historySearch.matchIndices = [];
+          this.historySearch.cursor = 0;
+          const draft = this.historySearch.savedDraft;
+          this.buffer = [...draft.buffer];
+          this.row = draft.row;
+          this.col = draft.col;
+          return [];
+        }
+        const matchIndices = this.findHistoryMatches(newQuery);
+        if (matchIndices.length === 0) {
+          const draft = this.historySearch.savedDraft;
+          this.historySearch = null;
+          this.buffer = [...draft.buffer];
+          this.row = draft.row;
+          this.col = draft.col;
+          return [{ type: "escalate-search", query: newQuery }];
+        }
+        this.historySearch.query = newQuery;
+        this.historySearch.matchIndices = matchIndices;
+        this.historySearch.cursor = 0;
+        this.loadEntry(this.history[matchIndices[0]] ?? "");
+        return [];
       }
-    };
-  } 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}`));
+      findHistoryMatches(query) {
+        const out = [];
+        for (let i = this.history.length - 1; i >= 0; i--) {
+          const entry = this.history[i] ?? "";
+          if (query.length === 0 || entry.toLowerCase().includes(query)) {
+            out.push(i);
+          }
+        }
+        return out;
       }
-    });
-  });
-}
-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;
+      cancelHistorySearch() {
+        if (this.historySearch === null) {
+          return;
+        }
+        const draft = this.historySearch.savedDraft;
+        this.historySearch = null;
+        this.buffer = [...draft.buffer];
+        this.row = draft.row;
+        this.col = draft.col;
       }
-      settled = true;
-      if (closedCode === 0) {
-        resolve5(Buffer.concat(chunks));
-      } else {
-        reject(new Error(`${cmd} exited ${closedCode}`));
+      loadEntry(text) {
+        this.buffer = text.split("\n");
+        if (this.buffer.length === 0) {
+          this.buffer = [""];
+        }
+        this.row = this.buffer.length - 1;
+        this.col = (this.buffer[this.row] ?? "").length;
       }
-    };
-    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;
+      send() {
+        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, attachments: attachments2 }];
+        }
+        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, attachments }];
       }
-      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) {
-    return "";
-  }
-  let prefix = names[0] ?? "";
-  for (let i = 1; i < names.length; i++) {
-    const n = names[i] ?? "";
-    let j = 0;
-    while (j < prefix.length && j < n.length && prefix[j] === n[j]) {
-      j += 1;
-    }
-    prefix = prefix.slice(0, j);
-    if (prefix.length === 0) {
-      break;
-    }
-  }
-  return prefix;
-}
-function computeTabCompletion(args) {
-  const { matches, firstLine: firstLine3 } = args;
-  if (matches.length === 0) {
-    return null;
-  }
-  const space = firstLine3.indexOf(" ");
-  const typedPrefix = space === -1 ? firstLine3 : firstLine3.slice(0, space);
-  const tail = space === -1 ? "" : firstLine3.slice(space);
-  if (matches.length === 1) {
-    const name = matches[0] ?? "";
-    const suffix = tail.startsWith(" ") ? "" : " ";
-    return name + suffix + tail;
-  }
-  const commonPrefix = longestCommonPrefix(matches);
-  if (commonPrefix.length <= typedPrefix.length) {
-    return null;
-  }
-  return commonPrefix + tail;
-}
-var init_completion = __esm({
-  "src/tui/completion.ts"() {
-    "use strict";
-  }
-});
-
-// src/tui/render-update.ts
-import stripAnsi from "strip-ansi";
-function sanitizeWireText(text) {
-  return stripAnsi(text).replace(STRIP_CONTROLS, "");
-}
-function sanitizeSingleLine(text) {
-  return sanitizeWireText(text).replace(/[\n\t]+/g, " ").replace(/  +/g, " ").trim();
-}
-function mapUpdate(update) {
-  if (!update || typeof update !== "object") {
-    return null;
-  }
-  const u = update;
-  const tag = u.sessionUpdate ?? u.kind;
-  if (typeof tag !== "string") {
-    return null;
-  }
-  switch (tag) {
-    case "agent_message_chunk":
-      return mapAgentText(u);
-    case "agent_thought_chunk":
-    case "agent_thought":
-      return mapAgentThought(u);
-    case "user_message_chunk":
-      return mapUserText(u);
-    case "prompt_received":
-      return mapPromptReceived(u);
-    case "tool_call":
-      return mapToolCall(u);
-    case "tool_call_update":
-      return mapToolCallUpdate(u);
-    case "plan":
-      return mapPlan(u);
-    case "current_mode_update":
-      return mapMode(u);
-    case "current_model_update":
-      return mapModel(u);
-    case "turn_complete":
-      return mapTurnComplete(u);
-    case "usage_update":
-      return mapUsage(u);
-    case "available_commands_update":
-      return mapAvailableCommands(u);
-    case "session_info_update":
-      return mapSessionInfo(u);
-    default:
-      return { kind: "unknown", sessionUpdate: tag, raw: update };
-  }
-}
-function mapSessionInfo(u) {
-  const rawTitle = readString(u, "title");
-  const title = rawTitle !== void 0 ? sanitizeSingleLine(rawTitle) : void 0;
-  const meta = u._meta;
-  let agentId;
-  if (meta && typeof meta === "object" && !Array.isArray(meta)) {
-    const ns = meta["hydra-acp"];
-    if (ns && typeof ns === "object" && !Array.isArray(ns)) {
-      const candidate = ns.agentId;
-      if (typeof candidate === "string") {
-        agentId = candidate;
+      // Home: jump to the very start of the prompt buffer. If we're already
+      // there, fall through to scrolling the scrollback to its top.
+      handleHome() {
+        if (this.row !== 0 || this.col !== 0) {
+          this.row = 0;
+          this.col = 0;
+          return [];
+        }
+        return [{ type: "scroll-to-top" }];
+      }
+      // End: jump to the end of the last line of the prompt buffer. Already
+      // there → scroll the scrollback to the bottom (newest).
+      handleEnd() {
+        const lastRow = this.buffer.length - 1;
+        const lastCol = (this.buffer[lastRow] ?? "").length;
+        if (this.row !== lastRow || this.col !== lastCol) {
+          this.row = lastRow;
+          this.col = lastCol;
+          return [];
+        }
+        return [{ type: "scroll-to-bottom" }];
       }
-    }
-  }
-  if (title === void 0 && agentId === void 0) {
-    return null;
+      handleCtrlC() {
+        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) {
+          return [{ type: "cancel" }];
+        }
+        return [{ type: "exit" }];
+      }
+    };
   }
-  const event = { kind: "session-info" };
-  if (title !== void 0) {
-    event.title = title;
+});
+
+// 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 (agentId !== void 0) {
-    event.agentId = agentId;
+  if (env.platform === "linux") {
+    return readLinux(env);
   }
-  return event;
+  return {
+    ok: false,
+    reason: `clipboard paste is not supported on ${env.platform}`
+  };
 }
-function normalizeAdvertisedCommands(list) {
-  if (!Array.isArray(list)) {
-    return [];
+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);
   }
-  const out = [];
-  for (const raw of list) {
-    if (!raw || typeof raw !== "object") {
-      continue;
-    }
-    const c = raw;
-    if (typeof c.name !== "string" || c.name.length === 0) {
-      continue;
+  try {
+    await run2(env.spawn, "osascript", args);
+    const img = await readFileAsAttachment(tmpPath, true);
+    if (img.ok) {
+      return img;
     }
-    const rawName = c.name.startsWith("/") ? c.name : `/${c.name}`;
-    const cmd = { name: sanitizeSingleLine(rawName) };
-    if (typeof c.description === "string") {
-      cmd.description = sanitizeSingleLine(c.description);
+    if (img.reason.startsWith("clipboard image is")) {
+      return img;
     }
-    out.push(cmd);
-  }
-  return out;
-}
-function mapAvailableCommands(u) {
-  const list = u.availableCommands ?? u.commands;
-  if (!Array.isArray(list)) {
-    return null;
-  }
-  return { kind: "available-commands", commands: normalizeAdvertisedCommands(list) };
-}
-function mapUsage(u) {
-  const event = { kind: "usage-update" };
-  if (typeof u.used === "number") {
-    event.used = u.used;
-  }
-  if (typeof u.size === "number") {
-    event.size = u.size;
+  } catch {
+    await fs14.unlink(tmpPath).catch(() => void 0);
   }
-  if (u.cost && typeof u.cost === "object") {
-    const cost = u.cost;
-    if (typeof cost.amount === "number") {
-      event.costAmount = cost.amount;
-    }
-    if (typeof cost.currency === "string") {
-      event.costCurrency = cost.currency;
+  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" };
   }
-  return event;
-}
-function mapAgentText(u) {
-  const text = extractContentText(u.content);
-  if (text === null) {
-    return null;
-  }
-  return { kind: "agent-text", text };
 }
-function mapAgentThought(u) {
-  const text = typeof u.text === "string" ? sanitizeWireText(u.text) : extractContentText(u.content);
-  if (text === null) {
-    return null;
+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"
+    };
   }
-  return { kind: "agent-thought", text };
-}
-function mapUserText(u) {
-  const meta = u._meta;
-  if (meta && typeof meta === "object" && !Array.isArray(meta)) {
-    const hydra = meta["hydra-acp"];
-    if (hydra && typeof hydra === "object" && !Array.isArray(hydra) && hydra.compatFor === "prompt_received") {
-      return null;
+  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 {
   }
-  const text = extractContentText(u.content);
-  if (text === null) {
-    return null;
-  }
-  return { kind: "user-text", text };
-}
-function mapPromptReceived(u) {
-  const promptText = extractPromptText2(u.prompt);
-  if (promptText === null) {
-    return null;
+  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" };
   }
-  return { kind: "user-text", text: promptText };
 }
-function mapToolCall(u) {
-  const toolCallId = readString(u, "toolCallId") ?? readString(u, "id");
-  if (!toolCallId) {
-    return null;
-  }
-  const rawTitle = readString(u, "title") ?? readString(u, "name") ?? readString(u, "label") ?? "tool call";
-  const title = sanitizeSingleLine(rawTitle);
-  const status = readString(u, "status");
-  const rawKind = readString(u, "kind");
-  const event = { kind: "tool-call", toolCallId, title };
-  if (status !== void 0) {
-    event.status = status;
+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 (rawKind !== void 0) {
-    event.rawKind = rawKind;
+  if (env.env.DISPLAY && await which(env, "xclip")) {
+    return {
+      cmd: "xclip",
+      imageArgs: ["-selection", "clipboard", "-t", "image/png", "-o"],
+      textArgs: ["-selection", "clipboard", "-o"]
+    };
   }
-  return event;
+  return null;
 }
-function mapToolCallUpdate(u) {
-  const toolCallId = readString(u, "toolCallId") ?? readString(u, "id");
-  if (!toolCallId) {
-    return null;
-  }
-  const rawTitle = readString(u, "title");
-  const title = rawTitle !== void 0 ? sanitizeSingleLine(rawTitle) : void 0;
-  const status = readString(u, "status");
-  const meaningful = title !== void 0 || status === "completed" || status === "failed" || status === "rejected" || status === "cancelled";
-  if (!meaningful) {
-    return null;
-  }
-  const event = { kind: "tool-call-update", toolCallId };
-  if (title !== void 0) {
-    event.title = title;
-  }
-  if (status !== void 0) {
-    event.status = status;
-  }
-  return event;
+function normalizeText(text) {
+  return text.replace(/\r\n?/g, "\n");
 }
-function mapPlan(u) {
-  const entries = u.entries;
-  if (!Array.isArray(entries)) {
-    return null;
+async function which(env, cmd) {
+  try {
+    await run2(env.spawn, "which", [cmd]);
+    return true;
+  } catch {
+    return false;
   }
-  const normalized = [];
-  for (const raw of entries) {
-    if (!raw || typeof raw !== "object") {
-      continue;
-    }
-    const e = raw;
-    const content = typeof e.content === "string" ? sanitizeSingleLine(e.content) : void 0;
-    if (!content) {
-      continue;
+}
+async function readFileAsAttachment(p, unlinkAfter) {
+  try {
+    const buf = await fs14.readFile(p);
+    if (unlinkAfter) {
+      await fs14.unlink(p).catch(() => void 0);
     }
-    const entry = { content };
-    if (typeof e.status === "string") {
-      entry.status = e.status;
+    if (buf.length === 0) {
+      return { ok: false, reason: "no image on clipboard" };
     }
-    if (typeof e.priority === "string") {
-      entry.priority = e.priority;
+    if (buf.length > MAX_ATTACHMENT_BYTES) {
+      return {
+        ok: false,
+        reason: `clipboard image is ${formatSize(buf.length)}, max ${formatSize(MAX_ATTACHMENT_BYTES)}`
+      };
     }
-    normalized.push(entry);
-  }
-  return { kind: "plan", entries: normalized };
-}
-function mapMode(u) {
-  const mode = readString(u, "currentMode") ?? readString(u, "mode");
-  if (!mode) {
-    return null;
+    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" };
   }
-  return { kind: "mode-changed", mode: sanitizeSingleLine(mode) };
 }
-function mapModel(u) {
-  const model = readString(u, "currentModel") ?? readString(u, "model");
-  if (!model) {
-    return null;
-  }
-  return { kind: "model-changed", model: sanitizeSingleLine(model) };
+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 mapTurnComplete(u) {
-  const stopReason = readString(u, "stopReason");
-  return stopReason !== void 0 ? { kind: "turn-complete", stopReason } : { kind: "turn-complete" };
+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();
+    });
+  });
 }
-function extractContentText(content) {
-  if (typeof content === "string") {
-    return sanitizeWireText(content);
-  }
-  if (!content || typeof content !== "object") {
-    return null;
+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
+    };
   }
-  const c = content;
-  if (c.type === "text" && typeof c.text === "string") {
-    return sanitizeWireText(c.text);
+});
+
+// src/tui/completion.ts
+function longestCommonPrefix(names) {
+  if (names.length === 0) {
+    return "";
   }
-  if (typeof c.text === "string") {
-    return sanitizeWireText(c.text);
+  let prefix = names[0] ?? "";
+  for (let i = 1; i < names.length; i++) {
+    const n = names[i] ?? "";
+    let j = 0;
+    while (j < prefix.length && j < n.length && prefix[j] === n[j]) {
+      j += 1;
+    }
+    prefix = prefix.slice(0, j);
+    if (prefix.length === 0) {
+      break;
+    }
   }
-  return null;
+  return prefix;
 }
-function extractPromptText2(prompt) {
-  if (!Array.isArray(prompt)) {
+function computeTabCompletion(args) {
+  const { matches, firstLine: firstLine3 } = args;
+  if (matches.length === 0) {
     return null;
   }
-  const parts = [];
-  for (const block of prompt) {
-    const text = extractContentText(block);
-    if (text !== null) {
-      parts.push(text);
-    }
+  const space = firstLine3.indexOf(" ");
+  const typedPrefix = space === -1 ? firstLine3 : firstLine3.slice(0, space);
+  const tail = space === -1 ? "" : firstLine3.slice(space);
+  if (matches.length === 1) {
+    const name = matches[0] ?? "";
+    const suffix = tail.startsWith(" ") ? "" : " ";
+    return name + suffix + tail;
   }
-  if (parts.length === 0) {
+  const commonPrefix = longestCommonPrefix(matches);
+  if (commonPrefix.length <= typedPrefix.length) {
     return null;
   }
-  return parts.join("");
-}
-function readString(u, key) {
-  const v = u[key];
-  return typeof v === "string" ? v : void 0;
+  return commonPrefix + tail;
 }
-var STRIP_CONTROLS;
-var init_render_update = __esm({
-  "src/tui/render-update.ts"() {
+var init_completion = __esm({
+  "src/tui/completion.ts"() {
     "use strict";
-    STRIP_CONTROLS = /[\x00-\x08\x0b-\x1f\x7f]/g;
   }
 });
 
@@ -7693,7 +8196,7 @@ function formatBlock(text, prefix, bodyStyle, prefixStyle, sentBy, fillRow) {
   }
   return out;
 }
-function formatToolLine(state) {
+function formatToolLine2(state) {
   const initial = state.initialTitle;
   const latest = state.latestTitle;
   const initialLc = initial.toLowerCase();
@@ -8096,6 +8599,7 @@ async function runSession(term, config, opts, exitHint) {
   let initialModel;
   let initialMode;
   let initialCommands;
+  let initialUsage;
   let initialTurnStartedAt;
   if (ctx.sessionId === "__new__") {
     const hydraNewMeta = {};
@@ -8125,6 +8629,7 @@ async function runSession(term, config, opts, exitHint) {
     }
     initialModel = hydraMeta.currentModel;
     initialMode = hydraMeta.currentMode;
+    initialUsage = hydraMeta.currentUsage;
     initialTurnStartedAt = hydraMeta.turnStartedAt;
     if (hydraMeta.availableCommands) {
       initialCommands = normalizeAdvertisedCommands(hydraMeta.availableCommands);
@@ -8150,6 +8655,7 @@ async function runSession(term, config, opts, exitHint) {
     }
     initialModel = hydraMeta.currentModel;
     initialMode = hydraMeta.currentMode;
+    initialUsage = hydraMeta.currentUsage;
     initialTurnStartedAt = hydraMeta.turnStartedAt;
     if (hydraMeta.availableCommands) {
       initialCommands = normalizeAdvertisedCommands(hydraMeta.availableCommands);
@@ -8356,18 +8862,25 @@ async function runSession(term, config, opts, exitHint) {
     }
     return true;
   };
-  const headerName = resolvedAgentId || agentInfoName || "?";
+  const sessionbarAgent = resolvedAgentId || agentInfoName || "?";
+  const usage = { ...initialUsage ?? {} };
   screen.start();
-  screen.setHeader({
-    agent: headerName,
+  screen.setSessionbar({
+    agent: sessionbarAgent,
     cwd: resolvedCwd,
     sessionId: resolvedSessionId,
     title: resolvedTitle,
-    model: initialModel
+    model: initialModel,
+    usage: { ...usage }
   });
   if (initialMode) {
     screen.appendLines(formatEvent({ kind: "mode-changed", mode: initialMode }));
   }
+  void getPendingUpdate().then((info) => {
+    if (info) {
+      screen.notify(`\u2728 ${formatUpdateNoticeLine(info)}`, 3e4);
+    }
+  });
   let finishSession = null;
   const sessionDone = new Promise((resolve5) => {
     finishSession = resolve5;
@@ -8929,7 +9442,6 @@ async function runSession(term, config, opts, exitHint) {
       );
     }
   };
-  const usage = {};
   const toolStates = /* @__PURE__ */ new Map();
   const toolCallOrder = [];
   let toolsExpanded = false;
@@ -9012,7 +9524,7 @@ async function runSession(term, config, opts, exitHint) {
     for (const id of visibleIds) {
       const state = toolStates.get(id);
       if (state) {
-        lines.push(formatToolLine(state));
+        lines.push(formatToolLine2(state));
       }
     }
     screen.upsertLines("tools", lines);
@@ -9058,11 +9570,11 @@ async function runSession(term, config, opts, exitHint) {
     }
     if (event.kind === "session-info") {
       if (event.title !== void 0) {
-        screen.setHeader({ title: event.title });
+        screen.setSessionbar({ title: event.title });
       }
       if (event.agentId !== void 0 && event.agentId !== resolvedAgentId) {
         resolvedAgentId = event.agentId;
-        screen.setHeader({ agent: event.agentId });
+        screen.setSessionbar({ agent: event.agentId });
       }
       return;
     }
@@ -9085,7 +9597,7 @@ async function runSession(term, config, opts, exitHint) {
         changed = true;
       }
       if (changed) {
-        screen.setHeader({ usage: { ...usage } });
+        screen.setSessionbar({ usage: { ...usage } });
       }
       return;
     }
@@ -9136,7 +9648,7 @@ async function runSession(term, config, opts, exitHint) {
       return;
     }
     if (event.kind === "model-changed") {
-      screen.setHeader({ model: event.model });
+      screen.setSessionbar({ model: event.model });
     }
     const formatted = formatEvent(event);
     if (formatted.length > 0) {
@@ -9387,6 +9899,7 @@ var init_app = __esm({
     init_session();
     init_paths();
     init_hydra_version();
+    init_update_check();
     init_history();
     init_discovery();
     init_picker();
@@ -9425,6 +9938,7 @@ var KNOWN_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "foreground",
   "help",
   "info",
+  "json",
   "new",
   "reattach",
   "replace",
@@ -11700,6 +12214,7 @@ function constantTimeEqual(a, b) {
 // src/daemon/routes/sessions.ts
 init_config();
 init_bundle();
+init_transcript();
 init_types();
 init_hydra_version();
 import * as os3 from "os";
@@ -11782,6 +12297,24 @@ function registerSessionRoutes(app, manager, defaults) {
     );
     reply.code(200).send(bundle);
   });
+  app.get("/v1/sessions/:id/transcript", async (request, reply) => {
+    const raw = request.params.id;
+    const id = await manager.resolveCanonicalId(raw) ?? raw;
+    const exported = await manager.exportBundle(id);
+    if (!exported) {
+      reply.code(404).send({ error: "session not found" });
+      return;
+    }
+    const bundle = encodeBundle({
+      record: exported.record,
+      history: exported.history,
+      promptHistory: exported.promptHistory.length > 0 ? exported.promptHistory : void 0,
+      hydraVersion: HYDRA_VERSION,
+      machine: os3.hostname()
+    });
+    reply.header("Content-Type", "text/markdown; charset=utf-8");
+    reply.code(200).send(bundleToMarkdown(bundle));
+  });
   app.post("/v1/sessions/import", async (request, reply) => {
     const body = request.body ?? {};
     if (body.bundle === void 0) {
@@ -12096,11 +12629,18 @@ function registerAcpWsEndpoint(app, deps) {
         model: hydraMeta.model
       });
       const client = bindClientToSession(connection, session, state);
-      await session.attach(client, "full");
+      const { entries: replay } = await session.attach(client, "full");
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
         clientId: client.clientId
       });
+      setImmediate(() => {
+        void (async () => {
+          for (const note of replay) {
+            await connection.notify(note.method, note.params).catch(() => void 0);
+          }
+        })();
+      });
       return {
         sessionId: session.sessionId,
         _meta: buildResponseMeta(session)
@@ -12314,6 +12854,9 @@ function buildResponseMeta(session) {
   if (session.currentMode !== void 0) {
     ours.currentMode = session.currentMode;
   }
+  if (session.currentUsage !== void 0) {
+    ours.currentUsage = session.currentUsage;
+  }
   const commands = session.mergedAvailableCommands();
   if (commands.length > 0) {
     ours.availableCommands = commands;
@@ -13714,54 +14257,8 @@ function injectHydraMeta(msg, additions) {
   };
 }
 
-// src/core/update-check.ts
-init_hydra_version();
-var PKG_NAME = "@hydra-acp/cli";
-var cached;
-function disabled() {
-  if (process.env.NO_UPDATE_NOTIFIER === "1") {
-    return true;
-  }
-  if (process.argv.includes("--no-update-notifier")) {
-    return true;
-  }
-  return false;
-}
-async function getPendingUpdate() {
-  if (cached !== void 0) {
-    return cached;
-  }
-  if (disabled()) {
-    cached = null;
-    return cached;
-  }
-  try {
-    const mod = await import("update-notifier");
-    const updateNotifier = mod.default ?? mod;
-    const notifier = updateNotifier({
-      pkg: { name: PKG_NAME, version: HYDRA_VERSION },
-      updateCheckInterval: 1e3 * 60 * 60 * 24
-    });
-    const u = notifier.update;
-    if (u && typeof u.latest === "string" && typeof u.current === "string" && u.latest !== u.current) {
-      cached = {
-        current: u.current,
-        latest: u.latest,
-        type: typeof u.type === "string" ? u.type : "unknown"
-      };
-    } else {
-      cached = null;
-    }
-  } catch {
-    cached = null;
-  }
-  return cached;
-}
-function formatUpdateNoticeLine(info) {
-  return `hydra-acp ${info.latest} available (current ${info.current}) \xB7 run: npm update -g ${PKG_NAME}`;
-}
-
 // src/cli.ts
+init_update_check();
 var suppressUpdateNotice = false;
 async function main() {
   const argv = process.argv.slice(2);
@@ -13872,7 +14369,10 @@ async function main() {
     case "sessions": {
       const sub = positional[1];
       if (sub === void 0 || sub === "list") {
-        await runSessionsList({ all: flags.all === true });
+        await runSessionsList({
+          all: flags.all === true,
+          json: flags.json === true
+        });
         return;
       }
       if (sub === "kill") {
@@ -13888,6 +14388,11 @@ async function main() {
         await runSessionsExport(positional[2], out);
         return;
       }
+      if (sub === "transcript") {
+        const out = resolveOption(flags, "out");
+        await runSessionsTranscript(positional[2], out);
+        return;
+      }
       if (sub === "import") {
         const cwd = resolveOption(flags, "cwd");
         await runSessionsImport(positional[2], {
@@ -14031,11 +14536,14 @@ function printHelp() {
       "  hydra-acp daemon start [--foreground]   Start daemon (detached by default; --foreground to attach)",
       "  hydra-acp daemon stop|restart|status",
       "  hydra-acp daemon logs [-f] [-n N]  Tail or follow the daemon log",
-      "  hydra-acp sessions [list] [--all]  List sessions (live + 20 most-recent cold; --all for everything)",
+      "  hydra-acp sessions [list] [--all] [--json]",
+      "                                     List sessions (live + 20 most-recent cold; --all for everything; --json emits the raw daemon response as JSON for scripts)",
       "  hydra-acp sessions kill <id>       Demote a live session to cold (keeps the on-disk record)",
       "  hydra-acp sessions remove <id>     Remove a session entirely (live or cold)",
       "  hydra-acp sessions export <id> [--out <file>|.]",
       "                                     Write a session bundle to <file>, to a default-named file when --out=., or to stdout",
+      "  hydra-acp sessions transcript <id>|<file> [--out <file>|.]",
+      "                                     Render a session as a markdown transcript. Accepts a session id (renders via the daemon) or a local .hydra bundle file (rendered in-process). Writes to <file>, to a default-named file when --out=., or to stdout",
       "  hydra-acp sessions import <file>|- [--replace] [--cwd <path>] [--info]",
       "                                     Import a bundle from <file> or stdin (-); --replace overwrites a lineage match (kills it if live); --cwd overrides the bundle's recorded working directory; --info prints the bundle's meta without importing",
       "  hydra-acp extensions list                   List configured extensions and live state",