@hydra-acp/cli 0.1.2 → 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;
@@ -43,7 +48,8 @@ var init_paths = __esm({
       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")
     };
   }
 });
@@ -157,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({
@@ -182,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 })
     });
   }
 });
@@ -226,6 +236,9 @@ function extractHydraMeta(meta) {
   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) {
@@ -703,6 +716,9 @@ var init_session = __esm({
         }
         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];
@@ -767,6 +783,29 @@ 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
@@ -844,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;
         });
@@ -938,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 });
       }
@@ -986,7 +1038,7 @@ 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;
         }
@@ -1365,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();
@@ -1650,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();
@@ -1685,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(
@@ -1732,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");
@@ -1748,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}` }
@@ -1757,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) {
@@ -1768,7 +1941,7 @@ var init_sessions = __esm({
   "src/cli/commands/sessions.ts"() {
     "use strict";
     init_config();
-    init_session();
+    init_session_row();
   }
 });
 
@@ -2008,12 +2181,12 @@ var init_resilient_ws = __esm({
 });
 
 // src/tui/history.ts
-import { promises as fs9 } from "fs";
+import { promises as fs10 } from "fs";
 import * as path4 from "path";
 async function loadHistory(file) {
   let text;
   try {
-    text = await fs9.readFile(file, "utf8");
+    text = await fs10.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return [];
@@ -2053,9 +2226,9 @@ function appendEntry(history, entry) {
   return out;
 }
 async function saveHistory(file, history) {
-  await fs9.mkdir(path4.dirname(file), { recursive: true });
+  await fs10.mkdir(path4.dirname(file), { recursive: true });
   const lines = history.map((entry) => JSON.stringify(entry));
-  await fs9.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({
@@ -2096,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) {
@@ -2123,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);
+  };
+  const paintSessionRow = (sessionIdx) => {
+    const label = sessionLines[sessionIdx] ?? "";
+    if (selectedIdx === sessionIdx + 1) {
+      term.brightWhite.bgBlue.noFormat(`\u276F ${label}`);
+    } else {
+      term.noFormat(`  ${label}`);
+    }
+  };
+  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 ")}`;
+  };
+  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());
+  };
+  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");
-      process.exit(130);
     }
+    paintIndicator();
+    term("\n");
   };
-  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 repaintNewItem = () => {
+    term.moveTo(1, startRow).eraseLineAfter();
+    paintNewItem();
   };
-  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 repaintSessionRow = (sessionIdx) => {
+    if (sessionIdx < scrollOffset || sessionIdx >= scrollOffset + viewportSize) {
+      return;
+    }
+    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 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))
-  };
+function readTermHeight(term) {
+  return term.height ?? 24;
 }
-function maxLen4(headerCell, values) {
-  let max = headerCell.length;
-  for (const v of values) {
-    if (v.length > max) {
-      max = v.length;
-    }
-  }
-  return max;
+function readTermWidth(term) {
+  return term.width ?? 80;
 }
-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 formatNewSessionLabel(cwd, maxWidth) {
+  const prefix = "+ New session in ";
+  const budget = Math.max(1, maxWidth - prefix.length);
+  return prefix + truncateMiddle(cwd, budget);
 }
-var HEADER;
+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++) {
@@ -2348,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);
@@ -2542,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";
@@ -2562,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;
@@ -2582,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 = [];
@@ -2596,6 +3067,7 @@ var init_screen = __esm({
         queued: 0
       };
       header = { agent: "?", cwd: "?", sessionId: "?" };
+      lastWindowTitle = null;
       resizeHandler;
       keyHandler;
       mouseHandler;
@@ -2616,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);
@@ -2716,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
@@ -2734,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) {
@@ -2755,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) {
@@ -2772,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
@@ -2793,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 {
@@ -2800,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;
             }
           }
@@ -2813,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();
@@ -2840,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();
@@ -2862,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) {
@@ -2936,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
@@ -3010,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
@@ -3045,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;
@@ -3060,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();
@@ -3075,38 +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 sid = shortId(this.header.sessionId);
         const title = this.header.title?.trim();
-        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 cwdCap = Math.max(8, Math.floor(variableRoom / 2));
-          cwdRoom = Math.min(this.header.cwd.length, cwdCap);
-          titleRoom = Math.max(8, variableRoom - cwdRoom);
-        } else {
-          titleRoom = 0;
-          cwdRoom = variableRoom;
-        }
-        this.term.bold("hydra")(" \xB7 ").cyan(this.header.agent)(" \xB7 ").dim(truncate(this.header.cwd, cwdRoom))(" \xB7 ").yellow(sid);
-        if (title) {
-          this.term(" \xB7 ").bold(truncate(title, titleRoom));
-        }
-        if (usage) {
-          const col = Math.max(1, w - usage.length + 1);
-          this.term.moveTo(col, 1);
-          this.term.dim(usage);
-        }
+        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;
@@ -3115,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() {
@@ -3160,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() {
@@ -3194,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() {
@@ -3225,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() {
@@ -3247,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;
@@ -3261,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++) {
@@ -3289,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 {
@@ -3297,38 +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 if (this.banner.status === "disconnected") {
-          this.term.brightRed(`${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) {
@@ -3378,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) {
@@ -3447,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;
@@ -3555,6 +4213,9 @@ var init_input = __esm({
           case "ctrl-w":
             this.killWord();
             return [];
+          case "ctrl-y":
+            this.yank();
+            return [];
           case "escape":
             return [];
         }
@@ -3648,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() {
@@ -3668,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;
@@ -4333,6 +5012,7 @@ var init_format = __esm({
 });
 
 // src/tui/app.ts
+import { appendFileSync, statSync, renameSync } from "fs";
 import { nanoid as nanoid3 } from "nanoid";
 import termkit from "terminal-kit";
 async function runTuiApp(opts) {
@@ -4350,6 +5030,8 @@ async function runSession(term, config, opts) {
     term.grabInput(false);
     process.exit(0);
   }
+  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}`];
@@ -4396,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(() => {
@@ -4406,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;
@@ -4423,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") {
@@ -4542,6 +5228,7 @@ async function runSession(term, config, opts) {
   let initialModel;
   let initialMode;
   let initialCommands;
+  let initialTurnStartedAt;
   if (ctx.sessionId === "__new__") {
     const created = await conn.request("session/new", {
       cwd: ctx.cwd,
@@ -4562,6 +5249,7 @@ async function runSession(term, config, opts) {
     }
     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 }
@@ -4587,20 +5275,26 @@ async function runSession(term, config, opts) {
     }
     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 }
       );
     }
   }
-  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)) {
@@ -4767,11 +5461,18 @@ async function runSession(term, config, opts) {
   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;
@@ -4846,6 +5547,7 @@ async function runSession(term, config, opts) {
   };
   const teardown = () => {
     process.off("SIGINT", sigintHandler);
+    screen.clearWindowTitle();
     screen.stop();
     saveHistory(historyFile, history).catch(() => void 0);
     void stream.close().catch(() => void 0);
@@ -4861,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;
@@ -4901,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;
@@ -5088,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: () => {
@@ -5118,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" }
@@ -5174,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)}`;
@@ -5277,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;
@@ -5317,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;
@@ -5342,6 +6058,23 @@ 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;
@@ -5351,13 +6084,9 @@ async function runSession(term, config, opts) {
     }
     closeAgentText();
     if (toolsBlockStartedAt !== null) {
-      if (toolCallOrder.length > 0) {
-        toolsBlockEndedAt = Date.now();
-        renderToolsBlock();
-        screen.clearKey("tools");
-      } else {
-        screen.removeBlock("tools");
-      }
+      toolsBlockEndedAt = Date.now();
+      renderToolsBlock();
+      screen.clearKey("tools");
       toolStates.clear();
       toolCallOrder.length = 0;
       toolsBlockStartedAt = null;
@@ -5427,7 +6156,7 @@ async function runSession(term, config, opts) {
       ]);
     }
     screen.setBanner({
-      status: pendingTurns > 0 ? "running" : "ready",
+      status: pendingTurns > 0 ? "busy" : "ready",
       elapsedMs: pendingTurns > 0 ? 0 : void 0
     });
   };
@@ -5475,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;
@@ -5496,7 +6225,41 @@ function newCtx(opts, cwd, config) {
     cwd
   };
 }
-var PLAN_PREFIX_TEXT;
+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, TUI_LOG_MAX_BYTES;
 var init_app = __esm({
   "src/tui/app.ts"() {
     "use strict";
@@ -5514,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;
   }
 });
 
@@ -5630,7 +6394,7 @@ import { setTimeout as sleep2 } from "timers/promises";
 
 // src/daemon/server.ts
 init_config();
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as fsp2 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
@@ -5802,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";
 
@@ -6189,6 +6956,7 @@ var HistoryStore = class {
 };
 
 // src/core/session-manager.ts
+init_paths();
 init_types();
 var SessionManager = class {
   constructor(registry, spawner, store, options = {}) {
@@ -6307,7 +7075,8 @@ var SessionManager = class {
       seedHistory: params.seedHistory,
       currentModel: params.currentModel,
       currentMode: params.currentMode,
-      agentCommands: params.agentCommands
+      agentCommands: params.agentCommands,
+      firstPromptSeeded: true
     });
     await this.attachManagerHooks(session);
     return session;
@@ -6478,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"
       });
@@ -6497,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"
       });
@@ -6519,6 +7290,10 @@ 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
@@ -6593,11 +7368,19 @@ var SessionManager = class {
     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 fs6 from "fs";
+import * as fs7 from "fs";
 import * as fsp from "fs/promises";
 import * as path3 from "path";
 var RESTART_BASE_MS = 1e3;
@@ -6880,7 +7663,7 @@ var ExtensionManager = class {
     }
     const ext = entry.config;
     const command = ext.command.length > 0 ? ext.command : [ext.name];
-    const logStream = fs6.createWriteStream(paths.extensionLogFile(ext.name), {
+    const logStream = fs7.createWriteStream(paths.extensionLogFile(ext.name), {
       flags: "a"
     });
     logStream.write(
@@ -6930,7 +7713,7 @@ var ExtensionManager = class {
     }
     if (typeof child.pid === "number") {
       try {
-        fs6.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
+        fs7.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
 `, {
           encoding: "utf8",
           mode: 384
@@ -6955,7 +7738,7 @@ var ExtensionManager = class {
     });
     child.on("exit", (code, signal) => {
       try {
-        fs6.unlinkSync(paths.extensionPidFile(ext.name));
+        fs7.unlinkSync(paths.extensionPidFile(ext.name));
       } catch {
       }
       logStream.write(
@@ -7093,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;
@@ -7300,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();
@@ -7553,6 +8362,9 @@ function buildResponseMeta(session) {
   if (commands.length > 0) {
     ours.availableCommands = commands;
   }
+  if (session.turnStartedAt !== void 0) {
+    ours.turnStartedAt = session.turnStartedAt;
+  }
   return mergeMeta(session.agentMeta, ours);
 }
 function buildInitializeResult() {
@@ -7638,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,
@@ -7673,7 +8489,7 @@ async function startDaemon(config) {
     await manager.closeAll();
     await app.close();
     try {
-      fs7.unlinkSync(paths.pidFile());
+      fs8.unlinkSync(paths.pidFile());
     } catch {
     }
     try {
@@ -7712,13 +8528,13 @@ function ensureLoopbackOrTls(config) {
 init_daemon_bootstrap();
 
 // src/cli/commands/log-tail.ts
-import * as fs8 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") {
@@ -7729,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 = fs8.watch(logPath, () => {
+  const watcher = fs9.watch(logPath, () => {
     if (pending) {
       return;
     }
@@ -8915,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);
@@ -9026,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",