@hydra-acp/cli 0.1.1 → 0.1.3

package/dist/cli.js

@@ -17,6 +17,11 @@ function hydraHome() {
   if (override && override.length > 0) {
     return path.resolve(override);
   }
+  if (process.env.VITEST) {
+    throw new Error(
+      "HYDRA_ACP_HOME is unset under VITEST; vitest.setup.ts must run first"
+    );
+  }
   return path.join(os.homedir(), ".hydra-acp");
 }
 var ROOT_ENV, paths;
@@ -34,11 +39,17 @@ var init_paths = __esm({
       agentsDir: () => path.join(hydraHome(), "agents"),
       agentDir: (id) => path.join(hydraHome(), "agents", id),
       sessionsDir: () => path.join(hydraHome(), "sessions"),
-      sessionFile: (id) => path.join(hydraHome(), "sessions", `${id}.json`),
+      // One directory per session id under sessions/. Co-locates the
+      // session record, its transcript, and any future per-session state
+      // (uploads, scratch, etc.) so the lifecycle is just "rm -rf the dir".
+      sessionDir: (id) => path.join(hydraHome(), "sessions", id),
+      sessionFile: (id) => path.join(hydraHome(), "sessions", id, "meta.json"),
+      historyFile: (id) => path.join(hydraHome(), "sessions", id, "history.jsonl"),
       extensionsDir: () => path.join(hydraHome(), "extensions"),
       extensionLogFile: (name) => path.join(hydraHome(), "extensions", `${name}.log`),
       extensionPidFile: (name) => path.join(hydraHome(), "extensions", `${name}.pid`),
-      tuiHistoryFile: () => path.join(hydraHome(), "tui-history")
+      tuiHistoryFile: (id) => path.join(hydraHome(), "sessions", id, "prompt-history"),
+      tuiLogFile: () => path.join(hydraHome(), "tui.log")
     };
   }
 });
@@ -152,7 +163,11 @@ var init_config = __esm({
       // /clear, ^L, resize — bypass this throttle. Default 1000 (1 Hz) keeps
       // CPU low during heavy streaming; bump to 250 for 4 Hz, 100 for ~10 Hz,
       // or 0 to disable throttling entirely.
-      repaintThrottleMs: z.number().int().nonnegative().default(1e3)
+      repaintThrottleMs: z.number().int().nonnegative().default(1e3),
+      // Cap on logical lines retained in the in-memory scrollback render
+      // buffer. Oldest lines are dropped on overflow. The on-disk session
+      // history is unaffected; this only bounds the TUI's local view buffer.
+      maxScrollbackLines: z.number().int().positive().default(1e4)
     });
     ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
     ExtensionBody = z.object({
@@ -177,7 +192,7 @@ var init_config = __esm({
       // recency and truncated to this count. `--all` overrides in the CLI.
       sessionListColdLimit: z.number().int().nonnegative().default(20),
       extensions: z.record(ExtensionName, ExtensionBody).default({}),
-      tui: TuiConfig.default({ repaintThrottleMs: 1e3 })
+      tui: TuiConfig.default({ repaintThrottleMs: 1e3, maxScrollbackLines: 1e4 })
     });
   }
 });
@@ -215,6 +230,35 @@ function extractHydraMeta(meta) {
       out.resume = parsed.data;
     }
   }
+  if (typeof obj.currentModel === "string") {
+    out.currentModel = obj.currentModel;
+  }
+  if (typeof obj.currentMode === "string") {
+    out.currentMode = obj.currentMode;
+  }
+  if (typeof obj.turnStartedAt === "number" && obj.turnStartedAt > 0) {
+    out.turnStartedAt = obj.turnStartedAt;
+  }
+  if (Array.isArray(obj.availableCommands)) {
+    const cmds = [];
+    for (const raw of obj.availableCommands) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        continue;
+      }
+      const c = raw;
+      if (typeof c.name !== "string") {
+        continue;
+      }
+      const cmd = { name: c.name };
+      if (typeof c.description === "string") {
+        cmd.description = c.description;
+      }
+      cmds.push(cmd);
+    }
+    if (cmds.length > 0) {
+      out.availableCommands = cmds;
+    }
+  }
   return out;
 }
 function mergeMeta(passthrough, ours) {
@@ -502,6 +546,25 @@ function withCode(err, code) {
   err.code = code;
   return err;
 }
+function isStateUpdate(method, params) {
+  if (method !== "session/update") {
+    return false;
+  }
+  const obj = params ?? {};
+  const kind = obj.update?.sessionUpdate;
+  return typeof kind === "string" && STATE_UPDATE_KINDS.has(kind);
+}
+function sameAdvertisedCommands(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i]?.name !== b[i]?.name || a[i]?.description !== b[i]?.description) {
+      return false;
+    }
+  }
+  return true;
+}
 function captureInternalChunk(capture, params) {
   const obj = params ?? {};
   const update = obj.update ?? {};
@@ -564,7 +627,7 @@ function firstLine(text, max) {
   }
   return void 0;
 }
-var HYDRA_ID_ALPHABET, generateHydraId, HYDRA_SESSION_PREFIX, Session;
+var HYDRA_ID_ALPHABET, generateHydraId, HYDRA_SESSION_PREFIX, Session, STATE_UPDATE_KINDS;
 var init_session = __esm({
   "src/core/session.ts"() {
     "use strict";
@@ -586,14 +649,26 @@ var init_session = __esm({
       agentMeta;
       agentArgs;
       title;
+      // Snapshot state delivered to attaching clients via the attach
+      // response _meta rather than via history replay (which would be
+      // stale-prone for snapshot-shaped events).
+      currentModel;
+      currentMode;
       updatedAt;
       clients = /* @__PURE__ */ new Map();
       history = [];
+      historyStore;
       promptQueue = [];
       promptInFlight = false;
       closed = false;
       closeHandlers = [];
       titleHandlers = [];
+      // Subscribers notified after every entry that's actually persisted to
+      // history (skipping snapshot-shaped events filtered by
+      // recordAndBroadcast). The HTTP /v1/sessions/:id/history?follow=1
+      // endpoint uses this to tail a live session's conversation stream
+      // without participating in turns or prompts.
+      broadcastHandlers = [];
       // True once we've observed our first session/prompt; gates the
       // first-prompt-seeded title so subsequent prompts don't churn it.
       firstPromptSeeded = false;
@@ -613,12 +688,18 @@ var init_session = __esm({
       idleTimer;
       spawnReplacementAgent;
       agentChangeHandlers = [];
-      // Last available_commands_update we observed from the agent. Stored so
-      // we can re-broadcast a merged (hydra ∪ agent) list whenever either
-      // half changes — most importantly when a fresh client attaches and
-      // replays history, since the in-cache update is the daemon's merged
-      // form (the agent's raw form is never broadcast).
+      // Last available_commands_update we observed from the agent. Stored
+      // so we can re-broadcast a merged (hydra ∪ agent) list whenever
+      // either half changes, and persisted to meta.json so a fresh attach
+      // can deliver the merged list via _meta without depending on history
+      // replay.
       agentAdvertisedCommands = [];
+      // Persist hooks for snapshot-shaped state. SessionManager hooks these
+      // to mirror changes into meta.json so cold-resurrect attaches can
+      // surface the latest snapshot via the attach response _meta.
+      agentCommandsHandlers = [];
+      modelHandlers = [];
+      modeHandlers = [];
       constructor(init) {
         this.sessionId = init.sessionId ?? `${HYDRA_SESSION_PREFIX}${generateHydraId()}`;
         this.cwd = init.cwd;
@@ -628,11 +709,22 @@ var init_session = __esm({
         this.agentMeta = init.agentMeta;
         this.agentArgs = init.agentArgs;
         this.title = init.title;
+        this.currentModel = init.currentModel;
+        this.currentMode = init.currentMode;
+        if (init.agentCommands && init.agentCommands.length > 0) {
+          this.agentAdvertisedCommands = [...init.agentCommands];
+        }
         this.idleTimeoutMs = init.idleTimeoutMs ?? 0;
         this.spawnReplacementAgent = init.spawnReplacementAgent;
+        if (init.firstPromptSeeded) {
+          this.firstPromptSeeded = true;
+        }
+        this.historyStore = init.historyStore;
+        if (init.seedHistory && init.seedHistory.length > 0) {
+          this.history = [...init.seedHistory];
+        }
         this.updatedAt = Date.now();
         this.wireAgent(this.agent);
-        this.broadcastMergedCommands();
       }
       broadcastMergedCommands() {
         const merged = [
@@ -661,8 +753,15 @@ var init_session = __esm({
           }
           const agentCmds = extractAdvertisedCommands(params);
           if (agentCmds !== null) {
-            this.agentAdvertisedCommands = agentCmds;
-            this.broadcastMergedCommands();
+            this.setAgentAdvertisedCommands(agentCmds);
+            return;
+          }
+          if (this.maybeApplyAgentModel(params)) {
+            this.recordAndBroadcast("session/update", params);
+            return;
+          }
+          if (this.maybeApplyAgentMode(params)) {
+            this.recordAndBroadcast("session/update", params);
             return;
           }
           this.maybeApplyAgentSessionInfo(params);
@@ -684,6 +783,50 @@ var init_session = __esm({
       get attachedCount() {
         return this.clients.size;
       }
+      // Wall-clock when the in-flight agent turn began, or undefined when
+      // idle. Derived from history: the most recent prompt_received without
+      // a later turn_complete is the outstanding turn, and its recordedAt
+      // is when the prompt was first broadcast. Used by buildResponseMeta
+      // so a fresh client reattaching mid-turn boots up with the busy
+      // banner showing real elapsed time.
+      get turnStartedAt() {
+        for (let i = this.history.length - 1; i >= 0; i--) {
+          const entry = this.history[i];
+          if (!entry) {
+            continue;
+          }
+          const params = entry.params;
+          const kind = params?.update?.sessionUpdate;
+          if (kind === "turn_complete") {
+            return void 0;
+          }
+          if (kind === "prompt_received") {
+            return entry.recordedAt;
+          }
+        }
+        return void 0;
+      }
+      // Snapshot of the current in-memory replay history. Used by the
+      // HTTP history endpoint to deliver the "what's accumulated so far"
+      // prefix before optionally tailing with onBroadcast. Returns a copy
+      // so callers can't mutate our cache.
+      getHistorySnapshot() {
+        return [...this.history];
+      }
+      // Subscribe to recordable broadcast entries — fires once per entry
+      // that lands in history (so snapshot-shaped session_info/model/mode/
+      // available_commands updates do NOT trigger this; they're broadcast
+      // live but not recorded). Returns an unsubscribe function the caller
+      // must invoke when done.
+      onBroadcast(handler) {
+        this.broadcastHandlers.push(handler);
+        return () => {
+          const i = this.broadcastHandlers.indexOf(handler);
+          if (i >= 0) {
+            this.broadcastHandlers.splice(i, 1);
+          }
+        };
+      }
       attach(client, historyPolicy) {
         if (this.closed) {
           throw withCode(
@@ -740,13 +883,19 @@ var init_session = __esm({
         this.broadcastPromptReceived(client, params);
         this.maybeSeedTitleFromPrompt(params);
         return this.enqueuePrompt(async () => {
-          const response = await this.agent.connection.request(
-            "session/prompt",
-            {
-              ...params,
-              sessionId: this.upstreamSessionId
-            }
-          );
+          let response;
+          try {
+            response = await this.agent.connection.request(
+              "session/prompt",
+              {
+                ...params,
+                sessionId: this.upstreamSessionId
+              }
+            );
+          } catch (err) {
+            this.broadcastTurnComplete(client.clientId, { stopReason: "error" });
+            throw err;
+          }
           this.broadcastTurnComplete(client.clientId, response);
           return response;
         });
@@ -834,6 +983,13 @@ var init_session = __esm({
           return;
         }
         this.cancelIdleTimer();
+        if (opts.regenTitle && this.firstPromptSeeded) {
+          const timeoutMs = opts.regenTitleTimeoutMs ?? 5e3;
+          await Promise.race([
+            this.runTitleRegen().catch(() => void 0),
+            new Promise((r) => setTimeout(r, timeoutMs).unref?.())
+          ]);
+        }
         await this.agent.kill().catch(() => void 0);
         this.markClosed({ deleteRecord: opts.deleteRecord ?? false });
       }
@@ -882,13 +1038,98 @@ var init_session = __esm({
         }
         const promptParams = params ?? {};
         const text = extractPromptText(promptParams.prompt);
-        const seed = firstLine(text, 80);
+        const seed = firstLine(text, 200);
         if (!seed) {
           return;
         }
         this.firstPromptSeeded = true;
         this.setTitle(seed);
       }
+      // Apply an agent-emitted current_model_update. Returns true if the
+      // notification was a model update (caller still needs to broadcast
+      // it). Returns false otherwise so the caller can try the next kind.
+      maybeApplyAgentModel(params) {
+        const obj = params ?? {};
+        const update = obj.update ?? {};
+        if (update.sessionUpdate !== "current_model_update") {
+          return false;
+        }
+        const raw = typeof update.currentModel === "string" ? update.currentModel : typeof update.model === "string" ? update.model : void 0;
+        if (raw === void 0) {
+          return true;
+        }
+        const trimmed = raw.trim();
+        if (!trimmed || trimmed === this.currentModel) {
+          return true;
+        }
+        this.currentModel = trimmed;
+        for (const handler of this.modelHandlers) {
+          try {
+            handler(trimmed);
+          } catch {
+          }
+        }
+        return true;
+      }
+      maybeApplyAgentMode(params) {
+        const obj = params ?? {};
+        const update = obj.update ?? {};
+        if (update.sessionUpdate !== "current_mode_update") {
+          return false;
+        }
+        const raw = typeof update.currentMode === "string" ? update.currentMode : typeof update.mode === "string" ? update.mode : void 0;
+        if (raw === void 0) {
+          return true;
+        }
+        const trimmed = raw.trim();
+        if (!trimmed || trimmed === this.currentMode) {
+          return true;
+        }
+        this.currentMode = trimmed;
+        for (const handler of this.modeHandlers) {
+          try {
+            handler(trimmed);
+          } catch {
+          }
+        }
+        return true;
+      }
+      // Update the cached agent command list, fire persist handlers, and
+      // broadcast the merged list to attached clients. Idempotent on a
+      // structurally identical list so we don't churn meta.json on noisy
+      // re-emissions.
+      setAgentAdvertisedCommands(commands) {
+        if (sameAdvertisedCommands(this.agentAdvertisedCommands, commands)) {
+          this.broadcastMergedCommands();
+          return;
+        }
+        this.agentAdvertisedCommands = commands;
+        for (const handler of this.agentCommandsHandlers) {
+          try {
+            handler(commands);
+          } catch {
+          }
+        }
+        this.broadcastMergedCommands();
+      }
+      // Subscribe to snapshot-state updates. SessionManager wires these to
+      // persist the new value into meta.json so cold resurrect can restore
+      // them via the attach response _meta.
+      onAgentCommandsChange(handler) {
+        this.agentCommandsHandlers.push(handler);
+      }
+      onModelChange(handler) {
+        this.modelHandlers.push(handler);
+      }
+      onModeChange(handler) {
+        this.modeHandlers.push(handler);
+      }
+      // Returns a freshly merged command list (hydra ∪ agent) for callers
+      // that need a snapshot — notably acp-ws.ts's buildResponseMeta when
+      // assembling the attach response.
+      mergedAvailableCommands() {
+        return [...hydraCommandsAsAdvertised(), ...this.agentAdvertisedCommands];
+      }
       // Pick up an agent-emitted session_info_update and store its title
       // as our canonical record. The notification is also forwarded to
       // clients via the surrounding recordAndBroadcast call. Authoritative
@@ -1176,7 +1417,8 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         }
         this.idleTimer = setTimeout(() => {
           this.idleTimer = void 0;
-          void this.close({ deleteRecord: false }).catch(() => void 0);
+          const opts = this.firstPromptSeeded ? { deleteRecord: false, regenTitle: true } : { deleteRecord: true };
+          void this.close(opts).catch(() => void 0);
         }, this.idleTimeoutMs);
         if (typeof this.idleTimer.unref === "function") {
           this.idleTimer.unref();
@@ -1199,9 +1441,34 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       }
       recordAndBroadcast(method, params, excludeClientId) {
         const rewritten = this.rewriteForClient(params);
-        this.history.push({ method, params: rewritten, recordedAt: Date.now() });
-        if (this.history.length > 1e3) {
-          this.history = this.history.slice(-500);
+        const recordable = !isStateUpdate(method, rewritten);
+        if (recordable) {
+          const entry = {
+            method,
+            params: rewritten,
+            recordedAt: Date.now()
+          };
+          this.history.push(entry);
+          let trimmed = false;
+          if (this.history.length > 1e3) {
+            this.history = this.history.slice(-500);
+            trimmed = true;
+          }
+          if (this.historyStore) {
+            if (trimmed) {
+              void this.historyStore.rewrite(this.sessionId, [...this.history]).catch(() => void 0);
+            } else {
+              void this.historyStore.append(this.sessionId, entry).catch(
+                () => void 0
+              );
+            }
+          }
+          for (const handler of this.broadcastHandlers) {
+            try {
+              handler(entry);
+            } catch {
+            }
+          }
         }
         this.updatedAt = Date.now();
         for (const client of this.clients.values()) {
@@ -1297,6 +1564,12 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         }
       }
     };
+    STATE_UPDATE_KINDS = /* @__PURE__ */ new Set([
+      "session_info_update",
+      "current_model_update",
+      "current_mode_update",
+      "available_commands_update"
+    ]);
   }
 });
 
@@ -1430,6 +1703,147 @@ var init_daemon_bootstrap = __esm({
   }
 });
 
+// src/cli/session-row.ts
+function toRow(s, now = Date.now()) {
+  return {
+    session: stripHydraSessionPrefix(s.sessionId),
+    upstream: s.upstreamSessionId ?? "-",
+    status: (s.status ?? "live").toUpperCase(),
+    clients: s.status === "cold" ? "-" : String(s.attachedClients),
+    agent: s.agentId ?? "?",
+    age: formatRelativeAge(s.updatedAt, now),
+    title: s.title ?? "-",
+    cwd: s.cwd
+  };
+}
+function computeWidths(rows) {
+  return {
+    session: maxLen(HEADER.session, rows.map((r) => r.session)),
+    upstream: maxLen(HEADER.upstream, rows.map((r) => r.upstream)),
+    status: maxLen(HEADER.status, rows.map((r) => r.status)),
+    clients: maxLen(HEADER.clients, rows.map((r) => r.clients)),
+    agent: maxLen(HEADER.agent, rows.map((r) => r.agent)),
+    age: maxLen(HEADER.age, rows.map((r) => r.age)),
+    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) {
+  const fixed = [
+    r.session.padEnd(w.session),
+    r.upstream.padEnd(w.upstream),
+    r.status.padEnd(w.status),
+    r.clients.padStart(w.clients),
+    r.agent.padEnd(w.agent),
+    r.age.padStart(w.age)
+  ].join(SEP);
+  if (maxWidth === void 0) {
+    return [fixed, r.title.padEnd(w.title), r.cwd].join(SEP);
+  }
+  const titleCap = Math.min(w.title, TITLE_MAX_WIDTH);
+  const budget = maxWidth - fixed.length - SEP.length;
+  if (budget <= 0) {
+    return fixed.slice(0, maxWidth);
+  }
+  const titleNatural = Math.min(r.title.length, titleCap);
+  let titleAlloc = titleNatural + SEP.length + MIN_CWD <= budget ? titleCap : Math.max(0, budget - SEP.length - MIN_CWD);
+  titleAlloc = Math.min(titleAlloc, Math.max(0, budget - SEP.length - 1));
+  const titleCell = truncateRight(r.title, titleAlloc).padEnd(titleAlloc);
+  const cwdBudget = Math.max(0, budget - titleAlloc - SEP.length);
+  const cwdCell = truncateMiddle(r.cwd, cwdBudget);
+  return [fixed, titleCell, cwdCell].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, MIN_CWD, TITLE_MAX_WIDTH;
+var init_session_row = __esm({
+  "src/cli/session-row.ts"() {
+    "use strict";
+    init_session();
+    HEADER = {
+      session: "SESSION",
+      upstream: "UPSTREAM",
+      status: "STATUS",
+      clients: "CLIENTS",
+      agent: "AGENT",
+      age: "AGE",
+      title: "TITLE",
+      cwd: "CWD"
+    };
+    SEP = "  ";
+    MIN_CWD = 8;
+    TITLE_MAX_WIDTH = 40;
+  }
+});
+
 // src/cli/commands/sessions.ts
 async function runSessionsList(opts = {}) {
   const config = await loadConfig();
@@ -1465,44 +1879,13 @@ async function runSessionsList(opts = {}) {
     visible = [...sorted.slice(0, liveCount), ...coldSlice];
     truncated = hiddenCold;
   }
-  const rows = visible.map((s) => ({
-    session: stripHydraSessionPrefix(s.sessionId),
-    upstream: s.upstreamSessionId ?? "-",
-    status: (s.status ?? "live").toUpperCase(),
-    clients: s.status === "cold" ? "-" : String(s.attachedClients),
-    agent: s.agentId ?? "?",
-    title: s.title ?? "-",
-    cwd: s.cwd
-  }));
-  const header = {
-    session: "SESSION",
-    upstream: "UPSTREAM",
-    status: "STATUS",
-    clients: "CLIENTS",
-    agent: "AGENT",
-    title: "TITLE",
-    cwd: "CWD"
-  };
-  const widths = {
-    session: maxLen(header.session, rows.map((r) => r.session)),
-    upstream: maxLen(header.upstream, rows.map((r) => r.upstream)),
-    status: maxLen(header.status, rows.map((r) => r.status)),
-    clients: maxLen(header.clients, rows.map((r) => r.clients)),
-    agent: maxLen(header.agent, rows.map((r) => r.agent)),
-    title: maxLen(header.title, rows.map((r) => r.title))
-  };
-  const formatRow2 = (r) => [
-    r.session.padEnd(widths.session),
-    r.upstream.padEnd(widths.upstream),
-    r.status.padEnd(widths.status),
-    r.clients.padStart(widths.clients),
-    r.agent.padEnd(widths.agent),
-    r.title.padEnd(widths.title),
-    r.cwd
-  ].join("  ");
-  process.stdout.write(formatRow2(header) + "\n");
+  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;
+  process.stdout.write(formatRow(HEADER, widths, maxWidth) + "\n");
   for (const r of rows) {
-    process.stdout.write(formatRow2(r) + "\n");
+    process.stdout.write(formatRow(r, widths, maxWidth) + "\n");
   }
   if (truncated > 0) {
     process.stdout.write(
@@ -1512,15 +1895,6 @@ async function runSessionsList(opts = {}) {
     );
   }
 }
-function maxLen(headerCell, values) {
-  let max = headerCell.length;
-  for (const v of values) {
-    if (v.length > max) {
-      max = v.length;
-    }
-  }
-  return max;
-}
 async function runSessionsKill(id) {
   if (!id) {
     process.stderr.write("Usage: hydra-acp sessions kill <session-id>\n");
@@ -1528,6 +1902,25 @@ async function runSessionsKill(id) {
   }
   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 runSessionsRm(id) {
+  if (!id) {
+    process.stderr.write("Usage: hydra-acp sessions rm <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}` }
@@ -1537,7 +1930,7 @@ async function runSessionsKill(id) {
 `);
     process.exit(1);
   }
-  process.stdout.write(`Killed ${id}
+  process.stdout.write(`Removed ${id}
 `);
 }
 function httpBase(host, port, tls) {
@@ -1548,17 +1941,252 @@ var init_sessions = __esm({
   "src/cli/commands/sessions.ts"() {
     "use strict";
     init_config();
-    init_session();
+    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((resolve2, reject) => {
+    const ws = new WebSocket(url, subprotocols);
+    const onOpen = () => {
+      ws.off("error", onError);
+      resolve2(wsToMessageStream(ws));
+    };
+    const onError = (err) => {
+      ws.off("open", onOpen);
+      reject(err);
+    };
+    ws.once("open", onOpen);
+    ws.once("error", onError);
+  });
+}
+var BACKOFF_INITIAL_MS, BACKOFF_MAX_MS, BACKOFF_MULTIPLIER, MAX_RECONNECT_ATTEMPTS, ResilientWsStream;
+var init_resilient_ws = __esm({
+  "src/shim/resilient-ws.ts"() {
+    "use strict";
+    init_ws_stream();
+    init_types();
+    BACKOFF_INITIAL_MS = 200;
+    BACKOFF_MAX_MS = 5e3;
+    BACKOFF_MULTIPLIER = 2;
+    MAX_RECONNECT_ATTEMPTS = 60;
+    ResilientWsStream = class {
+      constructor(opts) {
+        this.opts = opts;
+      }
+      opts;
+      current;
+      outboundQueue = [];
+      messageHandlers = [];
+      closeHandlers = [];
+      destroyed = false;
+      firstConnect = true;
+      reconnectInFlight;
+      connectGate;
+      releaseConnectGate;
+      pendingRequests = /* @__PURE__ */ new Map();
+      async start() {
+        await this.connectWithRetry();
+      }
+      onMessage(handler) {
+        this.messageHandlers.push(handler);
+      }
+      onClose(handler) {
+        this.closeHandlers.push(handler);
+      }
+      async send(message) {
+        if (this.destroyed) {
+          throw new Error("resilient ws stream is destroyed");
+        }
+        if (this.connectGate || !this.current) {
+          this.outboundQueue.push(message);
+          return;
+        }
+        try {
+          await this.current.send(message);
+        } catch (err) {
+          this.outboundQueue.push(message);
+          this.scheduleReconnect(err);
+        }
+      }
+      // Send a request directly and resolve when the matching response arrives
+      // on the same connection. Used by onConnect handlers to await replay-attach
+      // responses before letting the outbound queue drain. Bypasses the
+      // connectGate intentionally.
+      async request(message) {
+        if (this.destroyed) {
+          throw new Error("resilient ws stream is destroyed");
+        }
+        if (!this.current) {
+          throw new Error("resilient ws stream not connected");
+        }
+        const id = message.id;
+        const promise = new Promise((resolve2, reject) => {
+          this.pendingRequests.set(id, { resolve: resolve2, reject });
+        });
+        try {
+          await this.current.send(message);
+        } catch (err) {
+          this.pendingRequests.delete(id);
+          throw err;
+        }
+        return promise;
+      }
+      async close() {
+        this.destroyed = true;
+        if (this.current) {
+          await this.current.close().catch(() => void 0);
+        }
+        for (const handler of this.closeHandlers) {
+          handler();
+        }
+      }
+      async connectWithRetry() {
+        let attempt = 0;
+        let backoff = BACKOFF_INITIAL_MS;
+        while (!this.destroyed) {
+          try {
+            const stream = await openWs(this.opts.url, this.opts.subprotocols);
+            this.bindStream(stream);
+            const wasFirst = this.firstConnect;
+            this.firstConnect = false;
+            this.connectGate = new Promise((resolve2) => {
+              this.releaseConnectGate = resolve2;
+            });
+            try {
+              if (this.opts.onConnect) {
+                try {
+                  await this.opts.onConnect(wasFirst);
+                } catch (err) {
+                  this.log(
+                    `hydra-acp: post-connect handler failed: ${err.message}`
+                  );
+                }
+              }
+            } finally {
+              this.releaseConnectGate?.();
+              this.releaseConnectGate = void 0;
+              this.connectGate = void 0;
+            }
+            await this.flushQueue();
+            return;
+          } catch (err) {
+            attempt += 1;
+            if (this.opts.onConnectFailure) {
+              this.opts.onConnectFailure(err);
+            }
+            if (attempt >= MAX_RECONNECT_ATTEMPTS) {
+              throw new Error(
+                `hydra-acp: gave up reconnecting after ${attempt} attempts: ${err.message}`
+              );
+            }
+            this.log(
+              `hydra-acp: connect attempt ${attempt} failed (${err.message}); retrying in ${backoff}ms`
+            );
+            await sleep3(backoff);
+            backoff = Math.min(backoff * BACKOFF_MULTIPLIER, BACKOFF_MAX_MS);
+          }
+        }
+      }
+      bindStream(stream) {
+        this.current = stream;
+        stream.onMessage((msg) => {
+          if (isResponse(msg)) {
+            const pending = this.pendingRequests.get(msg.id);
+            if (pending) {
+              this.pendingRequests.delete(msg.id);
+              pending.resolve(msg);
+            }
+          }
+          for (const handler of this.messageHandlers) {
+            handler(msg);
+          }
+        });
+        stream.onClose((err) => {
+          if (this.destroyed) {
+            return;
+          }
+          this.current = void 0;
+          if (this.pendingRequests.size > 0) {
+            const reason = err ?? new Error("ws closed before response");
+            for (const { reject } of this.pendingRequests.values()) {
+              reject(reason);
+            }
+            this.pendingRequests.clear();
+          }
+          this.scheduleReconnect(err);
+        });
+      }
+      async flushQueue() {
+        if (!this.current) {
+          return;
+        }
+        const queue = this.outboundQueue;
+        this.outboundQueue = [];
+        for (const msg of queue) {
+          try {
+            await this.current.send(msg);
+          } catch (err) {
+            this.outboundQueue.unshift(msg);
+            this.scheduleReconnect(err);
+            return;
+          }
+        }
+      }
+      scheduleReconnect(err) {
+        if (this.destroyed || this.reconnectInFlight) {
+          return;
+        }
+        this.log(
+          `hydra-acp: connection lost (${err?.message ?? "no error"}); reconnecting...`
+        );
+        if (this.opts.onDisconnect) {
+          try {
+            this.opts.onDisconnect(err);
+          } catch (hookErr) {
+            this.log(
+              `hydra-acp: onDisconnect handler threw: ${hookErr.message}`
+            );
+          }
+        }
+        this.reconnectInFlight = (async () => {
+          try {
+            await this.connectWithRetry();
+          } catch (final) {
+            for (const handler of this.closeHandlers) {
+              handler(final);
+            }
+            this.destroyed = true;
+          } finally {
+            this.reconnectInFlight = void 0;
+          }
+        })();
+      }
+      log(line) {
+        if (this.opts.log) {
+          this.opts.log(line);
+          return;
+        }
+        process.stderr.write(`${line}
+`);
+      }
+    };
   }
 });
 
 // src/tui/history.ts
-import { promises as fs8 } from "fs";
+import { promises as fs10 } from "fs";
 import * as path4 from "path";
 async function loadHistory(file) {
   let text;
   try {
-    text = await fs8.readFile(file, "utf8");
+    text = await fs10.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return [];
@@ -1598,9 +2226,9 @@ function appendEntry(history, entry) {
   return out;
 }
 async function saveHistory(file, history) {
-  await fs8.mkdir(path4.dirname(file), { recursive: true });
+  await fs10.mkdir(path4.dirname(file), { recursive: true });
   const lines = history.map((entry) => JSON.stringify(entry));
-  await fs8.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
+  await fs10.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
 }
 var HISTORY_CAP;
 var init_history = __esm({
@@ -1641,6 +2269,26 @@ async function listSessions(config, opts = {}, fetchImpl = fetch) {
     title: s.title
   }));
 }
+async function killSession(config, id, fetchImpl = fetch) {
+  const base = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetchImpl(`${base}/v1/sessions/${id}/kill`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${config.daemon.authToken}` }
+  });
+  if (!response.ok && response.status !== 204 && response.status !== 404) {
+    throw new Error(`daemon returned HTTP ${response.status}`);
+  }
+}
+async function deleteSession(config, id, fetchImpl = fetch) {
+  const base = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetchImpl(`${base}/v1/sessions/${id}`, {
+    method: "DELETE",
+    headers: { Authorization: `Bearer ${config.daemon.authToken}` }
+  });
+  if (!response.ok && response.status !== 204 && response.status !== 404) {
+    throw new Error(`daemon returned HTTP ${response.status}`);
+  }
+}
 function pickMostRecent(sessions, cwd) {
   const matching = sessions.filter((s) => s.cwd === cwd);
   if (matching.length === 0) {
@@ -1668,147 +2316,401 @@ async function pickSession(term, opts) {
   if (opts.sessions.length === 0) {
     return { kind: "new" };
   }
-  const score = (s) => {
-    if (s.status !== "live") {
-      return 0;
+  const sortSessions = (sessions) => {
+    const score = (s) => {
+      if (s.status !== "live") {
+        return 0;
+      }
+      return s.cwd === opts.cwd ? 2 : 1;
+    };
+    return [...sessions].sort((a, b) => {
+      const tier = score(b) - score(a);
+      if (tier !== 0) {
+        return tier;
+      }
+      return b.updatedAt.localeCompare(a.updatedAt);
+    });
+  };
+  let visible = sortSessions(opts.sessions);
+  let rows = visible.map((s) => toRow(s, Date.now()));
+  let widths = computeWidths(rows);
+  let total = 1 + visible.length;
+  let selectedIdx = 0;
+  let scrollOffset = 0;
+  let mode = "normal";
+  let pendingAction = null;
+  let transientStatus = null;
+  let termHeight = readTermHeight(term);
+  let termWidth = readTermWidth(term);
+  let viewportSize = 0;
+  let newSessionLabel = "";
+  let headerLine = "";
+  let sessionLines = [];
+  let startRow = 1;
+  const computeLayout = () => {
+    termHeight = readTermHeight(term);
+    termWidth = readTermWidth(term);
+    const maxViewportRows = Math.max(3, termHeight - 6);
+    viewportSize = Math.min(visible.length, maxViewportRows);
+    const rowMaxWidth = Math.max(10, termWidth - ROW_PREFIX_WIDTH);
+    newSessionLabel = formatNewSessionLabel(opts.cwd, rowMaxWidth);
+    headerLine = formatRow(HEADER, widths, rowMaxWidth);
+    sessionLines = rows.map((r) => formatRow(r, widths, rowMaxWidth));
+  };
+  const rebuildRows = () => {
+    rows = visible.map((s) => toRow(s, Date.now()));
+    widths = computeWidths(rows);
+    total = 1 + visible.length;
+    computeLayout();
+  };
+  const adjustScroll = () => {
+    if (selectedIdx === 0) {
+      return;
+    }
+    const sessionIdx = selectedIdx - 1;
+    if (sessionIdx < scrollOffset) {
+      scrollOffset = sessionIdx;
+    } else if (sessionIdx >= scrollOffset + viewportSize) {
+      scrollOffset = sessionIdx - viewportSize + 1;
+    } else if (scrollOffset + viewportSize > visible.length) {
+      scrollOffset = Math.max(0, visible.length - viewportSize);
     }
-    return s.cwd === opts.cwd ? 2 : 1;
   };
-  const sorted = [...opts.sessions].sort((a, b) => {
-    const tier = score(b) - score(a);
-    if (tier !== 0) {
-      return tier;
+  const paintNewItem = () => {
+    if (selectedIdx === 0) {
+      term.brightWhite.bgBlue.noFormat(`\u276F ${newSessionLabel}`);
+    } else {
+      term.noFormat(`  ${newSessionLabel}`);
     }
-    return b.updatedAt.localeCompare(a.updatedAt);
-  });
-  const liveCount = sorted.filter((s) => s.status !== "cold").length;
-  const coldSlice = sorted.slice(liveCount, liveCount + opts.coldLimit);
-  const hiddenCold = sorted.length - liveCount - coldSlice.length;
-  const visible = [...sorted.slice(0, liveCount), ...coldSlice];
-  const rows = visible.map(toRow);
-  const widths = computeWidths(rows);
-  const newSessionLabel = `+ New session in ${opts.cwd}`;
-  const items = [newSessionLabel, ...rows.map((r) => formatRow(r, widths))];
-  term("\n");
-  term.bold("Select a session")("\n");
-  if (hiddenCold > 0) {
-    term.dim(`(${hiddenCold} older cold session${hiddenCold === 1 ? "" : "s"} hidden; use \`hydra-acp sessions --all\` to view)
-`);
-  }
-  term.dim(formatRow(HEADER, widths))("\n");
-  const onCtrlC = (name) => {
-    if (name === "CTRL_C") {
-      term.grabInput(false);
-      term("\n");
-      process.exit(130);
+  };
+  const paintSessionRow = (sessionIdx) => {
+    const label = sessionLines[sessionIdx] ?? "";
+    if (selectedIdx === sessionIdx + 1) {
+      term.brightWhite.bgBlue.noFormat(`\u276F ${label}`);
+    } else {
+      term.noFormat(`  ${label}`);
     }
   };
-  term.on("key", onCtrlC);
-  let response;
-  try {
-    response = await term.singleColumnMenu(items, {
-      cancelable: true,
-      exitOnUnexpectedKey: false,
-      selectedIndex: 0,
-      style: term.brightWhite,
-      selectedStyle: term.brightWhite.bgBlue,
-      keyBindings: {
-        ENTER: "submit",
-        KP_ENTER: "submit",
-        UP: "previous",
-        DOWN: "next",
-        TAB: "next",
-        SHIFT_TAB: "previous",
-        HOME: "first",
-        END: "last",
-        ESCAPE: "cancel",
-        CTRL_C: "cancel"
-      }
-    }).promise;
-  } finally {
-    term.off("key", onCtrlC);
-  }
-  term("\n");
-  if (response.canceled || response.selectedIndex === void 0) {
-    return { kind: "abort" };
-  }
-  if (response.selectedIndex === 0) {
-    return { kind: "new" };
-  }
-  const session = visible[response.selectedIndex - 1];
-  if (!session) {
-    return { kind: "abort" };
-  }
-  const result = {
-    kind: "attach",
-    sessionId: session.sessionId
+  const formatIndicator = () => {
+    const above = scrollOffset;
+    const below = Math.max(0, visible.length - scrollOffset - viewportSize);
+    if (above === 0 && below === 0) {
+      return "";
+    }
+    const parts = [];
+    if (above > 0) {
+      parts.push(`\u2191 ${above} above`);
+    }
+    if (below > 0) {
+      parts.push(`\u2193 ${below} below`);
+    }
+    return `  ${parts.join(" \xB7 ")}`;
   };
-  if (session.agentId !== void 0) {
-    result.agentId = session.agentId;
-  }
-  return result;
-}
-function toRow(s) {
-  return {
-    session: stripHydraSessionPrefix(s.sessionId),
-    upstream: s.upstreamSessionId ?? "-",
-    status: s.status.toUpperCase(),
-    clients: s.status === "cold" ? "-" : String(s.attachedClients),
-    agent: s.agentId ?? "?",
-    title: s.title ?? "-",
-    cwd: s.cwd
+  const shortId2 = (sessionId) => stripHydraSessionPrefix(sessionId);
+  const paintIndicator = () => {
+    term.moveTo(1, indicatorRow()).eraseLineAfter();
+    if (mode === "confirm-kill" && pendingAction) {
+      term.brightYellow.noFormat(`  kill ${shortId2(pendingAction.sessionId)}? [y/N]`);
+      return;
+    }
+    if (mode === "confirm-delete" && pendingAction) {
+      term.brightRed.noFormat(`  delete ${shortId2(pendingAction.sessionId)}? [y/N]`);
+      return;
+    }
+    if (mode === "busy" && pendingAction) {
+      term.dim.noFormat(`  working on ${shortId2(pendingAction.sessionId)}\u2026`);
+      return;
+    }
+    if (transientStatus !== null) {
+      term.dim.noFormat(`  ${transientStatus}`);
+      return;
+    }
+    term.dim.noFormat(formatIndicator());
   };
-}
-function computeWidths(rows) {
-  return {
-    session: maxLen4(HEADER.session, rows.map((r) => r.session)),
-    upstream: maxLen4(HEADER.upstream, rows.map((r) => r.upstream)),
-    status: maxLen4(HEADER.status, rows.map((r) => r.status)),
-    clients: maxLen4(HEADER.clients, rows.map((r) => r.clients)),
-    agent: maxLen4(HEADER.agent, rows.map((r) => r.agent)),
-    title: maxLen4(HEADER.title, rows.map((r) => r.title))
+  const indicatorRow = () => startRow + 3 + viewportSize;
+  const sessionRow = (sessionIdx) => startRow + 3 + (sessionIdx - scrollOffset);
+  const renderFromScratch = () => {
+    computeLayout();
+    adjustScroll();
+    startRow = 1;
+    term.moveTo(1, 1).eraseDisplayBelow();
+    paintNewItem();
+    term("\n\n");
+    term.dim.noFormat(`  ${headerLine}`)("\n");
+    for (let v = 0; v < viewportSize; v++) {
+      paintSessionRow(scrollOffset + v);
+      term("\n");
+    }
+    paintIndicator();
+    term("\n");
   };
-}
-function maxLen4(headerCell, values) {
-  let max = headerCell.length;
-  for (const v of values) {
-    if (v.length > max) {
-      max = v.length;
+  const repaintNewItem = () => {
+    term.moveTo(1, startRow).eraseLineAfter();
+    paintNewItem();
+  };
+  const repaintSessionRow = (sessionIdx) => {
+    if (sessionIdx < scrollOffset || sessionIdx >= scrollOffset + viewportSize) {
+      return;
     }
-  }
-  return max;
+    term.moveTo(1, sessionRow(sessionIdx)).eraseLineAfter();
+    paintSessionRow(sessionIdx);
+  };
+  const repaintViewport = () => {
+    for (let v = 0; v < viewportSize; v++) {
+      const row = startRow + 3 + v;
+      term.moveTo(1, row).eraseLineAfter();
+      const sessionIdx = scrollOffset + v;
+      if (sessionIdx < visible.length) {
+        paintSessionRow(sessionIdx);
+      }
+    }
+    paintIndicator();
+  };
+  renderFromScratch();
+  term.hideCursor();
+  return await new Promise((resolve2) => {
+    let resolved = false;
+    const onResize = () => {
+      if (resolved) {
+        return;
+      }
+      renderFromScratch();
+    };
+    const cleanup = () => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      term.off("key", onKey);
+      term.off("resize", onResize);
+      term.grabInput(false);
+      term.hideCursor(false);
+      term.moveTo(1, indicatorRow() + 1);
+      term("\n");
+    };
+    const refresh = async (preferredId) => {
+      try {
+        const next = await listSessions(opts.config);
+        visible = sortSessions(next);
+        rebuildRows();
+        if (preferredId !== void 0) {
+          const idx = visible.findIndex((s) => s.sessionId === preferredId);
+          if (idx >= 0) {
+            selectedIdx = idx + 1;
+          }
+        }
+        if (selectedIdx > total - 1) {
+          selectedIdx = Math.max(0, total - 1);
+        }
+        if (scrollOffset + viewportSize > visible.length) {
+          scrollOffset = Math.max(0, visible.length - viewportSize);
+        }
+        adjustScroll();
+        renderFromScratch();
+      } catch (err) {
+        transientStatus = `refresh failed: ${err.message}`;
+        renderFromScratch();
+      }
+    };
+    const performAction = async (kind) => {
+      if (!pendingAction) {
+        return;
+      }
+      const target = pendingAction;
+      mode = "busy";
+      paintIndicator();
+      try {
+        if (kind === "kill") {
+          await killSession(opts.config, target.sessionId);
+        } else {
+          await deleteSession(opts.config, target.sessionId);
+        }
+        mode = "normal";
+        pendingAction = null;
+        await refresh(kind === "kill" ? target.sessionId : void 0);
+      } catch (err) {
+        mode = "normal";
+        pendingAction = null;
+        transientStatus = `${kind} failed: ${err.message}`;
+        paintIndicator();
+      }
+    };
+    const move = (delta) => {
+      const next = Math.min(total - 1, Math.max(0, selectedIdx + delta));
+      if (next === selectedIdx) {
+        return;
+      }
+      const old = selectedIdx;
+      const oldScroll = scrollOffset;
+      selectedIdx = next;
+      adjustScroll();
+      if (scrollOffset !== oldScroll) {
+        repaintViewport();
+        if (old === 0 || selectedIdx === 0) {
+          repaintNewItem();
+        }
+        return;
+      }
+      if (old === 0) {
+        repaintNewItem();
+      } else {
+        repaintSessionRow(old - 1);
+      }
+      if (selectedIdx === 0) {
+        repaintNewItem();
+      } else {
+        repaintSessionRow(selectedIdx - 1);
+      }
+    };
+    const clearTransient = () => {
+      if (transientStatus === null) {
+        return false;
+      }
+      transientStatus = null;
+      paintIndicator();
+      return true;
+    };
+    const onKey = (name, _matches, data) => {
+      if (mode === "busy") {
+        return;
+      }
+      if (mode === "confirm-kill" || mode === "confirm-delete") {
+        if (data?.isCharacter && (name === "y" || name === "Y")) {
+          const kind = mode === "confirm-kill" ? "kill" : "delete";
+          void performAction(kind);
+          return;
+        }
+        if (name === "ESCAPE" || name === "CTRL_C" || name === "ENTER" || name === "KP_ENTER" || data?.isCharacter && (name === "n" || name === "N")) {
+          mode = "normal";
+          pendingAction = null;
+          paintIndicator();
+          return;
+        }
+        return;
+      }
+      clearTransient();
+      if (data?.isCharacter) {
+        if ((name === "k" || name === "K") && selectedIdx > 0) {
+          const session = visible[selectedIdx - 1];
+          if (!session) {
+            return;
+          }
+          pendingAction = {
+            sessionId: session.sessionId,
+            cwd: session.cwd,
+            status: session.status
+          };
+          mode = "confirm-kill";
+          paintIndicator();
+          return;
+        }
+        if ((name === "d" || name === "D") && selectedIdx > 0) {
+          const session = visible[selectedIdx - 1];
+          if (!session) {
+            return;
+          }
+          if (session.status === "live") {
+            transientStatus = "session is live \u2014 press k to kill it first";
+            paintIndicator();
+            return;
+          }
+          pendingAction = {
+            sessionId: session.sessionId,
+            cwd: session.cwd,
+            status: session.status
+          };
+          mode = "confirm-delete";
+          paintIndicator();
+          return;
+        }
+        return;
+      }
+      switch (name) {
+        case "UP":
+        case "SHIFT_TAB":
+          move(-1);
+          return;
+        case "DOWN":
+        case "TAB":
+          move(1);
+          return;
+        case "PAGE_UP":
+          move(-viewportSize);
+          return;
+        case "PAGE_DOWN":
+          move(viewportSize);
+          return;
+        case "HOME":
+          move(-total);
+          return;
+        case "END":
+          move(total);
+          return;
+        case "ENTER":
+        case "KP_ENTER": {
+          cleanup();
+          if (selectedIdx === 0) {
+            resolve2({ kind: "new" });
+            return;
+          }
+          const session = visible[selectedIdx - 1];
+          if (!session) {
+            resolve2({ kind: "abort" });
+            return;
+          }
+          const result = {
+            kind: "attach",
+            sessionId: session.sessionId
+          };
+          if (session.agentId !== void 0) {
+            result.agentId = session.agentId;
+          }
+          resolve2(result);
+          return;
+        }
+        case "ESCAPE":
+        case "CTRL_C":
+          cleanup();
+          resolve2({ kind: "abort" });
+          return;
+      }
+    };
+    term.grabInput({});
+    term.on("key", onKey);
+    term.on("resize", onResize);
+  });
 }
-function formatRow(r, w) {
-  return [
-    r.session.padEnd(w.session),
-    r.upstream.padEnd(w.upstream),
-    r.status.padEnd(w.status),
-    r.clients.padStart(w.clients),
-    r.agent.padEnd(w.agent),
-    r.title.padEnd(w.title),
-    r.cwd
-  ].join("  ");
+function readTermHeight(term) {
+  return term.height ?? 24;
 }
-var HEADER;
+function readTermWidth(term) {
+  return term.width ?? 80;
+}
+function formatNewSessionLabel(cwd, maxWidth) {
+  const prefix = "+ New session in ";
+  const budget = Math.max(1, maxWidth - prefix.length);
+  return prefix + truncateMiddle(cwd, budget);
+}
+var ROW_PREFIX_WIDTH;
 var init_picker = __esm({
   "src/tui/picker.ts"() {
     "use strict";
+    init_session_row();
     init_session();
-    HEADER = {
-      session: "SESSION",
-      upstream: "UPSTREAM",
-      status: "STATUS",
-      clients: "CLIENTS",
-      agent: "AGENT",
-      title: "TITLE",
-      cwd: "CWD"
-    };
+    init_discovery();
+    ROW_PREFIX_WIDTH = 2;
   }
 });
 
 // src/tui/screen.ts
 import stringWidth from "string-width";
 import wrapAnsi from "wrap-ansi";
+function formattedLineSig(zone, width, line) {
+  if (!line) {
+    return `${zone}|${width}|empty`;
+  }
+  return `${zone}|${width}|${line.prefix ?? ""}|${line.prefixStyle ?? ""}|${line.body}|${line.bodyStyle ?? ""}|${line.ansi ? "1" : "0"}|${line.fillRow ? "1" : "0"}`;
+}
 function computePromptVisualRows(buffer, room) {
   const rows = [];
   for (let i = 0; i < buffer.length; i++) {
@@ -1893,16 +2795,16 @@ function writeStyled(term, text, style) {
       term.bold.red.noFormat(text);
       return;
     case "tool-status-pending":
-      term.dim.yellow.noFormat(text);
+      term.dim.noFormat(text);
       return;
     case "tool-status-running":
-      term.bold.yellow.noFormat(text);
+      term.brightYellow.noFormat(text);
       return;
     case "tool-status-cancelled":
       term.dim.noFormat(text);
       return;
     case "plan":
-      term.magenta.noFormat(text);
+      term.brightYellow.noFormat(text);
       return;
     case "plan-done":
       term.green.noFormat(text);
@@ -2087,13 +2989,15 @@ function mapKeyName(name) {
       return "ctrl-u";
     case "CTRL_W":
       return "ctrl-w";
+    case "CTRL_Y":
+      return "ctrl-y";
     case "ESCAPE":
       return "escape";
     default:
       return null;
   }
 }
-var HEADER_ROWS, BANNER_ROWS, SEPARATOR_ROWS, MAX_PROMPT_ROWS, MAX_QUEUED_ROWS, MAX_PERMISSION_ROWS, MAX_COMPLETION_ROWS, CONFIRM_PROMPT_ROWS, DEFAULT_CONTENT_REPAINT_THROTTLE_MS, Screen, shortId;
+var HEADER_ROWS, BANNER_ROWS, SEPARATOR_ROWS, MAX_PROMPT_ROWS, MAX_QUEUED_ROWS, MAX_PERMISSION_ROWS, MAX_COMPLETION_ROWS, CONFIRM_PROMPT_ROWS, DEFAULT_CONTENT_REPAINT_THROTTLE_MS, DEFAULT_MAX_SCROLLBACK_LINES, Screen, shortId;
 var init_screen = __esm({
   "src/tui/screen.ts"() {
     "use strict";
@@ -2107,6 +3011,7 @@ var init_screen = __esm({
     MAX_COMPLETION_ROWS = 6;
     CONFIRM_PROMPT_ROWS = 2;
     DEFAULT_CONTENT_REPAINT_THROTTLE_MS = 1e3;
+    DEFAULT_MAX_SCROLLBACK_LINES = 1e4;
     Screen = class {
       term;
       dispatcher;
@@ -2127,6 +3032,27 @@ var init_screen = __esm({
       lastRepaintAt = 0;
       throttledRepaintTimer = null;
       contentRepaintThrottleMs;
+      maxScrollbackLines;
+      // Wrap memoization: each FormattedLine that lands in this.lines gets a
+      // monotonic id assigned via trackLine(); wrapCache holds the pre-wrapped
+      // FormattedLine[] for that id at wrapCacheWidth. Width changes flush the
+      // whole cache; in-place body mutation (streaming) and splices invalidate
+      // affected ids. Result: steady-state repaints only wrap newly-appended
+      // lines, not the entire history.
+      nextLineId = 1;
+      lineIds = /* @__PURE__ */ new WeakMap();
+      wrapCache = /* @__PURE__ */ new Map();
+      wrapCacheWidth = 0;
+      // Per-row signature of what was painted to each terminal row on the
+      // previous repaint. drawX methods funnel through paintRow(), which
+      // skips the moveTo+eraseLineAfter+write sequence when the new
+      // signature matches the previous frame. Eliminates flicker during
+      // the 1Hz busy-tick: only rows whose content actually changed
+      // (banner elapsed, tools-block summary) get re-emitted instead of
+      // every visible row. Cleared on dimension change.
+      lastFrameRows = /* @__PURE__ */ new Map();
+      lastFrameW = 0;
+      lastFrameH = 0;
       permissionPrompt = null;
       confirmPrompt = null;
       completions = [];
@@ -2141,6 +3067,7 @@ var init_screen = __esm({
         queued: 0
       };
       header = { agent: "?", cwd: "?", sessionId: "?" };
+      lastWindowTitle = null;
       resizeHandler;
       keyHandler;
       mouseHandler;
@@ -2161,6 +3088,7 @@ var init_screen = __esm({
         this.dispatcher = opts.dispatcher;
         this.onKey = opts.onKey;
         this.contentRepaintThrottleMs = opts.repaintThrottleMs ?? DEFAULT_CONTENT_REPAINT_THROTTLE_MS;
+        this.maxScrollbackLines = opts.maxScrollbackLines ?? DEFAULT_MAX_SCROLLBACK_LINES;
         this.resizeHandler = () => this.repaint();
         this.keyHandler = (name, _matches, data) => this.handleKey(name, data);
         this.mouseHandler = (name) => this.handleMouse(name);
@@ -2261,13 +3189,17 @@ var init_screen = __esm({
         }
         this.streamingActive = false;
         this.lines.push(...lines);
+        this.trackLines(lines);
         this.adjustScrollForLineChange(lines.length);
+        this.trimScrollback();
         this.scheduleRepaint();
       }
       appendLine(line) {
         this.streamingActive = false;
         this.lines.push(line);
+        this.trackLine(line);
         this.adjustScrollForLineChange(1);
+        this.trimScrollback();
         this.scheduleRepaint();
       }
       // When scrolled away from the bottom, shift scrollOffset to keep the
@@ -2279,6 +3211,40 @@ var init_screen = __esm({
           this.scrollOffset = Math.max(0, this.scrollOffset + delta);
         }
       }
+      trackLine(line) {
+        this.lineIds.set(line, this.nextLineId++);
+      }
+      trackLines(lines) {
+        for (const line of lines) {
+          this.trackLine(line);
+        }
+      }
+      forgetLine(line) {
+        const id = this.lineIds.get(line);
+        if (id !== void 0) {
+          this.wrapCache.delete(id);
+        }
+      }
+      // Drop oldest lines once scrollback exceeds the configured cap. Removes
+      // their wrap-cache entries and shifts keyedBlocks indices in sync;
+      // blocks whose lines fully fell off the head are dropped (a later
+      // upsert for that key will start a fresh block at the bottom).
+      trimScrollback() {
+        const overflow = this.lines.length - this.maxScrollbackLines;
+        if (overflow <= 0) {
+          return;
+        }
+        const removed = this.lines.splice(0, overflow);
+        for (const line of removed) {
+          this.forgetLine(line);
+        }
+        for (const [key, range] of [...this.keyedBlocks.entries()]) {
+          range.start -= overflow;
+          if (range.start < 0) {
+            this.keyedBlocks.delete(key);
+          }
+        }
+      }
       // Append-or-replace a single-line block keyed by `key`. Thin wrapper
       // around upsertLines for the common one-row case (tool calls).
       upsertLine(key, line) {
@@ -2300,7 +3266,15 @@ var init_screen = __esm({
           touchesEnd = oldEnd >= this.lines.length;
           const delta = newLines.length - existing.count;
           scrollDelta = delta;
-          this.lines.splice(existing.start, existing.count, ...newLines);
+          const removed = this.lines.splice(
+            existing.start,
+            existing.count,
+            ...newLines
+          );
+          for (const line of removed) {
+            this.forgetLine(line);
+          }
+          this.trackLines(newLines);
           existing.count = newLines.length;
           if (delta !== 0) {
             for (const [k, range] of this.keyedBlocks) {
@@ -2317,11 +3291,13 @@ var init_screen = __esm({
             count: newLines.length
           });
           this.lines.push(...newLines);
+          this.trackLines(newLines);
         }
         if (touchesEnd) {
           this.streamingActive = false;
         }
         this.adjustScrollForLineChange(scrollDelta);
+        this.trimScrollback();
         this.scheduleRepaint();
       }
       // Append fragments of a streaming message (e.g. agent_message_chunk). The
@@ -2338,6 +3314,7 @@ var init_screen = __esm({
         if (this.streamingActive && this.lines.length > 0) {
           const last = this.lines[this.lines.length - 1];
           if (last) {
+            this.forgetLine(last);
             last.body += first ?? "";
           }
         } else {
@@ -2345,7 +3322,9 @@ var init_screen = __esm({
             const last = this.lines[this.lines.length - 1];
             const isBlank = last && last.body === "" && (!last.prefix || last.prefix === "");
             if (!isBlank) {
-              this.lines.push({ body: "" });
+              const sep = { body: "" };
+              this.lines.push(sep);
+              this.trackLine(sep);
               added += 1;
             }
           }
@@ -2358,25 +3337,48 @@ var init_screen = __esm({
             initial.prefixStyle = prefixStyle;
           }
           this.lines.push(initial);
+          this.trackLine(initial);
           added += 1;
         }
         const continuationPrefix = " ".repeat(prefix.length);
         for (const piece of rest) {
-          this.lines.push({
+          const cont = {
             prefix: continuationPrefix,
             body: piece,
             bodyStyle
-          });
+          };
+          this.lines.push(cont);
+          this.trackLine(cont);
           added += 1;
         }
         this.streamingActive = true;
         this.adjustScrollForLineChange(added);
+        this.trimScrollback();
         this.scheduleRepaint();
       }
       setHeader(header) {
         this.header = { ...this.header, ...header };
+        this.syncWindowTitle();
         this.repaint();
       }
+      // Push the current session title (or short session id, as fallback) to
+      // 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 raw = title && title.length > 0 ? title : fallback;
+        const clean = raw.replace(/[\x00-\x1f\x7f]/g, "").slice(0, 200);
+        if (clean === this.lastWindowTitle) {
+          return;
+        }
+        this.lastWindowTitle = clean;
+        process.stdout.write(`\x1B]2;${clean}\x1B\\`);
+      }
+      clearWindowTitle() {
+        this.lastWindowTitle = null;
+        process.stdout.write("\x1B]2;\x1B\\");
+      }
       setBanner(banner) {
         this.banner = { ...this.banner, ...banner };
         this.drawBanner();
@@ -2385,6 +3387,8 @@ var init_screen = __esm({
       clearScrollback() {
         this.lines = [];
         this.keyedBlocks.clear();
+        this.wrapCache.clear();
+        this.wrapCacheWidth = 0;
         this.streamingActive = false;
         this.scrollOffset = 0;
         this.repaint();
@@ -2407,7 +3411,10 @@ var init_screen = __esm({
           return;
         }
         const touchesEnd = existing.start + existing.count >= this.lines.length;
-        this.lines.splice(existing.start, existing.count);
+        const removed = this.lines.splice(existing.start, existing.count);
+        for (const line of removed) {
+          this.forgetLine(line);
+        }
         this.keyedBlocks.delete(key);
         for (const [, range] of this.keyedBlocks) {
           if (range.start > existing.start) {
@@ -2481,9 +3488,12 @@ var init_screen = __esm({
         if (last && last.body === "" && (last.prefix === void 0 || last.prefix === "")) {
           return;
         }
-        this.lines.push({ body: "" });
+        const sep = { body: "" };
+        this.lines.push(sep);
+        this.trackLine(sep);
         this.streamingActive = false;
         this.adjustScrollForLineChange(1);
+        this.trimScrollback();
         this.scheduleRepaint();
       }
       // The dispatcher is the source of truth for prompt state. If the prompt
@@ -2555,9 +3565,11 @@ var init_screen = __esm({
         return Math.max(0, bottom - top + 1);
       }
       maxScrollOffset() {
-        const wrapped = this.wrapLines(this.lines, this.term.width);
-        const visible = this.scrollbackVisibleRows();
-        return Math.max(0, wrapped.length - visible);
+        const { rows } = this.wrapTail(
+          this.term.width,
+          Number.POSITIVE_INFINITY
+        );
+        return Math.max(0, rows.length - this.scrollbackVisibleRows());
       }
       // Used by content mutators to coalesce rapid updates. Repaints fire
       // at most once per contentRepaintThrottleMs; if a paint happened
@@ -2590,6 +3602,22 @@ var init_screen = __esm({
           this.repaint();
         }, this.contentRepaintThrottleMs - elapsed);
       }
+      // Funnel for every row that any drawX method renders. Skips emitting
+      // moveTo+eraseLineAfter+paint when the row's signature matches the
+      // previous frame's. The signature must capture everything that affects
+      // visible output for that row (width, FormattedLine fields, banner
+      // state, etc.) so identical sigs guarantee identical bytes.
+      paintRow(row, signature, paint) {
+        if (row < 1 || row > this.term.height) {
+          return;
+        }
+        if (this.lastFrameRows.get(row) === signature) {
+          return;
+        }
+        this.lastFrameRows.set(row, signature);
+        this.term.moveTo(1, row).eraseLineAfter();
+        paint();
+      }
       repaint() {
         if (this.repaintPaused > 0) {
           this.repaintPending = true;
@@ -2605,6 +3633,11 @@ var init_screen = __esm({
         if (w < 20 || h < 8) {
           return;
         }
+        if (w !== this.lastFrameW || h !== this.lastFrameH) {
+          this.lastFrameRows.clear();
+          this.lastFrameW = w;
+          this.lastFrameH = h;
+        }
         this.drawHeader();
         this.drawSeparator(HEADER_ROWS);
         this.drawScrollback();
@@ -2620,22 +3653,40 @@ var init_screen = __esm({
       }
       drawHeader() {
         const w = this.term.width;
-        this.term.moveTo(1, 1).eraseLineAfter();
         const usage = formatUsage(this.header.usage);
-        const cwdRoom = Math.max(8, w - 40 - (usage ? usage.length + 3 : 0));
-        this.term.bold("hydra")(" \xB7 ").cyan(this.header.agent)(" \xB7 ").dim(truncate(this.header.cwd, cwdRoom))(" \xB7 ").yellow(shortId(this.header.sessionId));
-        if (usage) {
-          const col = Math.max(1, w - usage.length + 1);
-          this.term.moveTo(col, 1);
-          this.term.dim(usage);
-        }
+        const sid = shortId(this.header.sessionId);
+        const title = this.header.title?.trim();
+        const sig = `hdr|${w}|${this.header.agent}|${this.header.cwd}|${sid}|${title ?? ""}|${usage ?? ""}`;
+        this.paintRow(1, sig, () => {
+          const fixed = "hydra \xB7 ".length + this.header.agent.length + " \xB7 ".length + " \xB7 ".length + sid.length + (title ? " \xB7 ".length : 0) + (usage ? usage.length + 3 : 0);
+          const variableRoom = Math.max(8, w - fixed);
+          let cwdRoom;
+          let titleRoom;
+          if (title) {
+            const cwdMin = Math.min(this.header.cwd.length, 12);
+            const titleCap = Math.max(8, variableRoom - cwdMin);
+            titleRoom = Math.min(title.length, titleCap);
+            cwdRoom = Math.max(8, variableRoom - titleRoom);
+          } else {
+            titleRoom = 0;
+            cwdRoom = variableRoom;
+          }
+          this.term.bold("hydra")(" \xB7 ").cyan.noFormat(this.header.agent)(" \xB7 ").dim.noFormat(truncate(this.header.cwd, cwdRoom))(" \xB7 ").yellow(sid);
+          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);
+            this.term.dim(usage);
+          }
+        });
       }
       drawSeparator(row) {
-        if (row < 1 || row > this.term.height) {
-          return;
-        }
-        this.term.moveTo(1, row).eraseLineAfter();
-        this.term.dim("\u2500".repeat(this.term.width));
+        const w = this.term.width;
+        this.paintRow(row, `sep|${w}`, () => {
+          this.term.dim("\u2500".repeat(w));
+        });
       }
       drawScrollback() {
         const w = this.term.width;
@@ -2644,21 +3695,30 @@ var init_screen = __esm({
         if (visibleRows <= 0) {
           return;
         }
-        const wrapped = this.wrapLines(this.lines, w);
-        const max = Math.max(0, wrapped.length - visibleRows);
-        if (this.scrollOffset > max) {
-          this.scrollOffset = max;
+        const { rows: wrapped, exhausted } = this.wrapTail(
+          w,
+          visibleRows + this.scrollOffset
+        );
+        if (exhausted) {
+          const max = Math.max(0, wrapped.length - visibleRows);
+          if (this.scrollOffset > max) {
+            this.scrollOffset = max;
+          }
         }
         const end = wrapped.length - this.scrollOffset;
         const start = Math.max(0, end - visibleRows);
         const slice = wrapped.slice(start, end);
+        const padTop = Math.max(0, visibleRows - slice.length);
         for (let i = 0; i < visibleRows; i++) {
           const row = top + i;
-          this.term.moveTo(1, row).eraseLineAfter();
-          const line = slice[i];
-          if (line) {
-            this.writeFormattedLine(line, w);
-          }
+          const sliceIdx = i - padTop;
+          const line = sliceIdx >= 0 ? slice[sliceIdx] : void 0;
+          const sig = formattedLineSig("sb", w, line);
+          this.paintRow(row, sig, () => {
+            if (line) {
+              this.writeFormattedLine(line, w);
+            }
+          });
         }
       }
       queuedRows() {
@@ -2689,26 +3749,27 @@ var init_screen = __esm({
         }
         for (let i = 0; i < rows; i++) {
           const row = completionTop + i;
-          this.term.moveTo(1, row).eraseLineAfter();
           const item = this.completions[i];
-          if (!item) {
-            continue;
-          }
           const isLast = i === rows - 1 && this.completions.length > MAX_COMPLETION_ROWS;
-          if (isLast) {
-            this.term.dim(
-              `  + ${this.completions.length - MAX_COMPLETION_ROWS + 1} more match(es)`
-            );
-            continue;
-          }
-          const namePadded = item.name.padEnd(nameWidth);
-          const desc = item.description ?? "";
-          const remaining = w - namePadded.length - 4;
-          const truncated = remaining > 0 ? truncate(desc, remaining) : "";
-          this.term("  ").brightCyan(namePadded);
-          if (truncated.length > 0) {
-            this.term("  ").dim(truncated);
-          }
+          const overflow = this.completions.length - MAX_COMPLETION_ROWS + 1;
+          const sig = item ? isLast ? `comp|${w}|overflow|${overflow}` : `comp|${w}|${nameWidth}|${item.name}|${item.description ?? ""}` : `comp|${w}|empty`;
+          this.paintRow(row, sig, () => {
+            if (!item) {
+              return;
+            }
+            if (isLast) {
+              this.term.dim(`  + ${overflow} more match(es)`);
+              return;
+            }
+            const namePadded = item.name.padEnd(nameWidth);
+            const desc = item.description ?? "";
+            const remaining = w - namePadded.length - 4;
+            const truncated = remaining > 0 ? truncate(desc, remaining) : "";
+            this.term("  ").brightCyan(namePadded);
+            if (truncated.length > 0) {
+              this.term("  ").dim(truncated);
+            }
+          });
         }
       }
       drawQueuedZone() {
@@ -2723,17 +3784,19 @@ var init_screen = __esm({
         const queuedTop = queuedBottom - rows + 1;
         for (let i = 0; i < rows; i++) {
           const row = queuedTop + i;
-          this.term.moveTo(1, row).eraseLineAfter();
           const text = this.queuedTexts[i];
-          if (text === void 0) {
-            continue;
-          }
           const isLast = i === rows - 1 && this.queuedTexts.length > MAX_QUEUED_ROWS;
           const overflow = this.queuedTexts.length - MAX_QUEUED_ROWS;
-          const summary = isLast ? `+ ${overflow + 1} more queued` : truncate(firstLine2(text), w - 4);
-          const display = ` \u23F3 ${summary}`;
-          const padded = display + " ".repeat(Math.max(0, w - display.length));
-          this.term.bgBlue.brightWhite.noFormat(padded);
+          const summary = text === void 0 ? "" : isLast ? `+ ${overflow + 1} more queued` : truncate(firstLine2(text), w - 4);
+          const sig = text === void 0 ? `queued|${w}|empty` : `queued|${w}|${isLast ? "ovf" : "row"}|${summary}`;
+          this.paintRow(row, sig, () => {
+            if (text === void 0) {
+              return;
+            }
+            const display = ` \u23F3 ${summary}`;
+            const padded = display + " ".repeat(Math.max(0, w - display.length));
+            this.term.bgBlue.brightWhite.noFormat(padded);
+          });
         }
       }
       drawPrompt() {
@@ -2754,19 +3817,30 @@ var init_screen = __esm({
         for (let i = 0; i < layout.rendered; i++) {
           const vr = visualRows[layout.windowStart + i];
           const row = top + i;
-          this.term.moveTo(1, row).eraseLineAfter();
-          if (!vr) {
-            continue;
-          }
-          if (vr.bufferIdx === 0 && vr.startCol === 0) {
-            this.term.brightWhite("> ");
-          } else if (vr.startCol === 0) {
-            this.term.dim("\xB7 ");
-          } else {
-            this.term("  ");
+          let gutter = "wrap";
+          let slice = "";
+          if (vr) {
+            if (vr.bufferIdx === 0 && vr.startCol === 0) {
+              gutter = "first";
+            } else if (vr.startCol === 0) {
+              gutter = "newline";
+            }
+            slice = (state.buffer[vr.bufferIdx] ?? "").slice(vr.startCol, vr.endCol);
           }
-          const line = state.buffer[vr.bufferIdx] ?? "";
-          this.term.noFormat(line.slice(vr.startCol, vr.endCol));
+          const sig = vr ? `prompt|${this.term.width}|${gutter}|${slice}` : `prompt|${this.term.width}|empty`;
+          this.paintRow(row, sig, () => {
+            if (!vr) {
+              return;
+            }
+            if (gutter === "first") {
+              this.term.brightWhite("> ");
+            } else if (gutter === "newline") {
+              this.term.dim("\xB7 ");
+            } else {
+              this.term("  ");
+            }
+            this.term.noFormat(slice);
+          });
         }
       }
       drawConfirmPrompt() {
@@ -2776,10 +3850,12 @@ var init_screen = __esm({
         }
         const w = this.term.width;
         const top = this.term.height - CONFIRM_PROMPT_ROWS - BANNER_ROWS + 1;
-        this.term.moveTo(1, top).eraseLineAfter();
-        this.term.brightYellow(` ? ${truncate(spec.question, w - 4)}`);
-        this.term.moveTo(1, top + 1).eraseLineAfter();
-        this.term.dim(` ${truncate(spec.hint, w - 2)}`);
+        this.paintRow(top, `confirm|q|${w}|${spec.question}`, () => {
+          this.term.brightYellow(` ? ${truncate(spec.question, w - 4)}`);
+        });
+        this.paintRow(top + 1, `confirm|h|${w}|${spec.hint}`, () => {
+          this.term.dim(` ${truncate(spec.hint, w - 2)}`);
+        });
       }
       drawPermissionPrompt() {
         const spec = this.permissionPrompt;
@@ -2790,21 +3866,20 @@ var init_screen = __esm({
         const rows = this.permissionRows();
         const top = this.term.height - rows - BANNER_ROWS + 1;
         let row = top;
-        const writeRow = (paint) => {
+        const writeRow = (sig, paint) => {
           if (row >= top + rows) {
             return;
           }
-          this.term.moveTo(1, row).eraseLineAfter();
-          paint();
+          this.paintRow(row, sig, paint);
           row += 1;
         };
-        writeRow(() => {
+        writeRow(`perm|t|${w}|${spec.title}`, () => {
           this.term.brightYellow(` \u{1F512} ${truncate(spec.title, w - 5)}`);
         });
-        writeRow(() => {
+        writeRow(`perm|sub|${w}`, () => {
           this.term.dim(" This action requires approval");
         });
-        writeRow(() => {
+        writeRow(`perm|q|${w}`, () => {
           this.term(" Do you want to proceed?");
         });
         for (let i = 0; i < spec.options.length; i++) {
@@ -2818,7 +3893,7 @@ var init_screen = __esm({
           const isSel = i === spec.selectedIndex;
           const marker = isSel ? "\u276F" : " ";
           const body = ` ${marker} ${i + 1}. ${truncate(opt.label, w - 8)}`;
-          writeRow(() => {
+          writeRow(`perm|o|${w}|${i}|${isSel ? "1" : "0"}|${opt.label}`, () => {
             if (isSel) {
               this.term.brightCyan(body);
             } else {
@@ -2826,36 +3901,42 @@ var init_screen = __esm({
             }
           });
         }
-        writeRow(() => {
+        writeRow(`perm|hint|${w}`, () => {
           this.term.dim(" \u2191/\u2193 choose \xB7 Enter submit \xB7 Esc cancel \xB7 1\u20139 quick-pick");
         });
       }
       drawBanner() {
         const row = this.term.height;
-        this.term.moveTo(1, row).eraseLineAfter();
-        const dot = this.banner.status === "running" ? "\u25CF" : "\u25CB";
-        const planLabel = this.banner.planMode ? "plan: ON " : "plan: off";
-        if (this.banner.status === "running") {
-          this.term.brightYellow(`${dot} ${this.banner.status}`);
-          if (this.banner.elapsedMs !== void 0 && this.banner.elapsedMs >= 1e3) {
-            this.term(" ").dim(formatElapsed(this.banner.elapsedMs));
+        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 sig = `bnr|${w}|${this.banner.status}|${elapsedStr}|${this.banner.queued}|${this.scrollOffset}|${this.banner.planMode ? "1" : "0"}|${this.banner.hint}`;
+        this.paintRow(row, sig, () => {
+          const dot = this.banner.status === "busy" ? "\u25CF" : "\u25CB";
+          const planLabel = this.banner.planMode ? "plan: ON " : "plan: off";
+          if (this.banner.status === "busy") {
+            this.term.brightYellow(`${dot} ${this.banner.status}`);
+            if (elapsedStr) {
+              this.term(" ").dim(elapsedStr);
+            }
+          } else if (this.banner.status === "disconnected") {
+            this.term.brightRed(`${dot} ${this.banner.status}`);
+          } else {
+            this.term.brightGreen(`${dot} ${this.banner.status}`);
           }
-        } else {
-          this.term.brightGreen(`${dot} ${this.banner.status}`);
-        }
-        if (this.banner.queued > 0) {
-          this.term(" \xB7 ").brightYellow(`${this.banner.queued} queued`);
-        }
-        if (this.scrollOffset > 0) {
-          this.term(" \xB7 ").brightCyan(`\u2191 ${this.scrollOffset}`);
-        }
-        this.term(" \xB7 ");
-        if (this.banner.planMode) {
-          this.term.brightMagenta(planLabel);
-        } else {
-          this.term.dim(planLabel);
-        }
-        this.term(" \xB7 ").dim(this.banner.hint);
+          if (this.banner.queued > 0) {
+            this.term(" \xB7 ").brightYellow(`${this.banner.queued} queued`);
+          }
+          if (this.scrollOffset > 0) {
+            this.term(" \xB7 ").brightCyan(`\u2191 ${this.scrollOffset}`);
+          }
+          this.term(" \xB7 ");
+          if (this.banner.planMode) {
+            this.term.brightYellow(planLabel);
+          } else {
+            this.term.dim(planLabel);
+          }
+          this.term(" \xB7 ").dim(this.banner.hint);
+        });
       }
       placeCursor() {
         if (this.permissionPrompt) {
@@ -2905,37 +3986,83 @@ var init_screen = __esm({
           4 + this.permissionPrompt.options.length
         );
       }
-      wrapLines(lines, width) {
+      // Walk this.lines from the tail, accumulating wrapped rows via the
+      // wrap cache, until we have at least `needed` rows or run out. Returns
+      // the collected rows in original (top-down) order plus an `exhausted`
+      // flag that's true iff we reached the head of this.lines. The hot path
+      // (drawScrollback) only ever asks for `visibleRows + scrollOffset`
+      // rows, so a 10k-line scrollback costs ~50 cache hits per repaint
+      // instead of 10k. With `needed = Infinity` this walks everything and
+      // doubles as a total-row counter for maxScrollOffset.
+      wrapTail(width, needed) {
         if (width <= 4) {
-          return lines;
+          const take = Math.min(needed, this.lines.length);
+          return {
+            rows: this.lines.slice(this.lines.length - take),
+            exhausted: needed >= this.lines.length
+          };
         }
-        const out = [];
-        for (const line of lines) {
-          const prefix = line.prefix ?? "";
-          const room = Math.max(1, width - prefix.length);
-          const chunks = line.ansi ? wrapAnsiBody(line.body, room) : wrap(line.body, room);
-          for (let i = 0; i < chunks.length; i++) {
-            const chunk = chunks[i] ?? "";
-            const wrappedLine = {
-              prefix: i === 0 ? line.prefix : " ".repeat(prefix.length),
-              body: chunk
-            };
-            if (line.prefixStyle !== void 0) {
-              wrappedLine.prefixStyle = line.prefixStyle;
-            }
-            if (line.bodyStyle !== void 0) {
-              wrappedLine.bodyStyle = line.bodyStyle;
-            }
-            if (line.fillRow) {
-              wrappedLine.fillRow = true;
-            }
-            if (line.ansi) {
-              wrappedLine.ansi = true;
-            }
-            out.push(wrappedLine);
+        if (this.wrapCacheWidth !== width) {
+          this.wrapCache.clear();
+          this.wrapCacheWidth = width;
+        }
+        if (needed <= 0 || this.lines.length === 0) {
+          return { rows: [], exhausted: true };
+        }
+        const batches = [];
+        let total = 0;
+        let stoppedAt = 0;
+        for (let i = this.lines.length - 1; i >= 0; i--) {
+          const wrapped = this.wrapOne(this.lines[i], width);
+          batches.push(wrapped);
+          total += wrapped.length;
+          stoppedAt = i;
+          if (total >= needed) {
+            break;
+          }
+        }
+        const rows = [];
+        for (let i = batches.length - 1; i >= 0; i--) {
+          rows.push(...batches[i]);
+        }
+        return { rows, exhausted: stoppedAt === 0 };
+      }
+      wrapOne(line, width) {
+        const id = this.lineIds.get(line);
+        if (id !== void 0) {
+          const cached = this.wrapCache.get(id);
+          if (cached) {
+            return cached;
+          }
+        }
+        const prefix = line.prefix ?? "";
+        const room = Math.max(1, width - prefix.length);
+        const chunks = line.ansi ? wrapAnsiBody(line.body, room) : wrap(line.body, room);
+        const wrapped = [];
+        for (let i = 0; i < chunks.length; i++) {
+          const chunk = chunks[i] ?? "";
+          const wrappedLine = {
+            prefix: i === 0 ? line.prefix : " ".repeat(prefix.length),
+            body: chunk
+          };
+          if (line.prefixStyle !== void 0) {
+            wrappedLine.prefixStyle = line.prefixStyle;
+          }
+          if (line.bodyStyle !== void 0) {
+            wrappedLine.bodyStyle = line.bodyStyle;
+          }
+          if (line.fillRow) {
+            wrappedLine.fillRow = true;
           }
+          if (line.ansi) {
+            wrappedLine.ansi = true;
+          }
+          wrapped.push(wrappedLine);
+        }
+        if (id !== void 0) {
+          this.wrapCache.set(id, wrapped);
         }
-        return out;
+        return wrapped;
       }
       writeFormattedLine(line, width) {
         if (line.prefix) {
@@ -2974,6 +4101,10 @@ var init_input = __esm({
       savedDraft = null;
       history = [];
       turnRunning = false;
+      // Single-slot kill ring. The most recent killed text (^U, ^K, ^W) lands
+      // here so ^Y can yank it back. Standard readline keeps a stack; we
+      // only keep one slot because that's what 99% of yank uses look like.
+      killBuffer = "";
       constructor(opts = {}) {
         this.history = [...opts.history ?? []];
         this.planMode = opts.planMode ?? false;
@@ -3082,6 +4213,9 @@ var init_input = __esm({
           case "ctrl-w":
             this.killWord();
             return [];
+          case "ctrl-y":
+            this.yank();
+            return [];
           case "escape":
             return [];
         }
@@ -3175,11 +4309,19 @@ var init_input = __esm({
       }
       killLine() {
         const line = this.currentLine();
+        const killed = line.slice(0, this.col);
+        if (killed.length > 0) {
+          this.killBuffer = killed;
+        }
         this.setCurrentLine(line.slice(this.col));
         this.col = 0;
       }
       killToEnd() {
         const line = this.currentLine();
+        const killed = line.slice(this.col);
+        if (killed.length > 0) {
+          this.killBuffer = killed;
+        }
         this.setCurrentLine(line.slice(0, this.col));
       }
       killWord() {
@@ -3195,9 +4337,19 @@ var init_input = __esm({
         while (i > 0 && !/\s/.test(line[i - 1] ?? "")) {
           i -= 1;
         }
+        const killed = line.slice(i, this.col);
+        if (killed.length > 0) {
+          this.killBuffer = killed;
+        }
         this.setCurrentLine(line.slice(0, i) + line.slice(this.col));
         this.col = i;
       }
+      yank() {
+        if (this.killBuffer.length === 0) {
+          return;
+        }
+        this.insertText(this.killBuffer);
+      }
       moveLeft() {
         if (this.col > 0) {
           this.col -= 1;
@@ -3340,10 +4492,19 @@ function mapUpdate(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 title = readString(u, "title");
+  if (title === void 0) {
+    return null;
+  }
+  return { kind: "session-info", title };
+}
 function mapAvailableCommands(u) {
   const list = u.availableCommands ?? u.commands;
   if (!Array.isArray(list)) {
@@ -3584,6 +4745,8 @@ function formatEvent(event) {
       return [];
     case "available-commands":
       return [];
+    case "session-info":
+      return [];
     case "unknown":
       return [];
   }
@@ -3849,8 +5012,8 @@ var init_format = __esm({
 });
 
 // src/tui/app.ts
-import WebSocket2 from "ws";
-import { once } from "events";
+import { appendFileSync, statSync, renameSync } from "fs";
+import { nanoid as nanoid3 } from "nanoid";
 import termkit from "terminal-kit";
 async function runTuiApp(opts) {
   const config = await ensureConfig();
@@ -3867,9 +5030,33 @@ async function runSession(term, config, opts) {
     term.grabInput(false);
     process.exit(0);
   }
-  const ws = await openWs2(config);
-  const stream = wsToMessageStream(ws);
+  const launchLabel = ctx.sessionId === "__new__" ? "Starting new session\u2026" : "Resuming session\u2026";
+  term.cyan(launchLabel)("\n");
+  const protocol = config.daemon.tls ? "wss" : "ws";
+  const wsUrl = `${protocol}://${config.daemon.host}:${config.daemon.port}/acp`;
+  const subprotocols = ["acp.v1", `hydra-acp-token.${config.daemon.authToken}`];
+  let onReconnect = null;
+  let onDisconnectHook = null;
+  const stream = new ResilientWsStream({
+    url: wsUrl,
+    subprotocols,
+    onConnect: async (firstConnect) => {
+      if (firstConnect) {
+        return;
+      }
+      if (onReconnect) {
+        await onReconnect();
+      }
+    },
+    onDisconnect: (err) => {
+      if (onDisconnectHook) {
+        onDisconnectHook(err);
+      }
+    },
+    log: () => void 0
+  });
   const conn = new JsonRpcConnection(stream);
+  await stream.start();
   let bufferedEvents = [];
   let applyRenderEvent = null;
   const appendRender = (event) => {
@@ -3891,8 +5078,9 @@ async function runSession(term, config, opts) {
     const screenReady = typeof screenRef !== "undefined" && screenRef !== null;
     if (before === 0 && pendingTurns > 0) {
       sessionBusySince = Date.now();
+      dispatcherRef?.setTurnRunning(true);
       if (screenReady) {
-        screenRef.setBanner({ status: "running", elapsedMs: 0 });
+        screenRef.setBanner({ status: "busy", elapsedMs: 0 });
       }
       if (sessionElapsedTimer === null && screenReady) {
         sessionElapsedTimer = setInterval(() => {
@@ -3901,10 +5089,11 @@ async function runSession(term, config, opts) {
           }
           screenRef.setBanner({ elapsedMs: Date.now() - sessionBusySince });
           renderToolsBlock();
-        }, 5e3);
+        }, 1e3);
       }
     } else if (before > 0 && pendingTurns === 0) {
       sessionBusySince = null;
+      dispatcherRef?.setTurnRunning(false);
       if (sessionElapsedTimer !== null) {
         clearInterval(sessionElapsedTimer);
         sessionElapsedTimer = null;
@@ -3918,9 +5107,11 @@ async function runSession(term, config, opts) {
     }
   };
   let screenRef = null;
+  let dispatcherRef = null;
   conn.onNotification("session/update", (params) => {
     const { update } = params ?? {};
     const event = mapUpdate(update);
+    debugLogUpdate(update, event);
     if (event?.kind === "user-text") {
       adjustPendingTurns(1);
     } else if (event?.kind === "turn-complete") {
@@ -4033,6 +5224,11 @@ async function runSession(term, config, opts) {
   let resolvedSessionId = ctx.sessionId;
   let resolvedAgentId = ctx.agentId;
   let resolvedCwd = ctx.cwd;
+  let resolvedTitle;
+  let initialModel;
+  let initialMode;
+  let initialCommands;
+  let initialTurnStartedAt;
   if (ctx.sessionId === "__new__") {
     const created = await conn.request("session/new", {
       cwd: ctx.cwd,
@@ -4048,6 +5244,17 @@ async function runSession(term, config, opts) {
     if (hydraMeta.cwd) {
       resolvedCwd = hydraMeta.cwd;
     }
+    if (hydraMeta.name) {
+      resolvedTitle = hydraMeta.name;
+    }
+    initialModel = hydraMeta.currentModel;
+    initialMode = hydraMeta.currentMode;
+    initialTurnStartedAt = hydraMeta.turnStartedAt;
+    if (hydraMeta.availableCommands) {
+      initialCommands = hydraMeta.availableCommands.map(
+        (c) => c.description !== void 0 ? { name: c.name, description: c.description } : { name: c.name }
+      );
+    }
   } else {
     const attached = await conn.request("session/attach", {
       sessionId: ctx.sessionId,
@@ -4063,16 +5270,31 @@ async function runSession(term, config, opts) {
     if (hydraMeta.cwd) {
       resolvedCwd = hydraMeta.cwd;
     }
+    if (hydraMeta.name) {
+      resolvedTitle = hydraMeta.name;
+    }
+    initialModel = hydraMeta.currentModel;
+    initialMode = hydraMeta.currentMode;
+    initialTurnStartedAt = hydraMeta.turnStartedAt;
+    if (hydraMeta.availableCommands) {
+      initialCommands = hydraMeta.availableCommands.map(
+        (c) => c.description !== void 0 ? { name: c.name, description: c.description } : { name: c.name }
+      );
+    }
   }
-  void upstreamSessionId;
-  const historyFile = paths.tuiHistoryFile();
+  const historyFile = paths.tuiHistoryFile(resolvedSessionId);
   let history = await loadHistory(historyFile).catch(() => []);
   const dispatcher = new InputDispatcher({ history });
+  dispatcherRef = dispatcher;
+  if (pendingTurns > 0) {
+    dispatcher.setTurnRunning(true);
+  }
   let turnInFlight = null;
   const screen = new Screen({
     term,
     dispatcher,
     repaintThrottleMs: config.tui.repaintThrottleMs,
+    maxScrollbackLines: config.tui.maxScrollbackLines,
     onKey: (events) => {
       for (const ev of events) {
         if (pendingPermission && tryHandlePermissionKey(ev)) {
@@ -4102,7 +5324,7 @@ async function runSession(term, config, opts) {
     { name: "/demo-plan", description: "Inject synthetic plan events (UI test)" },
     { name: "/demo-tool", description: "Inject a synthetic tool-call sequence (UI test)" }
   ];
-  let agentCommands = [];
+  let agentCommands = initialCommands ?? [];
   const allCommands = () => {
     const seen = /* @__PURE__ */ new Set();
     const out = [];
@@ -4226,17 +5448,31 @@ async function runSession(term, config, opts) {
   screen.setHeader({
     agent: headerName,
     cwd: resolvedCwd,
-    sessionId: resolvedSessionId
+    sessionId: resolvedSessionId,
+    title: resolvedTitle
   });
+  if (initialMode) {
+    screen.appendLines(formatEvent({ kind: "mode-changed", mode: initialMode }));
+  }
+  if (initialModel) {
+    screen.appendLines(formatEvent({ kind: "model-changed", model: initialModel }));
+  }
   let finishSession = null;
   const sessionDone = new Promise((resolve2) => {
     finishSession = resolve2;
   });
+  const cancelRemoteTurn = () => {
+    conn.notify("session/cancel", { sessionId: resolvedSessionId }).catch(() => void 0);
+  };
   const sigintHandler = () => {
     if (turnInFlight) {
       turnInFlight.cancel();
       return;
     }
+    if (pendingTurns > 0) {
+      cancelRemoteTurn();
+      return;
+    }
     void requestExit();
   };
   let exitConfirmation = null;
@@ -4311,12 +5547,10 @@ async function runSession(term, config, opts) {
   };
   const teardown = () => {
     process.off("SIGINT", sigintHandler);
+    screen.clearWindowTitle();
     screen.stop();
     saveHistory(historyFile, history).catch(() => void 0);
-    try {
-      ws.close();
-    } catch {
-    }
+    void stream.close().catch(() => void 0);
   };
   const stop = (code = 0) => {
     teardown();
@@ -4329,22 +5563,32 @@ async function runSession(term, config, opts) {
     }
   };
   const switchSession = async () => {
-    const resume = finishSession;
-    if (!resume) {
+    if (!finishSession) {
       return;
     }
-    finishSession = null;
-    teardown();
+    const pendingDraft = dispatcher.state().buffer.join("\n");
+    if (pendingDraft.replace(/\s+$/, "").length > 0) {
+      history = appendEntry(history, pendingDraft);
+      dispatcher.setHistory(history);
+    }
+    screen.pauseRepaint();
+    screen.stop();
+    saveHistory(historyFile, history).catch(() => void 0);
     const sessions = await listSessions(config);
     const choice = await pickSession(term, {
       cwd: resolvedCwd,
       sessions,
-      coldLimit: config.sessionListColdLimit
+      config
     });
     if (choice.kind === "abort") {
-      resume({ ...opts, sessionId: resolvedSessionId, cwd: resolvedCwd });
+      screen.start();
+      screen.resumeRepaint();
       return;
     }
+    const resume = finishSession;
+    finishSession = null;
+    process.off("SIGINT", sigintHandler);
+    void stream.close().catch(() => void 0);
     if (choice.kind === "new") {
       const { sessionId: _drop, ...rest } = opts;
       void _drop;
@@ -4369,6 +5613,8 @@ async function runSession(term, config, opts) {
       case "cancel":
         if (turnInFlight) {
           turnInFlight.cancel();
+        } else if (pendingTurns > 0) {
+          cancelRemoteTurn();
         }
         if (promptQueue.length > (workerActive ? 1 : 0)) {
           promptQueue.length = workerActive ? 1 : 0;
@@ -4556,7 +5802,6 @@ async function runSession(term, config, opts) {
     const promptArr = planMode ? [{ type: "text", text: PLAN_PREFIX_TEXT }, ...userBlocks] : userBlocks;
     adjustPendingTurns(1);
     appendRender({ kind: "user-text", text });
-    dispatcher.setTurnRunning(true);
     let cancelled = false;
     turnInFlight = {
       cancel: () => {
@@ -4586,7 +5831,6 @@ async function runSession(term, config, opts) {
       });
     } finally {
       turnInFlight = null;
-      dispatcher.setTurnRunning(false);
       adjustPendingTurns(-1);
       appendRender(
         stopReason !== void 0 ? { kind: "turn-complete", stopReason } : { kind: "turn-complete" }
@@ -4642,7 +5886,7 @@ async function runSession(term, config, opts) {
     const elapsed = end - toolsBlockStartedAt;
     let summary;
     if (total === 0) {
-      summary = inProgress ? `thinking \xB7 ${formatElapsed(elapsed)}` : `no tools \xB7 took ${formatElapsed(elapsed)}`;
+      summary = inProgress ? `thinking \xB7 ${formatElapsed(elapsed)}` : `thought \xB7 ${formatElapsed(elapsed)}`;
     } else {
       const noun = total === 1 ? "tool" : "tools";
       const timing = inProgress ? formatElapsed(elapsed) : `took ${formatElapsed(elapsed)}`;
@@ -4709,6 +5953,12 @@ async function runSession(term, config, opts) {
       refreshCompletions();
       return;
     }
+    if (event.kind === "session-info") {
+      if (event.title !== void 0) {
+        screen.setHeader({ title: event.title });
+      }
+      return;
+    }
     if (event.kind === "usage-update") {
       let changed = false;
       if (event.used !== void 0 && usage.used !== event.used) {
@@ -4739,6 +5989,12 @@ async function runSession(term, config, opts) {
       if (formatted2.length > 0) {
         screen.appendLines(formatted2);
       }
+      screen.clearKey("tools");
+      screen.clearKey("plan");
+      toolStates.clear();
+      toolCallOrder.length = 0;
+      toolsExpanded = false;
+      toolsBlockEndedAt = null;
       startToolsBlock();
       screen.redraw();
       return;
@@ -4779,12 +6035,10 @@ async function runSession(term, config, opts) {
     if (event.kind === "turn-complete") {
       closeAgentText();
       screen.clearKey("plan");
-      if (toolCallOrder.length > 0) {
+      if (toolsBlockStartedAt !== null) {
         toolsBlockEndedAt = Date.now();
         renderToolsBlock();
         screen.clearKey("tools");
-      } else if (toolsBlockStartedAt !== null) {
-        screen.removeBlock("tools");
       }
       toolStates.clear();
       toolCallOrder.length = 0;
@@ -4804,6 +6058,108 @@ async function runSession(term, config, opts) {
   } finally {
     screen.resumeRepaint();
   }
+  if (initialTurnStartedAt !== void 0 && pendingTurns > 0) {
+    sessionBusySince = initialTurnStartedAt;
+    screen.setBanner({
+      status: "busy",
+      elapsedMs: Date.now() - initialTurnStartedAt
+    });
+    if (sessionElapsedTimer === null) {
+      sessionElapsedTimer = setInterval(() => {
+        if (sessionBusySince === null || screenRef === null) {
+          return;
+        }
+        screenRef.setBanner({ elapsedMs: Date.now() - sessionBusySince });
+        renderToolsBlock();
+      }, 1e3);
+    }
+    startToolsBlock();
+  }
+  const resetInFlightUiState = () => {
+    if (pendingPermission) {
+      const resolve2 = pendingPermission.resolve;
+      pendingPermission = null;
+      screen.setPermissionPrompt(null);
+      resolve2({ outcome: { outcome: "cancelled" } });
+    }
+    closeAgentText();
+    if (toolsBlockStartedAt !== null) {
+      toolsBlockEndedAt = Date.now();
+      renderToolsBlock();
+      screen.clearKey("tools");
+      toolStates.clear();
+      toolCallOrder.length = 0;
+      toolsBlockStartedAt = null;
+      toolsBlockEndedAt = null;
+      toolsExpanded = false;
+    }
+    screen.clearKey("plan");
+    if (pendingTurns > 0) {
+      adjustPendingTurns(-pendingTurns);
+    }
+  };
+  onDisconnectHook = () => {
+    screen.setBanner({ status: "disconnected", elapsedMs: void 0 });
+  };
+  onReconnect = async () => {
+    resetInFlightUiState();
+    const initReq = {
+      jsonrpc: "2.0",
+      id: `tui-reinit-${nanoid3()}`,
+      method: "initialize",
+      params: {
+        protocolVersion: 1,
+        clientCapabilities: {
+          fs: { readTextFile: false, writeTextFile: false },
+          terminal: false
+        },
+        clientInfo: { name: "hydra-acp-tui", version: "0.1.0" }
+      }
+    };
+    try {
+      await stream.request(initReq);
+    } catch {
+    }
+    const attachReq = {
+      jsonrpc: "2.0",
+      id: `tui-reattach-${nanoid3()}`,
+      method: "session/attach",
+      params: {
+        sessionId: resolvedSessionId,
+        historyPolicy: "none",
+        clientInfo: { name: "hydra-acp-tui", version: "0.1.0" },
+        ...upstreamSessionId !== void 0 ? {
+          _meta: {
+            [HYDRA_META_KEY]: {
+              resume: {
+                upstreamSessionId,
+                agentId: resolvedAgentId,
+                cwd: resolvedCwd
+              }
+            }
+          }
+        } : {}
+      }
+    };
+    try {
+      const resp = await stream.request(attachReq);
+      if (resp.error) {
+        throw new Error(resp.error.message);
+      }
+    } catch (err) {
+      screen.appendLines([
+        {
+          prefix: "  ",
+          body: `reattach failed: ${err.message}`,
+          bodyStyle: "tool-status-fail"
+        }
+      ]);
+    }
+    screen.setBanner({
+      status: pendingTurns > 0 ? "busy" : "ready",
+      elapsedMs: pendingTurns > 0 ? 0 : void 0
+    });
+  };
   conn.onClose((err) => {
     if (err) {
       term.red(`
@@ -4848,7 +6204,7 @@ async function resolveSession(term, config, opts) {
   const choice = await pickSession(term, {
     cwd,
     sessions,
-    coldLimit: config.sessionListColdLimit
+    config
   });
   if (choice.kind === "abort") {
     return null;
@@ -4869,23 +6225,47 @@ function newCtx(opts, cwd, config) {
     cwd
   };
 }
-async function openWs2(config) {
-  const protocol = config.daemon.tls ? "wss" : "ws";
-  const url = `${protocol}://${config.daemon.host}:${config.daemon.port}/acp`;
-  const ws = new WebSocket2(url, [
-    "acp.v1",
-    `hydra-acp-token.${config.daemon.authToken}`
-  ]);
-  await once(ws, "open");
-  return ws;
+function debugLogUpdate(update, event) {
+  writeDebugLine({
+    src: "session/update",
+    update,
+    event: event === null ? null : { kind: event.kind }
+  });
+}
+function writeDebugLine(payload) {
+  const override = process.env.HYDRA_TUI_DEBUG_LOG;
+  const target = override === void 0 ? paths.tuiLogFile() : override;
+  if (target.length === 0) {
+    return;
+  }
+  try {
+    rotateIfBig(target);
+    const line = JSON.stringify({
+      t: (/* @__PURE__ */ new Date()).toISOString(),
+      ...payload
+    });
+    appendFileSync(target, `${line}
+`);
+  } catch {
+  }
+}
+function rotateIfBig(target) {
+  try {
+    const stat3 = statSync(target);
+    if (stat3.size < TUI_LOG_MAX_BYTES) {
+      return;
+    }
+    renameSync(target, `${target}.0`);
+  } catch {
+  }
 }
-var PLAN_PREFIX_TEXT;
+var PLAN_PREFIX_TEXT, TUI_LOG_MAX_BYTES;
 var init_app = __esm({
   "src/tui/app.ts"() {
     "use strict";
     init_connection();
-    init_ws_stream();
     init_types();
+    init_resilient_ws();
     init_config();
     init_daemon_bootstrap();
     init_paths();
@@ -4897,6 +6277,7 @@ var init_app = __esm({
     init_render_update();
     init_format();
     PLAN_PREFIX_TEXT = "Plan mode is on. Outline what you would do without making any changes. Do not edit files, run shell commands, or otherwise execute side effects; produce a plan only.";
+    TUI_LOG_MAX_BYTES = 5 * 1024 * 1024;
   }
 });
 
@@ -5013,7 +6394,7 @@ import { setTimeout as sleep2 } from "timers/promises";
 
 // src/daemon/server.ts
 init_config();
-import * as fs6 from "fs";
+import * as fs8 from "fs";
 import * as fsp2 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
@@ -5185,6 +6566,9 @@ function planSpawn(agent, extraArgs = []) {
   throw new Error(`Agent ${agent.id} has no usable distribution method.`);
 }
 
+// src/core/session-manager.ts
+import * as fs6 from "fs/promises";
+
 // src/core/agent-instance.ts
 import { spawn } from "child_process";
 
@@ -5330,6 +6714,10 @@ init_paths();
 import * as fs4 from "fs/promises";
 import * as path2 from "path";
 import { z as z4 } from "zod";
+var PersistedAgentCommand = z4.object({
+  name: z4.string(),
+  description: z4.string().optional()
+});
 var SessionRecord = z4.object({
   version: z4.literal(1),
   sessionId: z4.string(),
@@ -5338,6 +6726,13 @@ var SessionRecord = z4.object({
   cwd: z4.string(),
   title: z4.string().optional(),
   agentArgs: z4.array(z4.string()).optional(),
+  // Snapshot of "what is currently true about this session" carried in
+  // meta.json so a late-attaching or cold-resurrected client can be
+  // told via the attach response _meta without depending on history
+  // replay of a snapshot-shaped notification.
+  currentModel: z4.string().optional(),
+  currentMode: z4.string().optional(),
+  agentCommands: z4.array(PersistedAgentCommand).optional(),
   createdAt: z4.string(),
   updatedAt: z4.string()
 });
@@ -5350,7 +6745,7 @@ function assertSafeId(id) {
 var SessionStore = class {
   async write(record) {
     assertSafeId(record.sessionId);
-    await fs4.mkdir(paths.sessionsDir(), { recursive: true });
+    await fs4.mkdir(paths.sessionDir(record.sessionId), { recursive: true });
     const full = { version: 1, ...record };
     await fs4.writeFile(
       paths.sessionFile(record.sessionId),
@@ -5383,10 +6778,18 @@ var SessionStore = class {
       return;
     }
     try {
-      await fs4.unlink(paths.sessionFile(sessionId));
+      await fs4.unlink(paths.sessionFile(sessionId));
+    } catch (err) {
+      const e = err;
+      if (e.code !== "ENOENT") {
+        throw err;
+      }
+    }
+    try {
+      await fs4.rmdir(paths.sessionDir(sessionId));
     } catch (err) {
       const e = err;
-      if (e.code !== "ENOENT") {
+      if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
         throw err;
       }
     }
@@ -5404,11 +6807,7 @@ var SessionStore = class {
     }
     const records = [];
     for (const entry of entries) {
-      if (!entry.endsWith(".json")) {
-        continue;
-      }
-      const id = entry.slice(0, -".json".length);
-      const record = await this.read(id);
+      const record = await this.read(entry);
       if (record) {
         records.push(record);
       }
@@ -5425,18 +6824,146 @@ function recordFromMemorySession(args) {
     cwd: args.cwd,
     title: args.title,
     agentArgs: args.agentArgs,
+    currentModel: args.currentModel,
+    currentMode: args.currentMode,
+    agentCommands: args.agentCommands,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
   };
 }
 
+// src/core/history-store.ts
+init_paths();
+import * as fs5 from "fs/promises";
+var SESSION_ID_PATTERN2 = /^[A-Za-z0-9_-]+$/;
+var MAX_ENTRIES = 1e3;
+var HistoryStore = class {
+  // Serialize writes per session id so appends and rewrites don't
+  // interleave JSONL lines on disk. The chain swallows errors so one
+  // failed append doesn't poison every subsequent write.
+  writeQueues = /* @__PURE__ */ new Map();
+  async append(sessionId, entry) {
+    if (!SESSION_ID_PATTERN2.test(sessionId)) {
+      return;
+    }
+    return this.enqueue(sessionId, async () => {
+      await fs5.mkdir(paths.sessionDir(sessionId), { recursive: true });
+      const line = JSON.stringify(entry) + "\n";
+      await fs5.appendFile(paths.historyFile(sessionId), line, {
+        encoding: "utf8",
+        mode: 384
+      });
+    });
+  }
+  async rewrite(sessionId, entries) {
+    if (!SESSION_ID_PATTERN2.test(sessionId)) {
+      return;
+    }
+    return this.enqueue(sessionId, async () => {
+      await fs5.mkdir(paths.sessionDir(sessionId), { recursive: true });
+      const body = entries.length === 0 ? "" : entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+      await fs5.writeFile(paths.historyFile(sessionId), body, {
+        encoding: "utf8",
+        mode: 384
+      });
+    });
+  }
+  async load(sessionId) {
+    if (!SESSION_ID_PATTERN2.test(sessionId)) {
+      return [];
+    }
+    const pending = this.writeQueues.get(sessionId);
+    if (pending) {
+      await pending;
+    }
+    let raw;
+    try {
+      raw = await fs5.readFile(paths.historyFile(sessionId), "utf8");
+    } catch (err) {
+      const e = err;
+      if (e.code === "ENOENT") {
+        return [];
+      }
+      throw err;
+    }
+    const out = [];
+    for (const line of raw.split("\n")) {
+      if (line.length === 0) {
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        continue;
+      }
+      const obj = parsed;
+      if (typeof obj.method !== "string") {
+        continue;
+      }
+      if (typeof obj.recordedAt !== "number") {
+        continue;
+      }
+      out.push({
+        method: obj.method,
+        params: obj.params,
+        recordedAt: obj.recordedAt
+      });
+    }
+    if (out.length > MAX_ENTRIES) {
+      return out.slice(-MAX_ENTRIES);
+    }
+    return out;
+  }
+  async delete(sessionId) {
+    if (!SESSION_ID_PATTERN2.test(sessionId)) {
+      return;
+    }
+    return this.enqueue(sessionId, async () => {
+      try {
+        await fs5.unlink(paths.historyFile(sessionId));
+      } catch (err) {
+        const e = err;
+        if (e.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      try {
+        await fs5.rmdir(paths.sessionDir(sessionId));
+      } catch (err) {
+        const e = err;
+        if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
+          throw err;
+        }
+      }
+    });
+  }
+  enqueue(sessionId, task) {
+    const prev = this.writeQueues.get(sessionId) ?? Promise.resolve();
+    const task$ = prev.then(task, task);
+    const settled = task$.catch(() => void 0);
+    this.writeQueues.set(sessionId, settled);
+    void settled.finally(() => {
+      if (this.writeQueues.get(sessionId) === settled) {
+        this.writeQueues.delete(sessionId);
+      }
+    });
+    return task$;
+  }
+};
+
 // src/core/session-manager.ts
+init_paths();
 init_types();
 var SessionManager = class {
   constructor(registry, spawner, store, options = {}) {
     this.registry = registry;
     this.spawner = spawner ?? ((opts) => AgentInstance.spawn(opts));
     this.store = store ?? new SessionStore();
+    this.histories = new HistoryStore();
     this.idleTimeoutMs = options.idleTimeoutMs ?? 0;
   }
   registry;
@@ -5444,7 +6971,12 @@ var SessionManager = class {
   resurrectionInflight = /* @__PURE__ */ new Map();
   spawner;
   store;
+  histories;
   idleTimeoutMs;
+  // Serialize meta.json read-modify-write operations per session id so
+  // concurrent snapshot updates (e.g. an agent emitting model + mode
+  // back-to-back) don't lose writes via interleaved reads.
+  metaWriteQueues = /* @__PURE__ */ new Map();
   async create(params) {
     const fresh = await this.bootstrapAgent({
       agentId: params.agentId,
@@ -5461,7 +6993,8 @@ var SessionManager = class {
       title: params.title,
       agentArgs: params.agentArgs,
       idleTimeoutMs: this.idleTimeoutMs,
-      spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] })
+      spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
+      historyStore: this.histories
     });
     await this.attachManagerHooks(session);
     return session;
@@ -5537,7 +7070,13 @@ var SessionManager = class {
       title: params.title,
       agentArgs: params.agentArgs,
       idleTimeoutMs: this.idleTimeoutMs,
-      spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] })
+      spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
+      historyStore: this.histories,
+      seedHistory: params.seedHistory,
+      currentModel: params.currentModel,
+      currentMode: params.currentMode,
+      agentCommands: params.agentCommands,
+      firstPromptSeeded: true
     });
     await this.attachManagerHooks(session);
     return session;
@@ -5591,6 +7130,7 @@ var SessionManager = class {
       this.sessions.delete(session.sessionId);
       if (deleteRecord) {
         void this.store.delete(session.sessionId).catch(() => void 0);
+        void this.histories.delete(session.sessionId).catch(() => void 0);
       }
     });
     session.onTitleChange((title) => {
@@ -5601,6 +7141,24 @@ var SessionManager = class {
         () => void 0
       );
     });
+    session.onModelChange((model) => {
+      void this.persistSnapshot(session.sessionId, { currentModel: model }).catch(
+        () => void 0
+      );
+    });
+    session.onModeChange((mode) => {
+      void this.persistSnapshot(session.sessionId, { currentMode: mode }).catch(
+        () => void 0
+      );
+    });
+    session.onAgentCommandsChange((commands) => {
+      void this.persistSnapshot(session.sessionId, {
+        agentCommands: commands.map((c) => ({
+          name: c.name,
+          ...c.description !== void 0 ? { description: c.description } : {}
+        }))
+      }).catch(() => void 0);
+    });
     this.sessions.set(session.sessionId, session);
     await this.store.write(
       recordFromMemorySession({
@@ -5609,22 +7167,45 @@ var SessionManager = class {
         agentId: session.agentId,
         cwd: session.cwd,
         title: session.title,
-        agentArgs: session.agentArgs
+        agentArgs: session.agentArgs,
+        currentModel: session.currentModel,
+        currentMode: session.currentMode
       })
     ).catch(() => void 0);
   }
+  // Resolve a session's recorded history without forcing a resurrect.
+  // Returns the in-memory snapshot if the session is hot, falls back
+  // to the on-disk history file otherwise. Returns undefined if the
+  // session id is unknown to both the live map and disk store, so the
+  // caller can distinguish "no history yet" (empty array) from "404".
+  async getHistory(sessionId) {
+    const live = this.sessions.get(sessionId);
+    if (live) {
+      return live.getHistorySnapshot();
+    }
+    const record = await this.store.read(sessionId);
+    if (!record) {
+      return void 0;
+    }
+    return this.histories.load(sessionId).catch(() => []);
+  }
   async loadFromDisk(sessionId) {
     const record = await this.store.read(sessionId);
     if (!record) {
       return void 0;
     }
+    const seedHistory = await this.histories.load(sessionId).catch(() => []);
     return {
       hydraSessionId: record.sessionId,
       upstreamSessionId: record.upstreamSessionId,
       agentId: record.agentId,
       cwd: record.cwd,
       title: record.title,
-      agentArgs: record.agentArgs
+      agentArgs: record.agentArgs,
+      seedHistory: seedHistory.length > 0 ? seedHistory : void 0,
+      currentModel: record.currentModel,
+      currentMode: record.currentMode,
+      agentCommands: record.agentCommands
     };
   }
   get(sessionId) {
@@ -5666,13 +7247,14 @@ var SessionManager = class {
         continue;
       }
       liveIds.add(session.sessionId);
+      const used = await historyMtimeIso(session.sessionId) ?? new Date(session.updatedAt).toISOString();
       entries.push({
         sessionId: session.sessionId,
         upstreamSessionId: session.upstreamSessionId,
         cwd: session.cwd,
         title: session.title,
         agentId: session.agentId,
-        updatedAt: new Date(session.updatedAt).toISOString(),
+        updatedAt: used,
         attachedClients: session.attachedCount,
         status: "live"
       });
@@ -5685,13 +7267,14 @@ var SessionManager = class {
       if (filter.cwd && r.cwd !== filter.cwd) {
         continue;
       }
+      const used = await historyMtimeIso(r.sessionId) ?? r.updatedAt;
       entries.push({
         sessionId: r.sessionId,
         upstreamSessionId: r.upstreamSessionId,
         cwd: r.cwd,
         title: r.title,
         agentId: r.agentId,
-        updatedAt: r.updatedAt,
+        updatedAt: used,
         attachedClients: 0,
         status: "cold"
       });
@@ -5707,19 +7290,25 @@ var SessionManager = class {
     await this.store.delete(sessionId).catch(() => void 0);
     return true;
   }
+  async hasRecord(sessionId) {
+    const record = await this.store.read(sessionId).catch(() => void 0);
+    return record !== void 0;
+  }
   // Persist a title update from Session.setTitle. The on-disk record
   // was written at create time; updating it here keeps the session
   // record's title in sync with what was broadcast to clients so a
   // daemon restart (and later resurrect) restores the same title.
   async persistTitle(sessionId, title) {
-    const record = await this.store.read(sessionId);
-    if (!record) {
-      return;
-    }
-    await this.store.write({
-      ...record,
-      title,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    await this.enqueueMetaWrite(sessionId, async () => {
+      const record = await this.store.read(sessionId);
+      if (!record) {
+        return;
+      }
+      await this.store.write({
+        ...record,
+        title,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
     });
   }
   // Persist an agent swap from /hydra switch. The on-disk record's
@@ -5727,28 +7316,71 @@ var SessionManager = class {
   // later resurrect) brings the session back up on the agent the user
   // most recently switched to, not the one it was originally created on.
   async persistAgentChange(sessionId, agentId, upstreamSessionId) {
-    const record = await this.store.read(sessionId);
-    if (!record) {
-      return;
-    }
-    await this.store.write({
-      ...record,
-      agentId,
-      upstreamSessionId,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    await this.enqueueMetaWrite(sessionId, async () => {
+      const record = await this.store.read(sessionId);
+      if (!record) {
+        return;
+      }
+      await this.store.write({
+        ...record,
+        agentId,
+        upstreamSessionId,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+  }
+  // Update one or more snapshot fields (model, mode, commands) in
+  // meta.json. Used so cold-resurrect can deliver the latest snapshot
+  // to attaching clients via the attach response _meta. No-op if the
+  // session record has gone away (race with deleteRecord).
+  async persistSnapshot(sessionId, update) {
+    await this.enqueueMetaWrite(sessionId, async () => {
+      const record = await this.store.read(sessionId);
+      if (!record) {
+        return;
+      }
+      await this.store.write({
+        ...record,
+        ...update.currentModel !== void 0 ? { currentModel: update.currentModel } : {},
+        ...update.currentMode !== void 0 ? { currentMode: update.currentMode } : {},
+        ...update.agentCommands !== void 0 ? { agentCommands: update.agentCommands } : {},
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
     });
   }
+  // Serialize meta.json writes per session id so concurrent
+  // read-modify-write operations don't interleave reads.
+  enqueueMetaWrite(sessionId, task) {
+    const prev = this.metaWriteQueues.get(sessionId) ?? Promise.resolve();
+    const next = prev.then(task, task);
+    const settled = next.catch(() => void 0);
+    this.metaWriteQueues.set(sessionId, settled);
+    void settled.finally(() => {
+      if (this.metaWriteQueues.get(sessionId) === settled) {
+        this.metaWriteQueues.delete(sessionId);
+      }
+    });
+    return next;
+  }
   async closeAll() {
     const sessions = [...this.sessions.values()];
     await Promise.allSettled(sessions.map((s) => s.close()));
     this.sessions.clear();
   }
 };
+async function historyMtimeIso(sessionId) {
+  try {
+    const st = await fs6.stat(paths.historyFile(sessionId));
+    return new Date(st.mtimeMs).toISOString();
+  } catch {
+    return void 0;
+  }
+}
 
 // src/core/extensions.ts
 init_paths();
 import { spawn as spawn2 } from "child_process";
-import * as fs5 from "fs";
+import * as fs7 from "fs";
 import * as fsp from "fs/promises";
 import * as path3 from "path";
 var RESTART_BASE_MS = 1e3;
@@ -6031,7 +7663,7 @@ var ExtensionManager = class {
     }
     const ext = entry.config;
     const command = ext.command.length > 0 ? ext.command : [ext.name];
-    const logStream = fs5.createWriteStream(paths.extensionLogFile(ext.name), {
+    const logStream = fs7.createWriteStream(paths.extensionLogFile(ext.name), {
       flags: "a"
     });
     logStream.write(
@@ -6081,7 +7713,7 @@ var ExtensionManager = class {
     }
     if (typeof child.pid === "number") {
       try {
-        fs5.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
+        fs7.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
 `, {
           encoding: "utf8",
           mode: 384
@@ -6106,7 +7738,7 @@ var ExtensionManager = class {
     });
     child.on("exit", (code, signal) => {
       try {
-        fs5.unlinkSync(paths.extensionPidFile(ext.name));
+        fs7.unlinkSync(paths.extensionPidFile(ext.name));
       } catch {
       }
       logStream.write(
@@ -6222,8 +7854,7 @@ init_config();
 function registerSessionRoutes(app, manager, defaults) {
   app.get("/v1/sessions", async (request) => {
     const query = request.query;
-    const all = query?.all === "true" || query?.all === "1";
-    const sessions = await manager.list({ cwd: query?.cwd, all });
+    const sessions = await manager.list({ cwd: query?.cwd });
     return { sessions };
   });
   app.post("/v1/sessions", async (request, reply) => {
@@ -6245,6 +7876,22 @@ function registerSessionRoutes(app, manager, defaults) {
       reply.code(500).send({ error: err.message });
     }
   });
+  app.post("/v1/sessions/:id/kill", async (request, reply) => {
+    const raw = request.params.id;
+    const id = await manager.resolveCanonicalId(raw) ?? raw;
+    const session = manager.get(id);
+    if (session) {
+      await session.close({ deleteRecord: false });
+      reply.code(204).send();
+      return;
+    }
+    const exists = await manager.hasRecord(id);
+    if (!exists) {
+      reply.code(404).send({ error: "session not found" });
+      return;
+    }
+    reply.code(204).send();
+  });
   app.delete("/v1/sessions/:id", async (request, reply) => {
     const raw = request.params.id;
     const id = await manager.resolveCanonicalId(raw) ?? raw;
@@ -6261,6 +7908,50 @@ function registerSessionRoutes(app, manager, defaults) {
     }
     reply.code(204).send();
   });
+  app.get("/v1/sessions/:id/history", async (request, reply) => {
+    const raw = request.params.id;
+    const query = request.query;
+    const follow = query?.follow === "1" || query?.follow === "true";
+    const id = await manager.resolveCanonicalId(raw) ?? raw;
+    const live = manager.get(id);
+    let snapshot;
+    let unsubscribe;
+    if (live) {
+      snapshot = live.getHistorySnapshot();
+      if (follow) {
+        unsubscribe = live.onBroadcast((entry) => {
+          if (reply.raw.writableEnded) {
+            return;
+          }
+          reply.raw.write(JSON.stringify(entry) + "\n");
+        });
+      }
+    } else {
+      const cold = await manager.getHistory(id);
+      if (cold === void 0) {
+        reply.code(404).send({ error: "session not found" });
+        return reply;
+      }
+      snapshot = cold;
+    }
+    reply.raw.setHeader("Content-Type", "application/x-ndjson");
+    reply.raw.setHeader("Cache-Control", "no-cache");
+    reply.raw.statusCode = 200;
+    for (const entry of snapshot ?? []) {
+      reply.raw.write(JSON.stringify(entry) + "\n");
+    }
+    if (!unsubscribe) {
+      reply.raw.end();
+      return reply;
+    }
+    request.raw.on("close", () => {
+      unsubscribe?.();
+      if (!reply.raw.writableEnded) {
+        reply.raw.end();
+      }
+    });
+    return reply;
+  });
 }
 
 // src/daemon/routes/agents.ts
@@ -6408,6 +8099,16 @@ function parseRegisterBody(body) {
   };
 }
 
+// src/daemon/routes/config.ts
+function registerConfigRoutes(app, defaults) {
+  app.get("/v1/config", async () => {
+    return {
+      defaultAgent: defaults.defaultAgent,
+      defaultCwd: defaults.defaultCwd
+    };
+  });
+}
+
 // src/daemon/acp-ws.ts
 init_connection();
 init_ws_stream();
@@ -6651,6 +8352,19 @@ function buildResponseMeta(session) {
   if (session.agentArgs && session.agentArgs.length > 0) {
     ours.agentArgs = session.agentArgs;
   }
+  if (session.currentModel !== void 0) {
+    ours.currentModel = session.currentModel;
+  }
+  if (session.currentMode !== void 0) {
+    ours.currentMode = session.currentMode;
+  }
+  const commands = session.mergedAvailableCommands();
+  if (commands.length > 0) {
+    ours.availableCommands = commands;
+  }
+  if (session.turnStartedAt !== void 0) {
+    ours.turnStartedAt = session.turnStartedAt;
+  }
   return mergeMeta(session.agentMeta, ours);
 }
 function buildInitializeResult() {
@@ -6736,6 +8450,10 @@ async function startDaemon(config) {
   });
   registerAgentRoutes(app, registry);
   registerExtensionRoutes(app, extensions);
+  registerConfigRoutes(app, {
+    defaultAgent: config.defaultAgent,
+    defaultCwd: config.defaultCwd
+  });
   registerAcpWsEndpoint(app, {
     config,
     manager,
@@ -6771,7 +8489,7 @@ async function startDaemon(config) {
     await manager.closeAll();
     await app.close();
     try {
-      fs6.unlinkSync(paths.pidFile());
+      fs8.unlinkSync(paths.pidFile());
     } catch {
     }
     try {
@@ -6810,13 +8528,13 @@ function ensureLoopbackOrTls(config) {
 init_daemon_bootstrap();
 
 // src/cli/commands/log-tail.ts
-import * as fs7 from "fs";
+import * as fs9 from "fs";
 import * as fsp3 from "fs/promises";
 async function runLogTail(logPath, argv, notFoundMessage) {
   const opts = parseLogTailFlags(argv);
-  let stat2;
+  let stat3;
   try {
-    stat2 = await fsp3.stat(logPath);
+    stat3 = await fsp3.stat(logPath);
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
@@ -6827,14 +8545,14 @@ async function runLogTail(logPath, argv, notFoundMessage) {
     }
     throw err;
   }
-  let position = await printTail(logPath, stat2.size, opts.tail);
+  let position = await printTail(logPath, stat3.size, opts.tail);
   if (!opts.follow) {
     return;
   }
   process.stdout.write(`-- following ${logPath} --
 `);
   let pending = false;
-  const watcher = fs7.watch(logPath, () => {
+  const watcher = fs9.watch(logPath, () => {
     if (pending) {
       return;
     }
@@ -7592,226 +9310,7 @@ function maxLen3(headerCell, values) {
 // src/shim/proxy.ts
 init_config();
 init_daemon_bootstrap();
-
-// src/shim/resilient-ws.ts
-init_ws_stream();
-init_types();
-import { setTimeout as sleep3 } from "timers/promises";
-import { WebSocket } from "ws";
-var BACKOFF_INITIAL_MS = 200;
-var BACKOFF_MAX_MS = 5e3;
-var BACKOFF_MULTIPLIER = 2;
-var MAX_RECONNECT_ATTEMPTS = 60;
-var ResilientWsStream = class {
-  constructor(opts) {
-    this.opts = opts;
-  }
-  opts;
-  current;
-  outboundQueue = [];
-  messageHandlers = [];
-  closeHandlers = [];
-  destroyed = false;
-  firstConnect = true;
-  reconnectInFlight;
-  connectGate;
-  releaseConnectGate;
-  pendingRequests = /* @__PURE__ */ new Map();
-  async start() {
-    await this.connectWithRetry();
-  }
-  onMessage(handler) {
-    this.messageHandlers.push(handler);
-  }
-  onClose(handler) {
-    this.closeHandlers.push(handler);
-  }
-  async send(message) {
-    if (this.destroyed) {
-      throw new Error("resilient ws stream is destroyed");
-    }
-    if (this.connectGate || !this.current) {
-      this.outboundQueue.push(message);
-      return;
-    }
-    try {
-      await this.current.send(message);
-    } catch (err) {
-      this.outboundQueue.push(message);
-      this.scheduleReconnect(err);
-    }
-  }
-  // Send a request directly and resolve when the matching response arrives
-  // on the same connection. Used by onConnect handlers to await replay-attach
-  // responses before letting the outbound queue drain. Bypasses the
-  // connectGate intentionally.
-  async request(message) {
-    if (this.destroyed) {
-      throw new Error("resilient ws stream is destroyed");
-    }
-    if (!this.current) {
-      throw new Error("resilient ws stream not connected");
-    }
-    const id = message.id;
-    const promise = new Promise((resolve2, reject) => {
-      this.pendingRequests.set(id, { resolve: resolve2, reject });
-    });
-    try {
-      await this.current.send(message);
-    } catch (err) {
-      this.pendingRequests.delete(id);
-      throw err;
-    }
-    return promise;
-  }
-  async close() {
-    this.destroyed = true;
-    if (this.current) {
-      await this.current.close().catch(() => void 0);
-    }
-    for (const handler of this.closeHandlers) {
-      handler();
-    }
-  }
-  async connectWithRetry() {
-    let attempt = 0;
-    let backoff = BACKOFF_INITIAL_MS;
-    while (!this.destroyed) {
-      try {
-        const stream = await openWs(this.opts.url, this.opts.subprotocols);
-        this.bindStream(stream);
-        const wasFirst = this.firstConnect;
-        this.firstConnect = false;
-        this.connectGate = new Promise((resolve2) => {
-          this.releaseConnectGate = resolve2;
-        });
-        try {
-          if (this.opts.onConnect) {
-            try {
-              await this.opts.onConnect(wasFirst);
-            } catch (err) {
-              this.log(
-                `hydra-acp: post-connect handler failed: ${err.message}`
-              );
-            }
-          }
-        } finally {
-          this.releaseConnectGate?.();
-          this.releaseConnectGate = void 0;
-          this.connectGate = void 0;
-        }
-        await this.flushQueue();
-        return;
-      } catch (err) {
-        attempt += 1;
-        if (this.opts.onConnectFailure) {
-          this.opts.onConnectFailure(err);
-        }
-        if (attempt >= MAX_RECONNECT_ATTEMPTS) {
-          throw new Error(
-            `hydra-acp: gave up reconnecting after ${attempt} attempts: ${err.message}`
-          );
-        }
-        this.log(
-          `hydra-acp: connect attempt ${attempt} failed (${err.message}); retrying in ${backoff}ms`
-        );
-        await sleep3(backoff);
-        backoff = Math.min(backoff * BACKOFF_MULTIPLIER, BACKOFF_MAX_MS);
-      }
-    }
-  }
-  bindStream(stream) {
-    this.current = stream;
-    stream.onMessage((msg) => {
-      if (isResponse(msg)) {
-        const pending = this.pendingRequests.get(msg.id);
-        if (pending) {
-          this.pendingRequests.delete(msg.id);
-          pending.resolve(msg);
-        }
-      }
-      for (const handler of this.messageHandlers) {
-        handler(msg);
-      }
-    });
-    stream.onClose((err) => {
-      if (this.destroyed) {
-        return;
-      }
-      this.current = void 0;
-      if (this.pendingRequests.size > 0) {
-        const reason = err ?? new Error("ws closed before response");
-        for (const { reject } of this.pendingRequests.values()) {
-          reject(reason);
-        }
-        this.pendingRequests.clear();
-      }
-      this.scheduleReconnect(err);
-    });
-  }
-  async flushQueue() {
-    if (!this.current) {
-      return;
-    }
-    const queue = this.outboundQueue;
-    this.outboundQueue = [];
-    for (const msg of queue) {
-      try {
-        await this.current.send(msg);
-      } catch (err) {
-        this.outboundQueue.unshift(msg);
-        this.scheduleReconnect(err);
-        return;
-      }
-    }
-  }
-  scheduleReconnect(err) {
-    if (this.destroyed || this.reconnectInFlight) {
-      return;
-    }
-    this.log(
-      `hydra-acp: connection lost (${err?.message ?? "no error"}); reconnecting...`
-    );
-    this.reconnectInFlight = (async () => {
-      try {
-        await this.connectWithRetry();
-      } catch (final) {
-        for (const handler of this.closeHandlers) {
-          handler(final);
-        }
-        this.destroyed = true;
-      } finally {
-        this.reconnectInFlight = void 0;
-      }
-    })();
-  }
-  log(line) {
-    if (this.opts.log) {
-      this.opts.log(line);
-      return;
-    }
-    process.stderr.write(`${line}
-`);
-  }
-};
-function isResponse(msg) {
-  return !("method" in msg) && "id" in msg && msg.id !== void 0;
-}
-async function openWs(url, subprotocols) {
-  return new Promise((resolve2, reject) => {
-    const ws = new WebSocket(url, subprotocols);
-    const onOpen = () => {
-      ws.off("error", onError);
-      resolve2(wsToMessageStream(ws));
-    };
-    const onError = (err) => {
-      ws.off("open", onOpen);
-      reject(err);
-    };
-    ws.once("open", onOpen);
-    ws.once("error", onError);
-  });
-}
+init_resilient_ws();
 
 // src/shim/session-tracker.ts
 init_types();
@@ -8232,6 +9731,10 @@ async function main() {
         await runSessionsKill(positional[2]);
         return;
       }
+      if (sub === "rm") {
+        await runSessionsRm(positional[2]);
+        return;
+      }
       process.stderr.write(`Unknown sessions subcommand: ${sub}
 `);
       process.exit(2);
@@ -8343,7 +9846,8 @@ function printHelp() {
       "  hydra-acp daemon start|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 kill <id>       Kill a session (live or cold)",
+      "  hydra-acp sessions kill <id>       Demote a live session to cold (keeps the on-disk record)",
+      "  hydra-acp sessions rm <id>         Remove a session entirely (live or cold)",
       "  hydra-acp extensions list                   List configured extensions and live state",
       "  hydra-acp extensions add <name> [opts]      Add an extension to config",
       "  hydra-acp extensions remove <name>          Remove an extension from config",