@hydra-acp/cli 0.1.59 → 0.1.60

package/dist/cli.js

@@ -303,6 +303,34 @@ async function loadConfig() {
   await migrateLegacyAuthToken();
   return HydraConfig.parse(await readConfigFile());
 }
+async function updateRawConfig(mutate) {
+  await migrateLegacyAuthToken();
+  const raw = await readConfigFile();
+  mutate(raw);
+  HydraConfig.parse(raw);
+  await writeJsonAtomic(paths.config(), raw, { mode: 384 });
+}
+async function setTuiConfigValue(key, value) {
+  await updateRawConfig((raw) => {
+    const tui = raw.tui && typeof raw.tui === "object" && !Array.isArray(raw.tui) ? raw.tui : {};
+    tui[key] = value;
+    raw.tui = tui;
+  });
+}
+async function setDefaultAgent(agentId, modelId) {
+  await updateRawConfig((raw) => {
+    raw.defaultAgent = agentId;
+    if (modelId !== void 0) {
+      const models = raw.defaultModels && typeof raw.defaultModels === "object" ? raw.defaultModels : {};
+      models[agentId] = modelId;
+      raw.defaultModels = models;
+    }
+  });
+}
+async function hasConfiguredDefaultAgent() {
+  const raw = await readConfigFile();
+  return typeof raw.defaultAgent === "string" && raw.defaultAgent.length > 0;
+}
 function expandHome(p) {
   if (p === "~" || p === "$HOME") {
     return homedir2();
@@ -385,7 +413,7 @@ var init_config = __esm({
       // Width cap on the cwd column in the `sessions list` output and the
       // TUI picker. Set higher if you keep deeply-nested working directories
       // and want them visible; the elastic title column shrinks to make room.
-      cwdColumnMaxWidth: z.number().int().positive().default(24),
+      cwdColumnMaxWidth: z.number().int().positive().default(32),
       // When true (default), emit OSC 9;4 progress-bar control codes so the
       // host terminal can show an indeterminate busy indicator (taskbar pulse
       // on Windows Terminal, dock badge on KDE/Konsole, etc.) while a turn is
@@ -436,7 +464,28 @@ var init_config = __esm({
       // The diff payload is extracted from the ACP wire (content[]
       // type:"diff" entries, falling back to rawInput shapes), so any agent
       // that emits one of those shapes gets the treatment.
-      showFileUpdates: z.enum(["none", "edit", "diff"]).default("edit")
+      showFileUpdates: z.enum(["none", "edit", "diff"]).default("edit"),
+      // Columns shown in the `sessions list` output and the TUI picker, in
+      // the given order — so this controls both which columns appear and
+      // their left-to-right order. Valid names: session, upstream, host,
+      // state, agent, model, age, cwd, title, cost. Omit to use the built-in
+      // default (session, state, agent, age, cwd, title, cost — UPSTREAM,
+      // HOST, and MODEL hidden). The CLI's `--columns` flag overrides this
+      // per-invocation. Duplicate or unknown names are rejected.
+      sessionColumns: z.array(
+        z.enum([
+          "session",
+          "upstream",
+          "host",
+          "state",
+          "agent",
+          "model",
+          "age",
+          "cwd",
+          "title",
+          "cost"
+        ])
+      ).nonempty().optional()
     });
     ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
     ExtensionBody = z.object({
@@ -457,7 +506,7 @@ var init_config = __esm({
     HydraConfig = z.object({
       daemon: DaemonConfig.default({}),
       registry: RegistryConfig.default({ url: REGISTRY_URL_DEFAULT, ttlHours: 24 }),
-      defaultAgent: z.string().default("claude-acp"),
+      defaultAgent: z.string().default("opencode"),
       // Optional per-agent default model id. When a brand-new agent process
       // is spawned (session/new path), hydra issues session/set_model with
       // the matching entry so the user lands on their preferred model from
@@ -505,7 +554,7 @@ var init_config = __esm({
         maxScrollbackLines: 1e4,
         mouse: false,
         logMaxBytes: 5 * 1024 * 1024,
-        cwdColumnMaxWidth: 24,
+        cwdColumnMaxWidth: 32,
         progressIndicator: true,
         defaultEnterAction: "amend",
         showThoughts: true,
@@ -1122,7 +1171,8 @@ function sessionListEntryToWire(entry) {
   const hydraMeta = {
     attachedClients: entry.attachedClients,
     status: entry.status,
-    busy: entry.busy
+    busy: entry.busy,
+    awaitingInput: entry.awaitingInput
   };
   if (entry.agentId !== void 0) {
     hydraMeta.agentId = entry.agentId;
@@ -1239,6 +1289,17 @@ var init_types = __esm({
       // to a cold session does not resurrect or spawn an agent — just
       // streams history from disk. Used by the TUI's view-only mode.
       readonly: z3.boolean().optional(),
+      // Debug-only replay pacing. When "drip", the daemon skips chunk
+      // coalescing and re-emits each recorded session/update individually,
+      // spacing them by their original recordedAt deltas (scaled by
+      // dripSpeed, with a per-gap cap) so a session's streaming render can
+      // be reproduced at its real granularity for flicker investigation.
+      // Omitted/"instant" preserves the normal coalesced, as-fast-as-possible
+      // replay.
+      replayMode: z3.enum(["instant", "drip"]).optional(),
+      // Multiplier applied to original inter-entry gaps in drip mode. >1
+      // compresses time (faster), <1 stretches it. Defaults to 1.
+      dripSpeed: z3.number().positive().optional(),
       _meta: z3.record(z3.unknown()).optional()
     });
     HYDRA_META_KEY = "hydra-acp";
@@ -1294,6 +1355,11 @@ var init_types = __esm({
       // Always false for cold sessions. Lets pickers render a busy dot
       // without having to attach.
       busy: z3.boolean().default(false),
+      // True when the agent is blocked on the user (an outstanding
+      // session/request_permission, which also covers agent-posed
+      // questions). Always false for cold sessions. Lets pickers render a
+      // distinct "waiting on you" glyph instead of the busy dot.
+      awaitingInput: z3.boolean().default(false),
       _meta: z3.record(z3.unknown()).optional()
     });
     SessionListEntryWire = z3.object({
@@ -3064,6 +3130,14 @@ var init_session = __esm({
       get turnStartedAt() {
         return this.promptStartedAt;
       }
+      // True when the agent is blocked on the user: an outstanding
+      // session/request_permission (which also carries agent-posed
+      // questions — there's no separate "ask the user" request in ACP).
+      // Lets pickers show a "waiting on you" glyph distinct from the
+      // "actively working" one without having to attach.
+      get awaitingInput() {
+        return this.inFlightPermissions.size > 0;
+      }
       // Read the persisted history from disk. Returns [] if no history
       // file exists (fresh session, never prompted). Used by attach() and
       // the HTTP /history endpoint.
@@ -3120,23 +3194,24 @@ var init_session = __esm({
         return this.loadReplay(historyPolicy, opts);
       }
       async loadReplay(historyPolicy, opts) {
+        const maybeCoalesce = (entries) => opts.raw ? entries : coalesceReplay(entries);
         const raw = await this.getHistorySnapshot();
         const state = this.buildStateSnapshotReplay();
         if (historyPolicy === "after_message") {
           const cutoff = opts.afterMessageId ? findMessageIdIndex(raw, opts.afterMessageId) : -1;
           if (cutoff < 0) {
             return {
-              entries: [...state, ...coalesceReplay(raw)],
+              entries: [...state, ...maybeCoalesce(raw)],
               appliedPolicy: "full"
             };
           }
           return {
-            entries: [...state, ...coalesceReplay(raw.slice(cutoff + 1))],
+            entries: [...state, ...maybeCoalesce(raw.slice(cutoff + 1))],
             appliedPolicy: "after_message"
           };
         }
         return {
-          entries: [...state, ...coalesceReplay(raw)],
+          entries: [...state, ...maybeCoalesce(raw)],
           appliedPolicy: "full"
         };
       }
@@ -4403,6 +4478,7 @@ var init_session = __esm({
         const out = [
           { name: "hydra", description: "Hydra session command (kill, restart, title, agent <agent>)" },
           { name: "model", description: "Switch model; omit arg to list available models" },
+          { name: "mode", description: "Switch mode; omit arg to list available modes" },
           { name: "sessions", description: "List all sessions" },
           { name: "help", description: "Show available commands" }
         ];
@@ -4673,6 +4749,60 @@ ${body}
         });
         return { stopReason: "end_turn" };
       }
+      // /mode — the text-command twin of session/set_mode, so clients that
+      // can only send prompts (e.g. Slack) can switch modes. With no arg it
+      // lists advertised modes; with an arg it forwards session/set_mode to
+      // the agent and then applies the change locally. The forward +
+      // applyModeChange pair MUST stay identical to the daemon's
+      // session/set_mode handler (see acp-ws.ts) — applyModeChange owns the
+      // persistence + synthetic current_mode_update broadcast for both paths.
+      async handleModeCommand(text) {
+        const arg = text.slice("/mode".length).trim();
+        if (arg === "") {
+          const modes2 = this.agentAdvertisedModes;
+          const current = this.currentMode;
+          let body;
+          if (modes2.length === 0) {
+            body = current ? `Current mode: ${current}` : "_(no modes advertised yet)_";
+          } else {
+            const inList = current ? modes2.some((m) => m.id === current) : true;
+            const lines = modes2.map((m) => {
+              const marker = m.id === current ? "\u25B6 " : "  ";
+              const desc = m.name && m.name !== m.id ? `  ${m.name}` : "";
+              return `${marker}${m.id}${desc}`;
+            });
+            if (!inList && current) {
+              lines.unshift(`\u25B6 ${current}`);
+            }
+            body = lines.join("\n");
+          }
+          this.recordAndBroadcast("session/update", {
+            sessionId: this.upstreamSessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              content: { type: "text", text: `
+${body}
+` },
+              _meta: { "hydra-acp": { synthetic: true } }
+            }
+          });
+          return { stopReason: "end_turn" };
+        }
+        const modes = this.agentAdvertisedModes;
+        if (modes.length > 0 && !modes.some((m) => m.id === arg)) {
+          const known = modes.map((m) => m.id).join(", ");
+          throw withCode(
+            new Error(`unknown mode: ${arg} (known: ${known})`),
+            JsonRpcErrorCodes.InvalidParams
+          );
+        }
+        await this.forwardRequest("session/set_mode", {
+          sessionId: this.sessionId,
+          modeId: arg
+        });
+        this.applyModeChange(arg);
+        return { stopReason: "end_turn" };
+      }
       // /hydra title. With an arg, sets the title directly (synchronous,
       // broadcasts session_info_update). Without an arg, asks the manager
       // to schedule a background synopsis via the ephemeral-agent path —
@@ -5498,12 +5628,14 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         }
         this.broadcastPromptReceived(entry);
         const promptText = extractPromptText(entry.prompt).trim();
-        if (promptText === "/model" || promptText.startsWith("/model ") || promptText === "/sessions" || promptText === "/help") {
+        if (promptText === "/model" || promptText.startsWith("/model ") || promptText === "/mode" || promptText.startsWith("/mode ") || promptText === "/sessions" || promptText === "/help") {
           let result;
           if (promptText === "/sessions") {
             result = await this.handleSessionsCommand();
           } else if (promptText === "/help") {
             result = await this.handleHelpCommand();
+          } else if (promptText === "/mode" || promptText.startsWith("/mode ")) {
+            result = await this.handleModeCommand(promptText);
           } else {
             result = await this.handleModelCommand(promptText);
           }
@@ -5561,7 +5693,12 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       "current_mode_update",
       "available_commands_update",
       "available_modes_update",
-      "usage_update"
+      "usage_update",
+      // opencode's non-spec carrier for model/mode/config state. Its canonical
+      // form is harvested into meta.json and re-synthesized on attach, so
+      // recording it would just give never-prompted sessions a non-empty
+      // history and make them look interactive in the picker.
+      "config_option_update"
     ]);
   }
 });
@@ -6338,10 +6475,28 @@ async function listSessions(target, opts = {}, fetchImpl = fetch) {
     forkedFromSessionId: s.forkedFromSessionId,
     forkedFromMessageId: s.forkedFromMessageId,
     busy: s.busy,
+    awaitingInput: s.awaitingInput,
     originatingClient: s.originatingClient,
     interactive: s.interactive
   }));
 }
+async function listAgents(target, fetchImpl = fetch) {
+  const response = await fetchImpl(`${target.baseUrl}/v1/agents`, {
+    headers: { Authorization: `Bearer ${target.token}` }
+  });
+  if (!response.ok) {
+    throw new Error(`daemon returned HTTP ${response.status}`);
+  }
+  const body = await response.json();
+  if (!Array.isArray(body.agents)) {
+    return [];
+  }
+  return body.agents.map((a) => ({
+    id: a.id,
+    name: a.name,
+    description: a.description
+  }));
+}
 async function forkSession(target, id, opts = {}, fetchImpl = fetch) {
   const response = await fetchImpl(
     `${target.baseUrl}/v1/sessions/${id}/fork`,
@@ -6469,30 +6624,24 @@ function formatAgentWithModel(agentId, model) {
   }
   return `${agent}${AGENT_MODEL_SEP}${short}`;
 }
-function formatAgentCell(agentId, usage) {
-  const base = agentId ?? "?";
+function formatAgentCell(agentId) {
+  return agentId ?? "?";
+}
+function formatCostCell(usage) {
   if (!usage || typeof usage.costAmount !== "number") {
-    return base;
+    return "";
   }
-  const compact = formatCostCompact(usage.costAmount, usage.costCurrency);
-  if (compact === null) {
-    return base;
+  const { costAmount, costCurrency } = usage;
+  if (costCurrency === void 0 || costCurrency === "USD") {
+    return `$${Math.round(costAmount)}`;
   }
-  return `${base} ${compact}`;
+  return formatCost(costAmount, costCurrency);
 }
 function formatCost(amount, currency) {
   const sign = currency === "USD" || currency === void 0 ? "$" : "";
   const decimals = 2;
   return `${sign}${amount.toFixed(decimals)}${currency && currency !== "USD" ? ` ${currency}` : ""}`;
 }
-function formatCostCompact(amount, currency) {
-  const whole = Math.round(amount);
-  if (whole === 0) {
-    return null;
-  }
-  const sign = currency === "USD" || currency === void 0 ? "$" : "";
-  return `${sign}${whole}${currency && currency !== "USD" ? ` ${currency}` : ""}`;
-}
 var AGENT_MODEL_SEP;
 var init_agent_display = __esm({
   "src/core/agent-display.ts"() {
@@ -6502,15 +6651,39 @@ var init_agent_display = __esm({
 });
 
 // src/cli/session-row.ts
+function parseColumns(raw) {
+  const parts = raw.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+  if (parts.length === 0) {
+    throw new Error("--columns: no column names given");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const name of parts) {
+    if (!ALL_COLUMNS.includes(name)) {
+      throw new Error(
+        `--columns: unknown column "${name}" (valid: ${ALL_COLUMNS.join(", ")})`
+      );
+    }
+    if (seen.has(name)) {
+      throw new Error(`--columns: duplicate column "${name}"`);
+    }
+    seen.add(name);
+    out.push(name);
+  }
+  return out;
+}
 function toRow(s, now = Date.now()) {
   return {
     session: stripHydraSessionPrefix(s.sessionId),
     upstream: formatUpstreamCell(s.upstreamSessionId, s.importedFromMachine),
-    state: formatState(s.status, s.busy),
-    agent: formatAgentCell(s.agentId, s.currentUsage),
+    host: s.importedFromMachine ?? "-",
+    state: formatState(s.status, s.busy, s.awaitingInput),
+    agent: formatAgentCell(s.agentId),
+    model: shortenModel(s.currentModel) ?? "-",
     age: formatRelativeAge(s.updatedAt, now),
     title: s.title ?? "-",
-    cwd: shortenHomePath(s.cwd)
+    cwd: shortenHomePath(s.cwd),
+    cost: formatCostCell(s.currentUsage)
   };
 }
 function formatUpstreamCell(upstreamSessionId, importedFromMachine) {
@@ -6522,22 +6695,33 @@ function formatUpstreamCell(upstreamSessionId, importedFromMachine) {
   }
   return "-";
 }
-function formatState(status, busy) {
+function formatState(status, busy, awaitingInput) {
   if (status === "cold") {
     return "COLD";
   }
+  if (awaitingInput) {
+    return "LIVE\u25E6";
+  }
   return busy ? "LIVE\u2022" : "LIVE";
 }
-function computeWidths(rows) {
-  return {
-    session: maxLen(HEADER.session, rows.map((r) => r.session)),
-    upstream: maxLen(HEADER.upstream, rows.map((r) => r.upstream)),
-    state: maxLen(HEADER.state, rows.map((r) => r.state)),
-    agent: maxLen(HEADER.agent, rows.map((r) => r.agent)),
-    age: maxLen(HEADER.age, rows.map((r) => r.age)),
-    cwd: maxLen(HEADER.cwd, rows.map((r) => r.cwd)),
-    title: maxLen(HEADER.title, rows.map((r) => r.title))
+function computeWidths(rows, opts = {}) {
+  const columns = opts.columns ?? DEFAULT_COLUMNS;
+  const w = {
+    session: 0,
+    upstream: 0,
+    host: 0,
+    state: 0,
+    agent: 0,
+    model: 0,
+    age: 0,
+    cwd: 0,
+    title: 0,
+    cost: 0
   };
+  for (const col of columns) {
+    w[col] = maxLen(HEADER[col], rows.map((r) => r[col]));
+  }
+  return w;
 }
 function formatRelativeAge(iso, now) {
   if (!iso) {
@@ -6584,27 +6768,56 @@ function maxLen(headerCell, values) {
   }
   return max;
 }
-function formatRow(r, w, maxWidth, cwdMaxWidth = DEFAULT_CWD_MAX_WIDTH) {
-  const fixed = [
-    r.session.padEnd(w.session),
-    r.upstream.padEnd(w.upstream),
-    r.state.padEnd(w.state),
-    r.agent.padEnd(w.agent),
-    r.age.padStart(w.age)
-  ].join(SEP);
+function formatRow(r, w, maxWidth, opts = {}) {
+  const columns = opts.columns ?? DEFAULT_COLUMNS;
+  const cwdMaxWidth = opts.cwdMaxWidth ?? DEFAULT_CWD_MAX_WIDTH;
+  const naturalCell = (col) => col === "age" ? r[col].padStart(w[col]) : r[col].padEnd(w[col]);
   if (maxWidth === void 0) {
-    return [fixed, r.cwd.padEnd(w.cwd), r.title].join(SEP);
-  }
-  const budget = maxWidth - fixed.length - SEP.length;
-  if (budget <= 0) {
-    return fixed.slice(0, maxWidth);
+    const cells2 = columns.map(
+      (col, i) => i === columns.length - 1 ? r[col] : naturalCell(col)
+    );
+    return cells2.join(SEP);
+  }
+  const elasticIdx = columns.map((col, i) => ({ col, i })).filter(({ col }) => ELASTIC_COLUMNS.has(col));
+  const lastElastic = elasticIdx.length > 0 ? elasticIdx[elasticIdx.length - 1].i : -1;
+  if (lastElastic === -1) {
+    const out2 = columns.map(naturalCell).join(SEP);
+    return out2.length > maxWidth ? out2.slice(0, maxWidth) : out2;
+  }
+  const fixedWidth = columns.filter((col) => !ELASTIC_COLUMNS.has(col)).reduce((sum, col) => sum + w[col], 0);
+  const sepCount = Math.max(0, columns.length - 1);
+  let budget = maxWidth - fixedWidth - sepCount * SEP.length;
+  if (budget < 0) {
+    budget = 0;
+  }
+  const elasticAlloc = /* @__PURE__ */ new Map();
+  let remaining = budget;
+  for (const { col, i } of elasticIdx) {
+    if (i === lastElastic) {
+      continue;
+    }
+    const natural = col === "cwd" ? Math.min(w[col], cwdMaxWidth) : w[col];
+    const alloc = Math.min(natural, Math.max(0, remaining - 1));
+    elasticAlloc.set(i, alloc);
+    remaining = Math.max(0, remaining - alloc);
   }
-  const cwdCap = Math.min(w.cwd, cwdMaxWidth);
-  const cwdAlloc = Math.min(cwdCap, Math.max(0, budget - SEP.length - 1));
-  const cwdCell = truncateMiddle(r.cwd, cwdAlloc).padEnd(cwdAlloc);
-  const titleBudget = Math.max(0, budget - cwdAlloc - SEP.length);
-  const titleCell = truncateRight(r.title, titleBudget);
-  return [fixed, cwdCell, titleCell].join(SEP);
+  elasticAlloc.set(lastElastic, Math.max(0, remaining));
+  const lastCol = columns.length - 1;
+  const renderElastic = (col, width, isLast) => {
+    if (col === "cwd") {
+      return truncateMiddle(r[col], width).padEnd(width);
+    }
+    const cell = truncateRight(r[col], width);
+    return isLast ? cell : cell.padEnd(width);
+  };
+  const cells = columns.map((col, i) => {
+    if (ELASTIC_COLUMNS.has(col)) {
+      return renderElastic(col, elasticAlloc.get(i) ?? 0, i === lastCol);
+    }
+    return naturalCell(col);
+  });
+  const out = cells.join(SEP);
+  return out.length > maxWidth ? out.slice(0, maxWidth) : out;
 }
 function truncateRight(s, max) {
   if (max <= 0) {
@@ -6632,24 +6845,49 @@ function truncateMiddle(s, max) {
   const tail = max - 1 - head;
   return s.slice(0, head) + "\u2026" + s.slice(s.length - tail);
 }
-var HEADER, SEP, DEFAULT_CWD_MAX_WIDTH;
+var ALL_COLUMNS, DEFAULT_COLUMNS, ELASTIC_COLUMNS, HEADER, SEP, DEFAULT_CWD_MAX_WIDTH;
 var init_session_row = __esm({
   "src/cli/session-row.ts"() {
     "use strict";
     init_agent_display();
     init_paths();
     init_session();
+    ALL_COLUMNS = [
+      "session",
+      "upstream",
+      "host",
+      "state",
+      "agent",
+      "model",
+      "age",
+      "cwd",
+      "title",
+      "cost"
+    ];
+    DEFAULT_COLUMNS = [
+      "session",
+      "state",
+      "agent",
+      "age",
+      "cwd",
+      "title",
+      "cost"
+    ];
+    ELASTIC_COLUMNS = /* @__PURE__ */ new Set(["cwd", "title"]);
     HEADER = {
       session: "SESSION",
       upstream: "UPSTREAM",
+      host: "HOST",
       state: "STATE",
       agent: "AGENT",
+      model: "MODEL",
       age: "AGE",
       title: "TITLE",
-      cwd: "CWD"
+      cwd: "CWD",
+      cost: "COST"
     };
     SEP = "  ";
-    DEFAULT_CWD_MAX_WIDTH = 24;
+    DEFAULT_CWD_MAX_WIDTH = 32;
   }
 });
 
@@ -7202,7 +7440,21 @@ function formatBlock(text, prefix, bodyStyle, prefixStyle, sentBy, fillRow) {
   }
   return out;
 }
-function formatToolLine2(state) {
+function formatElapsed(ms) {
+  const totalSec = Math.floor(ms / 1e3);
+  if (totalSec < 60) {
+    return `${totalSec}s`;
+  }
+  const min = Math.floor(totalSec / 60);
+  const sec = totalSec % 60;
+  if (min < 60) {
+    return sec === 0 ? `${min}m` : `${min}m ${sec}s`;
+  }
+  const hr = Math.floor(min / 60);
+  const remMin = min % 60;
+  return remMin === 0 ? `${hr}h` : `${hr}h ${remMin}m`;
+}
+function formatToolLine2(state, now = Date.now()) {
   const initial = state.initialTitle;
   const latest = state.latestTitle;
   const initialLc = initial.toLowerCase();
@@ -7215,6 +7467,10 @@ function formatToolLine2(state) {
   } else {
     title = `${initial} \xB7 ${latest}`;
   }
+  if (state.startedAt !== void 0) {
+    const end = state.endedAt ?? now;
+    title = `${title} \xB7 ${formatElapsed(end - state.startedAt)}`;
+  }
   const lines = [
     {
       prefix: `  ${toolStatusIcon(state.status)} `,
@@ -7234,22 +7490,32 @@ function formatToolLine2(state) {
 }
 function formatEditDiffBlock(diff, mode) {
   const lines = [];
-  if (diff.path) {
-    lines.push({
-      prefix: "  ",
-      body: `\u25B8 Edited ${sanitizeSingleLine(shortenHomePath(diff.path))}`,
-      bodyStyle: "dim"
-    });
-  }
+  const header = (open2) => ({
+    prefix: "  ",
+    body: `${open2 ? "\u25BE" : "\u25B8"} Edited ${sanitizeSingleLine(shortenHomePath(diff.path))}`,
+    bodyStyle: "dim"
+  });
   if (mode === "edit") {
+    if (diff.path) {
+      lines.push(header(false));
+    }
     return lines;
   }
-  const body = buildUnifiedDiff(diff);
+  const body = buildUnifiedDiff(diff, { maxLines: Infinity });
   if (body.length === 0) {
+    if (diff.path) {
+      lines.push(header(false));
+    }
     return lines;
   }
+  if (diff.path) {
+    lines.push(header(true));
+  }
   const fenced = "```diff\n" + body + "\n```";
   lines.push(...parseAgentMarkdown(fenced));
+  if (lines.length > 0) {
+    lines.unshift({ body: "" });
+  }
   return lines;
 }
 function buildUnifiedDiff(diff, opts = {}) {
@@ -7324,6 +7590,20 @@ function diffLines(a, b) {
   }
   return out;
 }
+function isTerminalToolStatus(status) {
+  switch (status) {
+    case "completed":
+    case "succeeded":
+    case "ok":
+    case "failed":
+    case "error":
+    case "rejected":
+    case "cancelled":
+      return true;
+    default:
+      return false;
+  }
+}
 function toolStatusIcon(status) {
   switch (status) {
     case "completed":
@@ -8243,7 +8523,7 @@ var init_input = __esm({
           case "ctrl-n":
             return this.handleDown();
           case "ctrl-o":
-            return [{ type: "toggle-tools" }];
+            return [{ type: "toggle-options" }];
           case "backspace":
             this.backspace();
             return [];
@@ -9518,20 +9798,6 @@ function formatUsage(usage) {
   }
   return parts.length === 0 ? null : parts.join(" \xB7 ");
 }
-function formatElapsed(ms) {
-  const totalSec = Math.floor(ms / 1e3);
-  if (totalSec < 60) {
-    return `${totalSec}s`;
-  }
-  const min = Math.floor(totalSec / 60);
-  const sec = totalSec % 60;
-  if (min < 60) {
-    return sec === 0 ? `${min}m` : `${min}m ${sec}s`;
-  }
-  const hr = Math.floor(min / 60);
-  const remMin = min % 60;
-  return remMin === 0 ? `${hr}h` : `${hr}h ${remMin}m`;
-}
 function formatTokens(n) {
   if (n >= 1e6) {
     return `${(n / 1e6).toFixed(1)}M`;
@@ -9750,7 +10016,7 @@ function mapCsiUToKeyName(code, mod) {
   }
   return null;
 }
-var SESSIONBAR_ROWS, BANNER_ROWS, SEPARATOR_ROWS, MAX_PROMPT_ROWS, MAX_QUEUED_ROWS, MAX_PERMISSION_ROWS, MAX_HELP_ROWS, MAX_COMPLETION_ROWS, MAX_CHIP_ROWS, CONFIRM_PROMPT_ROWS, DEFAULT_CONTENT_REPAINT_THROTTLE_MS, DEFAULT_MAX_SCROLLBACK_LINES, BARE_URL_RE, Screen, NON_ASCII, SEGMENTER, TK_MARKUP_STYLE_CHAR, shortId;
+var SESSIONBAR_ROWS, BANNER_ROWS, SEPARATOR_ROWS, MAX_PROMPT_ROWS, MAX_QUEUED_ROWS, MAX_PERMISSION_ROWS, MAX_OPTIONS_ROWS, MAX_HELP_ROWS, MAX_COMPLETION_ROWS, MAX_CHIP_ROWS, CONFIRM_PROMPT_ROWS, DEFAULT_CONTENT_REPAINT_THROTTLE_MS, DEFAULT_MAX_SCROLLBACK_LINES, BARE_URL_RE, Screen, NON_ASCII, SEGMENTER, TK_MARKUP_STYLE_CHAR, shortId;
 var init_screen = __esm({
   "src/tui/screen.ts"() {
     "use strict";
@@ -9758,6 +10024,7 @@ var init_screen = __esm({
     init_paths();
     init_session();
     init_attachments();
+    init_format();
     init_sync();
     SESSIONBAR_ROWS = 1;
     BANNER_ROWS = 1;
@@ -9765,6 +10032,7 @@ var init_screen = __esm({
     MAX_PROMPT_ROWS = 8;
     MAX_QUEUED_ROWS = 5;
     MAX_PERMISSION_ROWS = 12;
+    MAX_OPTIONS_ROWS = 12;
     MAX_HELP_ROWS = 30;
     MAX_COMPLETION_ROWS = 6;
     MAX_CHIP_ROWS = 4;
@@ -9839,6 +10107,7 @@ var init_screen = __esm({
       lastFrameW = 0;
       lastFrameH = 0;
       permissionPrompt = null;
+      optionsPrompt = null;
       confirmPrompt = null;
       helpPrompt = null;
       completions = [];
@@ -10008,6 +10277,7 @@ var init_screen = __esm({
         this.writeProgressIndicator(0);
         this.started = false;
         if (!opts.keepFullscreen) {
+          emergencyTerminalReset();
           this.term.fullscreen(false);
           this.term("\n");
         }
@@ -10181,6 +10451,11 @@ uncaught: ${err.stack ?? err.message}
         }
         if (text.includes("\n")) {
           const parts = text.split("\n");
+          const nonEmpty = parts.filter((p) => p.length > 0).length;
+          if (nonEmpty > 1) {
+            this.onKey([{ type: "paste", text: text.replace(/\r/g, "") }]);
+            return;
+          }
           for (let i = 0; i < parts.length; i++) {
             if (parts[i].length > 0) {
               this.handleRawStdin(Buffer.from(parts[i], "binary"));
@@ -10708,6 +10983,41 @@ uncaught: ${err.stack ?? err.message}
       clearKey(key) {
         this.keyedBlocks.delete(key);
       }
+      // Whether a keyed block currently exists in scrollback.
+      hasKey(key) {
+        return this.keyedBlocks.has(key);
+      }
+      // Splice a keyed block's lines out of scrollback entirely (unlike
+      // clearKey, which only forgets the key but leaves the lines painted).
+      // Later blocks' start indices shift up by the removed count so they
+      // stay aligned with the lines array. No-op if the key is unknown.
+      removeKey(key) {
+        const block = this.keyedBlocks.get(key);
+        if (!block) {
+          return;
+        }
+        const end = block.start + block.count;
+        const touchesEnd = end >= this.lines.length;
+        const removedRows = this.wrappedRowsOfMany(
+          this.lines.slice(block.start, end)
+        );
+        const removed = this.lines.splice(block.start, block.count);
+        for (const line of removed) {
+          this.forgetLine(line);
+        }
+        this.keyedBlocks.delete(key);
+        for (const [k, range] of this.keyedBlocks) {
+          if (k !== key && range.start > block.start) {
+            range.start -= block.count;
+          }
+        }
+        if (touchesEnd) {
+          this.streamingActive = false;
+        }
+        this.adjustScrollForRowChange(-removedRows);
+        this.moveStickyToEnd();
+        this.scheduleRepaint();
+      }
       // Mark `key` as the sticky-bottom block. While set, whenever new content
       // lands after the block's lines (appendLines / appendStreaming / a new
       // upserted block) the screen floats this block back to the end so it
@@ -10826,6 +11136,15 @@ uncaught: ${err.stack ?? err.message}
         this.permissionPrompt = spec ? { ...spec } : null;
         this.repaint();
       }
+      // Interactive session-options modal (^O). Takes over the prompt area
+      // like the permission modal. Pass null to dismiss.
+      setOptionsPrompt(spec) {
+        this.optionsPrompt = spec ? { ...spec, options: spec.options.map((o) => ({ ...o })) } : null;
+        this.repaint();
+      }
+      isOptionsPromptActive() {
+        return this.optionsPrompt !== null;
+      }
       // Two-line confirmation modal that takes over the prompt area. Pass
       // null to dismiss. Currently unused — kept as a generic primitive for
       // any future modal that needs a question + hint footer.
@@ -11316,7 +11635,7 @@ uncaught: ${err.stack ?? err.message}
           this.drawSeparator(h - SESSIONBAR_ROWS);
           this.drawSessionbar();
           this.placeCursor();
-          if (this.permissionPrompt || this.confirmPrompt || this.helpPrompt) {
+          if (this.permissionPrompt || this.optionsPrompt || this.confirmPrompt || this.helpPrompt) {
             this.term.hideCursor(false);
           }
           this.lastPromptRows = promptRows;
@@ -11420,7 +11739,7 @@ uncaught: ${err.stack ?? err.message}
         this.repaint();
       }
       completionRows() {
-        if (this.permissionPrompt || this.confirmPrompt || this.helpPrompt) {
+        if (this.permissionPrompt || this.optionsPrompt || this.confirmPrompt || this.helpPrompt) {
           return 0;
         }
         return Math.min(MAX_COMPLETION_ROWS, this.completions.length);
@@ -11560,6 +11879,10 @@ uncaught: ${err.stack ?? err.message}
           this.drawPermissionPrompt();
           return;
         }
+        if (this.optionsPrompt) {
+          this.drawOptionsPrompt();
+          return;
+        }
         if (this.confirmPrompt) {
           this.drawConfirmPrompt();
           return;
@@ -11782,6 +12105,14 @@ uncaught: ${err.stack ?? err.message}
           this.term.moveTo(2, Math.min(optionRow, lastUsableRow));
           return;
         }
+        if (this.optionsPrompt) {
+          const rows = this.optionsRows();
+          const top2 = this.term.height - rows - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS + 1;
+          const optionRow = top2 + 1 + this.optionsPrompt.selectedIndex;
+          const lastUsableRow = this.term.height - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS;
+          this.term.moveTo(2, Math.min(optionRow, lastUsableRow));
+          return;
+        }
         if (this.confirmPrompt) {
           const top2 = this.term.height - CONFIRM_PROMPT_ROWS - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS + 1;
           this.term.moveTo(2, top2);
@@ -11820,6 +12151,9 @@ uncaught: ${err.stack ?? err.message}
         if (this.permissionPrompt) {
           return this.permissionRows();
         }
+        if (this.optionsPrompt) {
+          return this.optionsRows();
+        }
         if (this.confirmPrompt) {
           return CONFIRM_PROMPT_ROWS;
         }
@@ -11844,6 +12178,64 @@ uncaught: ${err.stack ?? err.message}
           4 + this.permissionPrompt.options.length
         );
       }
+      optionsRows() {
+        if (!this.optionsPrompt) {
+          return 0;
+        }
+        return Math.min(MAX_OPTIONS_ROWS, 2 + this.optionsPrompt.options.length);
+      }
+      drawOptionsPrompt() {
+        const spec = this.optionsPrompt;
+        if (!spec) {
+          return;
+        }
+        const w = this.term.width;
+        const rows = this.optionsRows();
+        const top = this.term.height - rows - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS + 1;
+        let row = top;
+        const writeRow = (sig, paint) => {
+          if (row >= top + rows) {
+            return;
+          }
+          this.paintRow(row, sig, paint);
+          row += 1;
+        };
+        writeRow(`opts|t|${w}|${spec.title}`, () => {
+          this.term.brightYellow(` \u2699 ${truncate(spec.title, w - 5)}`);
+        });
+        const labelWidth = Math.max(
+          ...spec.options.map((o) => o.label.length),
+          0
+        );
+        for (let i = 0; i < spec.options.length; i++) {
+          if (row >= top + rows - 1) {
+            break;
+          }
+          const opt = spec.options[i];
+          if (!opt) {
+            continue;
+          }
+          const isSel = i === spec.selectedIndex;
+          const marker = isSel ? "\u276F" : " ";
+          const prefix = ` ${marker} ${i + 1}. `;
+          const paddedLabel = opt.label.padEnd(labelWidth);
+          const room = w - prefix.length - 3;
+          const body = `${prefix}${truncate(`${paddedLabel}  ${opt.value}`, room)}`;
+          writeRow(
+            `opts|o|${w}|${i}|${isSel ? "1" : "0"}|${opt.value}|${opt.label}`,
+            () => {
+              if (isSel) {
+                this.term.brightYellow(body);
+              } else {
+                this.term.dim(body);
+              }
+            }
+          );
+        }
+        writeRow(`opts|hint|${w}`, () => {
+          this.term.dim(" \u2191/\u2193 choose \xB7 Enter this session \xB7 s save default \xB7 Esc close");
+        });
+      }
       // 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`
@@ -12018,7 +12410,7 @@ function drawBox(term, opts) {
   const termW = readTermWidth(term);
   const termH = readTermHeight(term);
   const desiredContentW = opts.contentWidth ?? MAX_BOX_WIDTH;
-  const maxContentW = Math.max(10, Math.min(MAX_BOX_WIDTH, termW - 4));
+  const maxContentW = Math.max(10, termW - 4);
   const contentW = Math.min(desiredContentW, maxContentW);
   const w = contentW + 2;
   const contentH = Math.max(1, Math.min(opts.contentHeight, termH - 4));
@@ -12468,8 +12860,12 @@ async function pickSession(term, opts) {
     return base;
   };
   let visible = applyPrefsFilters(allSessions);
+  const formatOpts = {
+    columns: opts.config.tui.sessionColumns ?? DEFAULT_COLUMNS,
+    cwdMaxWidth: opts.config.tui.cwdColumnMaxWidth
+  };
   let rows = visible.map((s) => toRow(s, Date.now()));
-  let widths = computeWidths(rows);
+  let widths = computeWidths(rows, formatOpts);
   let total = 1 + visible.length;
   let selectedIdx = 0;
   let scrollOffset = 0;
@@ -12496,7 +12892,11 @@ async function pickSession(term, opts) {
   let findInFlight = false;
   let renameBuffer = "";
   let transientStatus = null;
+  let currentSessionGone = false;
   const composer = new InputDispatcher({ history: [] });
+  if (opts.initialPrompt) {
+    composer.setBuffer(opts.initialPrompt);
+  }
   const composerHistoryCap = opts.config.tui.promptHistoryMaxEntries;
   loadHistory(paths.globalTuiHistoryFile()).then((entries) => {
     const capped = entries.length > composerHistoryCap ? entries.slice(entries.length - composerHistoryCap) : entries;
@@ -12521,7 +12921,6 @@ async function pickSession(term, opts) {
   let findBoxWindowStart = 0;
   let findBoxCursorVisualRow = 0;
   let findBoxCursorVisualCol = 0;
-  const cwdMaxWidth = opts.config.tui.cwdColumnMaxWidth;
   const computeLayout = () => {
     termHeight = readTermHeight2(term);
     termWidth = readTermWidth2(term);
@@ -12543,16 +12942,16 @@ async function pickSession(term, opts) {
     const reserved = 6 + composerRows;
     const maxViewportRows = Math.max(3, termHeight - reserved);
     viewportSize = Math.min(visible.length, maxViewportRows);
-    headerLine = formatRow(HEADER, widths, rowMaxWidth, cwdMaxWidth).padEnd(
+    headerLine = formatRow(HEADER, widths, rowMaxWidth, formatOpts).padEnd(
       rowMaxWidth
     );
     sessionLines = rows.map(
-      (r) => formatRow(r, widths, rowMaxWidth, cwdMaxWidth).padEnd(rowMaxWidth)
+      (r) => formatRow(r, widths, rowMaxWidth, formatOpts).padEnd(rowMaxWidth)
     );
   };
   const rebuildRows = () => {
     rows = visible.map((s) => toRow(s, Date.now()));
-    widths = computeWidths(rows);
+    widths = computeWidths(rows, formatOpts);
     total = 1 + visible.length;
     computeLayout();
   };
@@ -13295,9 +13694,19 @@ async function pickSession(term, opts) {
       term.moveTo(1, indicatorRow() + 1);
       term("\n");
     };
+    const tryAbort = () => {
+      if (currentSessionGone) {
+        transientStatus = "current session ended \u2014 pick a session or start a new one";
+        paintIndicator();
+        return false;
+      }
+      cleanup();
+      resolve8({ kind: "abort" });
+      return true;
+    };
     const renderFingerprint = () => {
       const cells = rows.map(
-        (r) => `${r.session}|${r.upstream}|${r.state}|${r.agent}|${r.age}|${r.title}|${r.cwd}`
+        (r) => `${r.session}|${r.upstream}|${r.host}|${r.state}|${r.agent}|${r.model}|${r.age}|${r.title}|${r.cwd}|${r.cost}`
       ).join("\n");
       return `${selectedIdx}:${scrollOffset}:${transientStatus ?? ""}
 ${cells}`;
@@ -13387,6 +13796,9 @@ ${cells}`;
         }
         mode = "normal";
         pendingAction = null;
+        if (session.sessionId === opts.currentSessionId) {
+          currentSessionGone = true;
+        }
         await refresh(kind === "kill" ? session.sessionId : void 0);
       } catch (err) {
         mode = "normal";
@@ -13733,8 +14145,7 @@ ${cells}`;
       }
       if (selectedIdx === 0 && !searchActive) {
         if (name === "ESCAPE") {
-          cleanup();
-          resolve8({ kind: "abort" });
+          tryAbort();
           return;
         }
         if (name === "ENTER" || name === "KP_ENTER") {
@@ -13787,8 +14198,7 @@ ${cells}`;
         const after = composer.state();
         const unchanged = before.buffer.length === after.buffer.length && before.buffer.every((line, i) => line === after.buffer[i]) && before.row === after.row && before.col === after.col;
         if (effects.some((e) => e.type === "exit")) {
-          cleanup();
-          resolve8({ kind: "abort" });
+          tryAbort();
           return;
         }
         if (unchanged) {
@@ -13861,8 +14271,7 @@ ${cells}`;
           return;
         }
         if (name === "q" || name === "Q") {
-          cleanup();
-          resolve8({ kind: "abort" });
+          tryAbort();
           return;
         }
         if (name === "o" || name === "O") {
@@ -14038,8 +14447,7 @@ ${cells}`;
         case "ESCAPE":
         case "CTRL_C":
         case "CTRL_D":
-          cleanup();
-          resolve8({ kind: "abort" });
+          tryAbort();
           return;
       }
     };
@@ -14088,6 +14496,9 @@ function sortSessions(sessions, cwd) {
       return 0;
     }
     const base = s.cwd === cwd ? 2 : 1;
+    if (s.awaitingInput) {
+      return base + 4;
+    }
     return s.busy ? base + 2 : base;
   };
   return [...sessions].sort((a, b) => {
@@ -14404,28 +14815,218 @@ async function promptForImportCwd(term, session, opts = {}) {
         }
         return;
       }
-      if (name === "CTRL_U") {
-        buffer = "";
-        errorLine = null;
-        repaintInput();
+      if (name === "CTRL_U") {
+        buffer = "";
+        errorLine = null;
+        repaintInput();
+        return;
+      }
+      if (name === "CTRL_W") {
+        const trimmedRight = buffer.replace(/[/\s]+$/, "");
+        const lastSep = Math.max(
+          trimmedRight.lastIndexOf("/"),
+          trimmedRight.lastIndexOf(" ")
+        );
+        buffer = lastSep >= 0 ? trimmedRight.slice(0, lastSep + 1) : "";
+        errorLine = null;
+        repaintInput();
+        return;
+      }
+      if (data?.isCharacter) {
+        buffer += name;
+        errorLine = null;
+        repaintInput();
+        return;
+      }
+    };
+    term.grabInput({});
+    term.on("key", onKey);
+    term.on("resize", onResize);
+  });
+}
+function truncate3(s, max) {
+  if (max <= 1) {
+    return "";
+  }
+  if (s.length <= max) {
+    return s;
+  }
+  return s.slice(0, Math.max(0, max - 1)) + "\u2026";
+}
+function truncateLeft(s, max) {
+  if (max <= 1) {
+    return "";
+  }
+  if (s.length <= max) {
+    return s;
+  }
+  return "\u2026" + s.slice(s.length - (max - 1));
+}
+var init_import_cwd_prompt = __esm({
+  "src/tui/import-cwd-prompt.ts"() {
+    "use strict";
+    init_paths();
+    init_session();
+    init_cwd();
+    init_completion();
+    init_prompt_utils();
+  }
+});
+
+// src/tui/agent-prompt.ts
+function initialIndex(agents) {
+  const idx = agents.findIndex((a) => a.id === PREFERRED_DEFAULT);
+  return idx === -1 ? 0 : idx;
+}
+async function promptForAgent(term, agents) {
+  resetTerminalModes();
+  let selected = initialIndex(agents);
+  let windowStart = 0;
+  const visibleRows = () => {
+    const termBudget = readTermHeight(term) - 8;
+    return Math.max(1, Math.min(MAX_VISIBLE_ROWS, agents.length, termBudget));
+  };
+  const reclamp = () => {
+    const rows = visibleRows();
+    if (selected < windowStart) {
+      windowStart = selected;
+    } else if (selected >= windowStart + rows) {
+      windowStart = selected - rows + 1;
+    }
+    const maxStart = Math.max(0, agents.length - rows);
+    if (windowStart > maxStart) {
+      windowStart = maxStart;
+    }
+    if (windowStart < 0) {
+      windowStart = 0;
+    }
+  };
+  const render = () => {
+    reclamp();
+    const rows = visibleRows();
+    const contentHeight = rows + 4;
+    const contentWidth = Math.min(
+      PREFERRED_CONTENT_WIDTH,
+      Math.max(40, readTermWidth(term) - 8)
+    );
+    const layout = drawBox(term, {
+      contentHeight,
+      contentWidth,
+      title: "Select agent"
+    });
+    const innerW = layout.contentW;
+    let row = 0;
+    term.moveTo(layout.contentX, layout.contentY + row);
+    term.noFormat(" Which agent should this session use?");
+    row += 2;
+    const end = Math.min(agents.length, windowStart + rows);
+    for (let i = windowStart; i < end; i++) {
+      const agent = agents[i];
+      if (!agent) {
+        continue;
+      }
+      const pointer = i === selected ? "\u276F" : " ";
+      const desc = agent.description ?? agent.name;
+      const idPart = ` ${pointer} ${agent.id}`;
+      term.moveTo(layout.contentX, layout.contentY + row);
+      if (i === selected) {
+        const line = `${idPart}  ${desc}`;
+        term.brightWhite.bgBlue.noFormat(padRight2(truncate4(line, innerW), innerW));
+      } else {
+        term.noFormat(idPart);
+        const room = innerW - idPart.length - 2;
+        if (room > 1) {
+          term.dim.noFormat(`  ${truncate4(desc, room)}`);
+        }
+      }
+      row++;
+    }
+    row++;
+    term.moveTo(layout.contentX, layout.contentY + row);
+    const more = agents.length > rows ? ` (${selected + 1}/${agents.length})` : "";
+    term.dim.noFormat(
+      ` \u2191/\u2193 navigate \xB7 Enter this session \xB7 s set default \xB7 Esc back${more}`
+    );
+    return layout;
+  };
+  render();
+  term.hideCursor();
+  return await new Promise((resolve8) => {
+    let resolved = false;
+    const cleanup = () => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      term.off("key", onKey);
+      term.off("resize", onResize);
+      term.grabInput(false);
+      term.hideCursor(false);
+      term.moveTo(1, 1).eraseDisplayBelow();
+    };
+    const finish = (value) => {
+      cleanup();
+      resolve8(value);
+    };
+    const onResize = () => {
+      if (resolved) {
+        return;
+      }
+      render();
+    };
+    const moveDown = () => {
+      if (selected < agents.length - 1) {
+        selected++;
+        render();
+      }
+    };
+    const moveUp = () => {
+      if (selected > 0) {
+        selected--;
+        render();
+      }
+    };
+    const onKey = (name, _m, data) => {
+      if (name === "CTRL_C" || name === "CTRL_D") {
+        finish({ kind: "cancel" });
+        return;
+      }
+      if (name === "ESCAPE") {
+        finish({ kind: "back" });
+        return;
+      }
+      if (name === "ENTER" || name === "KP_ENTER") {
+        const agent = agents[selected];
+        if (agent) {
+          finish({ kind: "select", agentId: agent.id, persist: false });
+        }
+        return;
+      }
+      if (name === "UP" || name === "SHIFT_TAB") {
+        moveUp();
         return;
       }
-      if (name === "CTRL_W") {
-        const trimmedRight = buffer.replace(/[/\s]+$/, "");
-        const lastSep = Math.max(
-          trimmedRight.lastIndexOf("/"),
-          trimmedRight.lastIndexOf(" ")
-        );
-        buffer = lastSep >= 0 ? trimmedRight.slice(0, lastSep + 1) : "";
-        errorLine = null;
-        repaintInput();
+      if (name === "DOWN" || name === "TAB") {
+        moveDown();
         return;
       }
       if (data?.isCharacter) {
-        buffer += name;
-        errorLine = null;
-        repaintInput();
-        return;
+        const lower = name.toLowerCase();
+        if (lower === "s") {
+          const agent = agents[selected];
+          if (agent) {
+            finish({ kind: "select", agentId: agent.id, persist: true });
+          }
+          return;
+        }
+        if (lower === "j") {
+          moveDown();
+          return;
+        }
+        if (lower === "k") {
+          moveUp();
+          return;
+        }
       }
     };
     term.grabInput({});
@@ -14433,7 +15034,7 @@ async function promptForImportCwd(term, session, opts = {}) {
     term.on("resize", onResize);
   });
 }
-function truncate3(s, max) {
+function truncate4(s, max) {
   if (max <= 1) {
     return "";
   }
@@ -14442,23 +15043,20 @@ function truncate3(s, max) {
   }
   return s.slice(0, Math.max(0, max - 1)) + "\u2026";
 }
-function truncateLeft(s, max) {
-  if (max <= 1) {
-    return "";
-  }
-  if (s.length <= max) {
-    return s;
+function padRight2(s, w) {
+  if (s.length >= w) {
+    return s.slice(0, w);
   }
-  return "\u2026" + s.slice(s.length - (max - 1));
+  return s + " ".repeat(w - s.length);
 }
-var init_import_cwd_prompt = __esm({
-  "src/tui/import-cwd-prompt.ts"() {
+var PREFERRED_DEFAULT, MAX_VISIBLE_ROWS, PREFERRED_CONTENT_WIDTH;
+var init_agent_prompt = __esm({
+  "src/tui/agent-prompt.ts"() {
     "use strict";
-    init_paths();
-    init_session();
-    init_cwd();
-    init_completion();
     init_prompt_utils();
+    PREFERRED_DEFAULT = "opencode";
+    MAX_VISIBLE_ROWS = 20;
+    PREFERRED_CONTENT_WIDTH = 88;
   }
 });
 
@@ -14796,7 +15394,12 @@ async function runTuiApp(opts) {
   const term = termkit.terminal;
   const exitHint = {};
   const viewPrefs = {
-    showThoughts: config.tui.showThoughts
+    showThoughts: config.tui.showThoughts,
+    toolsExpanded: false,
+    planExpanded: false,
+    showFileUpdates: config.tui.showFileUpdates,
+    mouseEnabled: config.tui.mouse,
+    defaultEnterAction: config.tui.defaultEnterAction
   };
   const pickerPrefs = createPickerPrefs();
   let altScreenEngaged = false;
@@ -14974,7 +15577,8 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     "current_mode_update",
     "available_commands_update",
     "available_modes_update",
-    "usage_update"
+    "usage_update",
+    "config_option_update"
   ]);
   const handleSessionUpdate = (params) => {
     const { update } = params ?? {};
@@ -15319,6 +15923,10 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       historyPolicy: "full",
       clientInfo: { name: "hydra-acp-tui", version: HYDRA_VERSION },
       ...opts.readonly === true ? { readonly: true } : {},
+      ...opts.drip === true ? {
+        replayMode: "drip",
+        ...opts.dripSpeed !== void 0 ? { dripSpeed: opts.dripSpeed } : {}
+      } : {},
       // Forward the user-chosen cwd via a full resume hint. An empty
       // upstreamSessionId routes through doResurrectFromImport
       // (first-launch imports); a real one takes the normal session/load
@@ -15410,7 +16018,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     dispatcher,
     repaintThrottleMs: config.tui.repaintThrottleMs,
     maxScrollbackLines: config.tui.maxScrollbackLines,
-    mouse: config.tui.mouse,
+    mouse: viewPrefs.mouseEnabled,
     progressIndicator: config.tui.progressIndicator,
     readonly: opts.readonly === true,
     onKey: (events) => {
@@ -15421,6 +16029,9 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         if (tryHandleHelpKey(ev)) {
           continue;
         }
+        if (tryHandleOptionsKey(ev)) {
+          continue;
+        }
         if (tryHandleScrollbackSearchKey(ev)) {
           continue;
         }
@@ -15664,7 +16275,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
   const buildHelpEntries = () => {
     const enqueueDesc = "enqueue prompt (sends now, or queues during a turn)";
     const amendDesc = "amend the in-flight turn (cancel + replace)";
-    const head = config.tui.defaultEnterAction === "amend" ? [
+    const head = viewPrefs.defaultEnterAction === "amend" ? [
       ["Enter", amendDesc],
       ["Ctrl+Enter / Shift+Enter / ^S", enqueueDesc]
     ] : [
@@ -15695,6 +16306,190 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     screen.setHelpPrompt(null);
     return true;
   };
+  const OPTION_IDS = [
+    "tools",
+    "plan",
+    "thoughts",
+    "diffs",
+    "mouse",
+    "enter"
+  ];
+  let optionsSelectedIndex = 0;
+  const optionValue = (id) => {
+    switch (id) {
+      case "tools":
+        return viewPrefs.toolsExpanded ? "expanded" : "collapsed";
+      case "plan":
+        return viewPrefs.planExpanded ? "expanded" : "collapsed";
+      case "thoughts":
+        return viewPrefs.showThoughts ? "shown" : "hidden";
+      case "diffs":
+        return viewPrefs.showFileUpdates;
+      case "mouse":
+        return viewPrefs.mouseEnabled ? "on" : "off";
+      case "enter":
+        return viewPrefs.defaultEnterAction;
+    }
+  };
+  const optionLabel = (id) => {
+    switch (id) {
+      case "tools":
+        return "Tools";
+      case "plan":
+        return "Plan";
+      case "thoughts":
+        return "Thoughts";
+      case "diffs":
+        return "File updates";
+      case "mouse":
+        return "Mouse capture";
+      case "enter":
+        return "Enter key";
+    }
+  };
+  const buildOptionsSpec = () => ({
+    title: "Session options",
+    options: OPTION_IDS.map((id) => ({
+      label: optionLabel(id),
+      value: optionValue(id)
+    })),
+    selectedIndex: optionsSelectedIndex
+  });
+  const refreshOptionsPrompt = () => {
+    if (!screen.isOptionsPromptActive()) {
+      return;
+    }
+    screen.setOptionsPrompt(buildOptionsSpec());
+  };
+  const toggleOptionsModal = () => {
+    if (screen.isOptionsPromptActive()) {
+      screen.setOptionsPrompt(null);
+      return;
+    }
+    optionsSelectedIndex = 0;
+    screen.setOptionsPrompt(buildOptionsSpec());
+  };
+  const applyOptionToggle = (id) => {
+    switch (id) {
+      case "tools":
+        viewPrefs.toolsExpanded = !viewPrefs.toolsExpanded;
+        renderToolsBlock();
+        break;
+      case "plan":
+        viewPrefs.planExpanded = !viewPrefs.planExpanded;
+        rerenderPlan();
+        break;
+      case "thoughts":
+        viewPrefs.showThoughts = !viewPrefs.showThoughts;
+        screen.setHideThoughts(!viewPrefs.showThoughts);
+        break;
+      case "diffs":
+        viewPrefs.showFileUpdates = viewPrefs.showFileUpdates === "diff" ? "edit" : "diff";
+        reRenderAllEditDiffs();
+        break;
+      case "mouse": {
+        const next = !screen.isMouseEnabled();
+        screen.setMouseEnabled(next);
+        viewPrefs.mouseEnabled = next;
+        break;
+      }
+      case "enter":
+        viewPrefs.defaultEnterAction = viewPrefs.defaultEnterAction === "amend" ? "enqueue" : "amend";
+        break;
+    }
+    refreshOptionsPrompt();
+  };
+  const saveOption = (id) => {
+    void (async () => {
+      try {
+        switch (id) {
+          case "tools":
+          case "plan":
+            screen.notify(`${optionLabel(id)} is session-only \u2014 not saved`);
+            return;
+          case "thoughts":
+            await setTuiConfigValue("showThoughts", viewPrefs.showThoughts);
+            break;
+          case "diffs":
+            await setTuiConfigValue(
+              "showFileUpdates",
+              viewPrefs.showFileUpdates
+            );
+            break;
+          case "mouse":
+            await setTuiConfigValue("mouse", viewPrefs.mouseEnabled);
+            break;
+          case "enter":
+            await setTuiConfigValue(
+              "defaultEnterAction",
+              viewPrefs.defaultEnterAction
+            );
+            break;
+        }
+        screen.notify(`saved default: ${optionLabel(id)} ${optionValue(id)}`);
+      } catch (err) {
+        screen.notify(
+          `save failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    })();
+  };
+  const tryHandleOptionsKey = (ev) => {
+    if (!screen.isOptionsPromptActive()) {
+      return false;
+    }
+    if (ev.type === "key") {
+      switch (ev.name) {
+        case "up":
+          optionsSelectedIndex = Math.max(0, optionsSelectedIndex - 1);
+          refreshOptionsPrompt();
+          return true;
+        case "down":
+          optionsSelectedIndex = Math.min(
+            OPTION_IDS.length - 1,
+            optionsSelectedIndex + 1
+          );
+          refreshOptionsPrompt();
+          return true;
+        case "enter": {
+          const id = OPTION_IDS[optionsSelectedIndex];
+          if (id) {
+            applyOptionToggle(id);
+          }
+          return true;
+        }
+        case "ctrl-o":
+        case "escape":
+        case "ctrl-c":
+          screen.setOptionsPrompt(null);
+          return true;
+        case "ctrl-d":
+          screen.setOptionsPrompt(null);
+          return false;
+        default:
+          return true;
+      }
+    }
+    if (ev.type === "char") {
+      if (/^[1-9]$/.test(ev.ch)) {
+        const idx = parseInt(ev.ch, 10) - 1;
+        const id = OPTION_IDS[idx];
+        if (id) {
+          optionsSelectedIndex = idx;
+          applyOptionToggle(id);
+        }
+        return true;
+      }
+      if (ev.ch === "s" || ev.ch === "S") {
+        const id = OPTION_IDS[optionsSelectedIndex];
+        if (id) {
+          saveOption(id);
+        }
+        return true;
+      }
+    }
+    return true;
+  };
   const teardown = () => {
     teardownStarted = true;
     process.off("SIGINT", sigintHandler);
@@ -15893,14 +16688,14 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
   const handleEffect = (effect) => {
     switch (effect.type) {
       case "send":
-        if (config.tui.defaultEnterAction === "amend") {
+        if (viewPrefs.defaultEnterAction === "amend") {
           amendPrompt(effect.text, effect.attachments, effect.displayText);
         } else {
           enqueuePrompt(effect.text, effect.attachments, effect.displayText);
         }
         return;
       case "amend":
-        if (config.tui.defaultEnterAction === "amend") {
+        if (viewPrefs.defaultEnterAction === "amend") {
           enqueuePrompt(effect.text, effect.attachments, effect.displayText);
         } else {
           amendPrompt(effect.text, effect.attachments, effect.displayText);
@@ -15993,9 +16788,8 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       case "next-live-session":
         void cycleLiveSession();
         return;
-      case "toggle-tools":
-        toolsExpanded = !toolsExpanded;
-        renderToolsBlock();
+      case "toggle-options":
+        toggleOptionsModal();
         return;
       case "toggle-thoughts":
         viewPrefs.showThoughts = !viewPrefs.showThoughts;
@@ -16007,6 +16801,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       case "toggle-mouse": {
         const next = !screen.isMouseEnabled();
         screen.setMouseEnabled(next);
+        viewPrefs.mouseEnabled = next;
         screen.notify(
           next ? "mouse capture on \u2014 wheel scrolls; shift+drag to select text" : "mouse capture off \u2014 click-drag selects text; PgUp/PgDn scrolls"
         );
@@ -16277,9 +17072,9 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         toolsBlockStartedAt = null;
         toolsBlockEndedAt = null;
         toolsBlockStopReason = null;
-        toolsExpanded = false;
         lastEditMarkPath = null;
         turnHasShownProse = false;
+        renderedEditDiffs.clear();
         screen.clearScrollback();
         return true;
       case "/demo-plan": {
@@ -16460,16 +17255,27 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     }
   };
   const toolStates = /* @__PURE__ */ new Map();
+  const renderedEditDiffs = /* @__PURE__ */ new Map();
   const exitPlanStates = /* @__PURE__ */ new Map();
   const toolCallOrder = [];
-  let toolsExpanded = false;
   let toolsBlockStartedAt = null;
   let toolsBlockEndedAt = null;
   let toolsBlockStopReason = null;
   let lastPlanEvent = null;
   const TOOLS_COLLAPSED_LIMIT = config.tui.maxToolItems;
   const PLAN_VISIBLE_LIMIT2 = config.tui.maxPlanItems;
-  const formatOptions = { maxPlanItems: PLAN_VISIBLE_LIMIT2 };
+  const planFormatOptions = () => ({
+    maxPlanItems: viewPrefs.planExpanded ? Infinity : PLAN_VISIBLE_LIMIT2
+  });
+  const rerenderPlan = () => {
+    if (lastPlanEvent === null) {
+      return;
+    }
+    const lines = formatEvent(lastPlanEvent, planFormatOptions());
+    if (lines.length > 0) {
+      screen.upsertLines("plan", [{ body: "" }, ...lines]);
+    }
+  };
   let agentBuffer = "";
   let agentKey = null;
   let agentSeq = 0;
@@ -16537,7 +17343,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     }
     const total = toolCallOrder.length;
     const capped = TOOLS_COLLAPSED_LIMIT > 0;
-    const visibleIds = !capped || toolsExpanded ? toolCallOrder : toolCallOrder.slice(Math.max(0, total - TOOLS_COLLAPSED_LIMIT));
+    const visibleIds = !capped || viewPrefs.toolsExpanded ? toolCallOrder : toolCallOrder.slice(Math.max(0, total - TOOLS_COLLAPSED_LIMIT));
     const hidden = total - visibleIds.length;
     const inProgress = toolsBlockEndedAt === null;
     const end = toolsBlockEndedAt ?? Date.now();
@@ -16556,12 +17362,8 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       const noun = total === 1 ? "tool" : "tools";
       const timing = stoppedReason !== null ? stoppedLabel : inProgress ? formatElapsed(elapsed) : `took ${formatElapsed(elapsed)}`;
       const parts = [`${total} ${noun}`, timing];
-      if (inProgress && capped) {
-        if (hidden > 0) {
-          parts.push(`${hidden} hidden \u2014 ^O expand`);
-        } else if (toolsExpanded && total > TOOLS_COLLAPSED_LIMIT) {
-          parts.push("^O collapse");
-        }
+      if (inProgress && capped && hidden > 0) {
+        parts.push(`${hidden} hidden`);
       }
       summary = parts.join(" \xB7 ");
     }
@@ -16580,7 +17382,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     for (const id of visibleIds) {
       const state = toolStates.get(id);
       if (state) {
-        lines.push(...formatToolLine2(state));
+        lines.push(...formatToolLine2(state, end));
       }
     }
     screen.upsertLines("tools", lines);
@@ -16597,7 +17399,8 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     const state = existing ?? {
       initialTitle: title ?? "tool",
       latestTitle: title ?? "tool",
-      status: status ?? "pending"
+      status: status ?? "pending",
+      startedAt: Date.now()
     };
     if (existing && title !== void 0) {
       state.latestTitle = title;
@@ -16608,6 +17411,9 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     if (!existing) {
       state.status = status ?? "pending";
     }
+    if (state.endedAt === void 0 && isTerminalToolStatus(state.status)) {
+      state.endedAt = Date.now();
+    }
     if (errorText !== void 0) {
       state.errorText = errorText;
     }
@@ -16627,35 +17433,60 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
   let lastEditMarkPath = null;
   let turnHasShownProse = false;
   const maybeRenderEditDiff = (toolCallId) => {
-    const mode = config.tui.showFileUpdates;
-    if (mode === "none") {
-      return;
-    }
-    const state = toolStates.get(toolCallId);
-    if (!state?.editDiff || state.status !== "completed") {
-      return;
-    }
-    if (mode === "diff") {
-      const lines2 = formatEditDiffBlock(state.editDiff, "diff");
-      if (lines2.length > 0) {
-        screen.upsertLines(`editdiff:${toolCallId}`, lines2);
+    const key = `editdiff:${toolCallId}`;
+    const lines = (() => {
+      const mode = viewPrefs.showFileUpdates;
+      if (mode === "none") {
+        return null;
       }
+      const state = toolStates.get(toolCallId);
+      if (!state?.editDiff || state.status !== "completed") {
+        return null;
+      }
+      if (mode === "diff") {
+        const out2 = formatEditDiffBlock(state.editDiff, "diff");
+        return out2.length > 0 ? out2 : null;
+      }
+      if (!turnHasShownProse) {
+        return null;
+      }
+      const diff2 = state.editDiff;
+      if (diff2.path && diff2.path === lastEditMarkPath && !screen.hasKey(key)) {
+        return null;
+      }
+      const out = formatEditDiffBlock(diff2, "edit");
+      if (out.length === 0) {
+        return null;
+      }
+      if (diff2.path) {
+        lastEditMarkPath = diff2.path;
+      }
+      return out;
+    })();
+    if (lines === null) {
+      screen.removeKey(key);
       return;
     }
-    if (!turnHasShownProse) {
-      return;
-    }
-    const diff = state.editDiff;
-    if (diff.path && diff.path === lastEditMarkPath) {
-      return;
-    }
-    const lines = formatEditDiffBlock(diff, "edit");
-    if (lines.length === 0) {
-      return;
+    const diff = toolStates.get(toolCallId)?.editDiff;
+    if (diff) {
+      renderedEditDiffs.set(toolCallId, diff);
     }
-    screen.upsertLines(`editdiff:${toolCallId}`, lines);
-    if (diff.path) {
-      lastEditMarkPath = diff.path;
+    screen.upsertLines(key, lines);
+  };
+  const reRenderAllEditDiffs = () => {
+    const mode = viewPrefs.showFileUpdates;
+    for (const [toolCallId, diff] of renderedEditDiffs) {
+      const key = `editdiff:${toolCallId}`;
+      if (mode === "none") {
+        screen.removeKey(key);
+        continue;
+      }
+      const out = formatEditDiffBlock(diff, mode);
+      if (out.length === 0) {
+        screen.removeKey(key);
+      } else {
+        screen.upsertLines(key, out);
+      }
     }
   };
   applyRenderEvent = (event) => {
@@ -16727,7 +17558,6 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       toolStates.clear();
       exitPlanStates.clear();
       toolCallOrder.length = 0;
-      toolsExpanded = false;
       toolsBlockEndedAt = null;
       lastEditMarkPath = null;
       turnHasShownProse = false;
@@ -16789,7 +17619,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       closeAgentText();
       closeThought();
       lastPlanEvent = event;
-      const lines = formatEvent(event, formatOptions);
+      const lines = formatEvent(event, planFormatOptions());
       if (lines.length > 0) {
         screen.upsertLines("plan", [{ body: "" }, ...lines]);
       }
@@ -16838,7 +17668,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
             stopped: true,
             amended: event.amended === true
           },
-          formatOptions
+          planFormatOptions()
         );
         if (lines.length > 0) {
           screen.upsertLines("plan", [{ body: "" }, ...lines]);
@@ -16868,7 +17698,6 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       toolsBlockStartedAt = null;
       toolsBlockEndedAt = null;
       toolsBlockStopReason = null;
-      toolsExpanded = false;
       upstreamInterruptedSeen = false;
       lastEditMarkPath = null;
       turnHasShownProse = false;
@@ -16956,7 +17785,6 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     toolsBlockStartedAt = null;
     toolsBlockEndedAt = null;
     toolsBlockStopReason = null;
-    toolsExpanded = false;
     lastEditMarkPath = null;
     turnHasShownProse = false;
   };
@@ -17114,6 +17942,10 @@ async function resolveSession(term, config, target, opts, pickerPrefs) {
     return ctx;
   }
   if (opts.forceNew) {
+    const agentStep = await ensureAgentForNew(term, target, opts);
+    if (agentStep !== "ok") {
+      return null;
+    }
     return newCtx(opts, cwd, config);
   }
   if (opts.resume) {
@@ -17137,7 +17969,8 @@ async function resolveSession(term, config, target, opts, pickerPrefs) {
       sessions,
       config,
       target,
-      prefs: pickerPrefs
+      prefs: pickerPrefs,
+      ...opts.initialPrompt !== void 0 ? { initialPrompt: opts.initialPrompt } : {}
     });
     if (choice.kind === "abort") {
       return null;
@@ -17146,6 +17979,13 @@ async function resolveSession(term, config, target, opts, pickerPrefs) {
       if (choice.prompt !== void 0) {
         opts.initialPrompt = choice.prompt;
       }
+      const agentStep = await ensureAgentForNew(term, target, opts);
+      if (agentStep === "cancel") {
+        return null;
+      }
+      if (agentStep === "back") {
+        continue;
+      }
       return newCtx(opts, cwd, config);
     }
     if (choice.kind === "fork") {
@@ -17305,6 +18145,38 @@ function newCtx(opts, cwd, config) {
     cwd
   };
 }
+async function ensureAgentForNew(term, target, opts) {
+  if (opts.agentId) {
+    return "ok";
+  }
+  if (await hasConfiguredDefaultAgent()) {
+    return "ok";
+  }
+  let agents;
+  try {
+    agents = await listAgents(target);
+  } catch {
+    return "ok";
+  }
+  if (agents.length === 0) {
+    return "ok";
+  }
+  const result = await promptForAgent(term, agents);
+  if (result.kind === "cancel") {
+    return "cancel";
+  }
+  if (result.kind === "back") {
+    return "back";
+  }
+  opts.agentId = result.agentId;
+  if (result.persist) {
+    try {
+      await setDefaultAgent(result.agentId);
+    } catch {
+    }
+  }
+  return "ok";
+}
 function debugLogUpdate(update, event) {
   writeDebugLine({
     src: "session/update",
@@ -17450,6 +18322,7 @@ var init_app = __esm({
     init_picker();
     init_import_cwd_prompt();
     init_import_action_prompt();
+    init_agent_prompt();
     init_screen();
     init_input();
     init_attachments();
@@ -17475,7 +18348,7 @@ var init_app = __esm({
       ["Alt+N / Alt+Tab", "next live session"],
       ["^T", "show / hide thoughts"],
       ["^V", "paste image from clipboard"],
-      ["^O", "expand / collapse tools block"],
+      ["^O", "session options (tools \xB7 plan \xB7 thoughts \xB7 diffs \xB7 mouse \xB7 enter)"],
       null,
       ["^R", "history reverse search (^S walks forward once engaged)"],
       ["PgUp / PgDn", "scroll scrollback"],
@@ -17516,6 +18389,7 @@ var KNOWN_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "detach",
   "diff",
   "disabled",
+  "drip",
   "fold",
   "follow",
   "force",
@@ -17538,8 +18412,10 @@ var KNOWN_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
 var KNOWN_VALUE_FLAGS = /* @__PURE__ */ new Set([
   "agent",
   "args",
+  "columns",
   "command",
   "cwd",
+  "drip-speed",
   "env",
   "host",
   "model",
@@ -20001,7 +20877,14 @@ var SessionManager = class {
       histories: this.histories,
       synopsisAgent: this.synopsisAgent,
       synopsisModel: this.synopsisModel,
-      persistTitle: (id, title) => this.persistTitle(id, title),
+      persistTitle: async (id, title) => {
+        const live = this.get(id);
+        if (live) {
+          await live.retitle(title);
+          return;
+        }
+        await this.persistTitle(id, title);
+      },
       persistSynopsis: (id, synopsis, through) => this.persistSynopsis(id, synopsis, through),
       logger: this.logger,
       npmRegistry: this.npmRegistry
@@ -20354,27 +21237,27 @@ var SessionManager = class {
       return false;
     }
   }
-  // When the last client detaches from a session that resolves to
-  // non-interactive — e.g. a `hydra cat` run, born interactive:undefined
-  // with originatingClient hydra-acp-cat, whose every prompt is ancillary
-  // — close it so its agent process doesn't linger until the (default 1h)
-  // idle timeout fires. The cold record is kept, so the rare refine-in-TUI
-  // still works via the resurrect/reseed path. Sessions promoted to
-  // interactive (driven by a real, non-ancillary prompt) resolve to true
-  // and are left running.
+  // When the last client detaches from a session that was never promoted
+  // to interactive, close it so its agent process doesn't linger until the
+  // (default 1h) idle timeout fires. This covers both `hydra cat` runs
+  // (born interactive:undefined with originatingClient hydra-acp-cat, every
+  // prompt ancillary) and any other client that opened a session but never
+  // sent a real, non-ancillary prompt. Promotion to interactive is
+  // synchronous on the first real prompt (Session.prompt sets _interactive
+  // = true before enqueuing), so a session that ever saw a genuine turn
+  // resolves to true here and is left running. The cold record is kept, so
+  // re-attaching resurrects via the reseed path.
+  //
+  // Note: this only fires from the explicit session/detach handler — raw WS
+  // close deliberately does NOT reap (see acp-ws.ts), so an abrupt
+  // disconnect of a never-prompted session falls through to the idle
+  // timeout rather than being torn down.
   async reapIfOrphanedNonInteractive(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session || session.attachedCount > 0) {
       return;
     }
-    const interactive = effectiveInteractive(
-      {
-        interactive: session.interactive,
-        ...session.originatingClient ? { originatingClient: session.originatingClient } : {}
-      },
-      true
-    );
-    if (interactive !== false) {
+    if (session.interactive === true) {
       return;
     }
     this.logger?.info(
@@ -20872,7 +21755,8 @@ var SessionManager = class {
         updatedAt: used,
         attachedClients: session.attachedCount,
         status: "live",
-        busy: session.turnStartedAt !== void 0
+        busy: session.turnStartedAt !== void 0,
+        awaitingInput: session.awaitingInput
       });
     }
     const records = await this.store.list().catch(() => []);
@@ -20910,7 +21794,8 @@ var SessionManager = class {
         updatedAt: used,
         attachedClients: 0,
         status: "cold",
-        busy: false
+        busy: false,
+        awaitingInput: false
       });
     }
     entries.sort((a, b) => a.updatedAt < b.updatedAt ? 1 : -1);
@@ -24814,10 +25699,11 @@ function registerAcpWsEndpoint(app, deps) {
         params.clientInfo,
         params.clientId
       );
+      const drip = params.replayMode === "drip";
       const { entries: replay, appliedPolicy } = await session.attach(
         client,
         params.historyPolicy,
-        { afterMessageId: params.afterMessageId }
+        { afterMessageId: params.afterMessageId, raw: drip }
       );
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
@@ -24825,10 +25711,35 @@ function registerAcpWsEndpoint(app, deps) {
         readonly
       });
       app.log.info(
-        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} requestedPolicy=${params.historyPolicy} appliedPolicy=${appliedPolicy} replayed=${replay.length} readonly=${readonly}`
+        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} requestedPolicy=${params.historyPolicy} appliedPolicy=${appliedPolicy} replayed=${replay.length} readonly=${readonly}${drip ? " replayMode=drip" : ""}`
       );
-      for (const note of replay) {
-        await connection.notify(note.method, note.params);
+      if (drip) {
+        const speed = params.dripSpeed && params.dripSpeed > 0 ? params.dripSpeed : 1;
+        const MAX_GAP_MS = 750;
+        void (async () => {
+          let prev = null;
+          for (const note of replay) {
+            const at = typeof note.recordedAt === "number" ? note.recordedAt : null;
+            if (prev !== null && at !== null) {
+              const gap = Math.min(MAX_GAP_MS, Math.max(0, (at - prev) / speed));
+              if (gap > 0) {
+                await new Promise((r) => setTimeout(r, gap));
+              }
+            }
+            if (at !== null) {
+              prev = at;
+            }
+            try {
+              await connection.notify(note.method, note.params);
+            } catch {
+              return;
+            }
+          }
+        })();
+      } else {
+        for (const note of replay) {
+          await connection.notify(note.method, note.params);
+        }
       }
       session.replayPendingPermissions(client);
       const modesPayload = buildModesPayload(session);
@@ -26689,12 +27600,15 @@ async function runSessionsList(opts = {}) {
   }
   const now = Date.now();
   const rows = visible.map((s) => toRow(s, now));
-  const widths = computeWidths(rows);
+  const formatOpts = {
+    columns: opts.columns ?? config.tui.sessionColumns ?? DEFAULT_COLUMNS,
+    cwdMaxWidth: config.tui.cwdColumnMaxWidth
+  };
+  const widths = computeWidths(rows, formatOpts);
   const maxWidth = process.stdout.isTTY ? process.stdout.columns : void 0;
-  const cwdMax = config.tui.cwdColumnMaxWidth;
-  process.stdout.write(formatRow(HEADER, widths, maxWidth, cwdMax) + "\n");
+  process.stdout.write(formatRow(HEADER, widths, maxWidth, formatOpts) + "\n");
   for (const r of rows) {
-    process.stdout.write(formatRow(r, widths, maxWidth, cwdMax) + "\n");
+    process.stdout.write(formatRow(r, widths, maxWidth, formatOpts) + "\n");
   }
   if (truncated > 0) {
     process.stdout.write(
@@ -26958,10 +27872,14 @@ function printBundleInfo(raw, cwdColumnMaxWidth) {
   }
   const summary = bundleToSummary(parsed);
   const row = toRow(summary);
-  const widths = computeWidths([row]);
+  const formatOpts = {
+    columns: ALL_COLUMNS,
+    cwdMaxWidth: cwdColumnMaxWidth
+  };
+  const widths = computeWidths([row], formatOpts);
   const maxWidth = process.stdout.isTTY ? process.stdout.columns : void 0;
-  process.stdout.write(formatRow(HEADER, widths, maxWidth, cwdColumnMaxWidth) + "\n");
-  process.stdout.write(formatRow(row, widths, maxWidth, cwdColumnMaxWidth) + "\n");
+  process.stdout.write(formatRow(HEADER, widths, maxWidth, formatOpts) + "\n");
+  process.stdout.write(formatRow(row, widths, maxWidth, formatOpts) + "\n");
   const originUpstream = parsed.session.upstreamSessionId ?? "-";
   process.stdout.write(
     `
@@ -27537,6 +28455,7 @@ function aggregate(bundle, status) {
   const durationMs = Number.isFinite(createdMs) && Number.isFinite(updatedMs) ? updatedMs - createdMs : null;
   return {
     sessionId: r.sessionId,
+    ...r.upstreamSessionId !== void 0 ? { upstreamSessionId: r.upstreamSessionId } : {},
     ...r.title !== void 0 ? { title: r.title } : {},
     cwd: r.cwd,
     agentId: r.agentId,
@@ -27564,6 +28483,9 @@ function formatSummary(d, verbose) {
   const lines = [];
   const pad = (label) => label.padEnd(14);
   lines.push(`${pad("Session:")}${d.sessionId}`);
+  if (d.upstreamSessionId) {
+    lines.push(`${pad("Upstream:")}${d.upstreamSessionId}`);
+  }
   if (d.title) {
     lines.push(`${pad("Title:")}${d.title}`);
   }
@@ -27688,6 +28610,9 @@ function formatDuration(ms) {
   return parts.join(" ");
 }
 
+// src/cli.ts
+init_session_row();
+
 // src/cli/commands/extensions.ts
 init_config();
 init_service_token();
@@ -28704,6 +29629,32 @@ function formatAge(ms) {
   const day = Math.floor(hour / 24);
   return `${day} day${day === 1 ? "" : "s"}`;
 }
+async function assertKnownAgent(agentId) {
+  const config = await loadConfig();
+  const serviceToken = await loadServiceToken();
+  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  let known;
+  try {
+    const r = await fetch(`${baseUrl}/v1/agents`, {
+      headers: { Authorization: `Bearer ${serviceToken}` }
+    });
+    if (!r.ok) {
+      return;
+    }
+    const body = await r.json();
+    known = body.agents.map((a) => a.id);
+  } catch {
+    return;
+  }
+  if (known.includes(agentId)) {
+    return;
+  }
+  process.stderr.write(
+    `hydra-acp: unknown agent '${agentId}'. Run 'hydra-acp agent list' to see available agents.
+`
+  );
+  process.exit(2);
+}
 async function runAgentsInstall(agentId) {
   if (!agentId) {
     process.stderr.write("Usage: hydra-acp agent install <agent-id>\n");
@@ -28875,16 +29826,7 @@ async function runAgentsSet(agentId, modelId) {
     process.exit(1);
     return;
   }
-  const raw = await readRawConfig3();
-  if (modelId === void 0) {
-    raw.defaultAgent = agentId;
-    await writeRawConfig3(raw);
-  } else {
-    const models = raw.defaultModels && typeof raw.defaultModels === "object" ? raw.defaultModels : {};
-    models[agentId] = modelId;
-    raw.defaultModels = models;
-    await writeRawConfig3(raw);
-  }
+  await setDefaultAgent(agentId, modelId);
   const disk = readAgentDefaults(await readRawConfig3());
   if (modelId !== void 0 && agentId !== disk.agent) {
     process.stdout.write(
@@ -28936,13 +29878,6 @@ async function readRawConfig3() {
   const raw = await fsp12.readFile(paths.config(), "utf8");
   return JSON.parse(raw);
 }
-async function writeRawConfig3(raw) {
-  await fsp12.writeFile(
-    paths.config(),
-    JSON.stringify(raw, null, 2) + "\n",
-    { encoding: "utf8", mode: 384 }
-  );
-}
 async function runAgentsRefresh() {
   const config = await loadConfig();
   const serviceToken = await loadServiceToken();
@@ -30458,6 +31393,9 @@ async function main() {
       if (streamBufferBytes !== void 0) {
         catOpts.streamBufferBytes = streamBufferBytes;
       }
+      if (agentIdFromFlag !== void 0) {
+        await assertKnownAgent(agentIdFromFlag);
+      }
       suppressUpdateNotice = true;
       await runCat(catOpts);
       return;
@@ -30498,11 +31436,24 @@ async function main() {
     case "sessions": {
       const sub = positional[1];
       if (sub === void 0 || sub === "list") {
+        const columnsRaw = resolveOption(flags, "columns");
+        let columns;
+        if (columnsRaw !== void 0) {
+          try {
+            columns = parseColumns(columnsRaw);
+          } catch (err) {
+            process.stderr.write(`${err.message}
+`);
+            process.exit(2);
+            return;
+          }
+        }
         await runSessionsList({
           all: flags.all === true,
           json: flags.json === true,
           host: typeof flags.host === "string" ? flags.host : void 0,
-          includeNonInteractive: flags["include-non-interactive"] === true
+          includeNonInteractive: flags["include-non-interactive"] === true,
+          columns
         });
         return;
       }
@@ -30737,6 +31688,9 @@ async function dispatchTui(flags, base) {
     );
     process.exit(2);
   }
+  if (base.agentId !== void 0) {
+    await assertKnownAgent(base.agentId);
+  }
   setHydraProcessTitle(buildTitleFromArgv(process.argv.slice(2)));
   const { runTui } = await Promise.resolve().then(() => (init_tui(), tui_exports));
   const tuiOpts = { resume, forceNew, readonly };
@@ -30761,6 +31715,19 @@ async function dispatchTui(flags, base) {
   if (base.dangerouslySkipPermissions === true) {
     tuiOpts.dangerouslySkipPermissions = true;
   }
+  if (flags.drip === true) {
+    if (base.sessionId === void 0) {
+      process.stderr.write(
+        "hydra-acp: --drip requires a session id. Pass --session <id-or-url> --drip.\n"
+      );
+      process.exit(2);
+    }
+    tuiOpts.drip = true;
+    const dripSpeed = parseNumericFlag(flags, "drip-speed");
+    if (dripSpeed !== void 0 && dripSpeed > 0) {
+      tuiOpts.dripSpeed = dripSpeed;
+    }
+  }
   await runTui(tuiOpts);
 }
 function parseNumericFlag(flags, name) {
@@ -30875,10 +31842,11 @@ function printHelp() {
       "  hydra-acp daemon start [--foreground]   Start daemon (detached by default; --foreground to attach)",
       "  hydra-acp daemon stop|restart",
       "  hydra-acp daemon logs [-f] [-n N]  Tail or follow the daemon log",
-      "  hydra-acp session [list] [--all] [--json] [--host=<host>] [--include-non-interactive]",
+      "  hydra-acp session [list] [--all] [--json] [--host=<host>] [--include-non-interactive] [--columns=<list>]",
       "                                     List sessions (live + 20 most-recent cold; --all lifts the cold cap AND surfaces non-interactive sessions; --json emits JSON for scripts).",
       "                                     --host filters by origin machine: 'local' (default) shows only sessions created here, 'all' shows everything, or pass a hostname (e.g. machine-b) to show only imports from that peer.",
       "                                     --include-non-interactive surfaces ancillary (e.g. `hydra cat`) or never-prompted sessions while keeping the cold cap (a narrower --all).",
+      "                                     --columns picks which columns show and their order, e.g. --columns=session,state,title,cost (valid: session,upstream,host,state,agent,model,age,cwd,title,cost). UPSTREAM/HOST/MODEL hidden by default; COST is the trailing column; overrides config.tui.sessionColumns.",
       "  hydra-acp session info <id> [--verbose] [--json] [--diff] [--fold] [--no-color] [--no-pager]",
       "                                     Aggregate one session: turn count, tool histogram, files touched, cost/duration, synopsis. --diff appends the session diff under the summary and pages the whole thing on a TTY (inherits --fold).",
       "  hydra-acp session diff <id> [--json] [--no-color] [--no-pager] [--fold]",