@hydra-acp/cli 0.1.1 → 0.1.2

package/dist/cli.js

@@ -34,7 +34,12 @@ var init_paths = __esm({
       agentsDir: () => path.join(hydraHome(), "agents"),
       agentDir: (id) => path.join(hydraHome(), "agents", id),
       sessionsDir: () => path.join(hydraHome(), "sessions"),
-      sessionFile: (id) => path.join(hydraHome(), "sessions", `${id}.json`),
+      // One directory per session id under sessions/. Co-locates the
+      // session record, its transcript, and any future per-session state
+      // (uploads, scratch, etc.) so the lifecycle is just "rm -rf the dir".
+      sessionDir: (id) => path.join(hydraHome(), "sessions", id),
+      sessionFile: (id) => path.join(hydraHome(), "sessions", id, "meta.json"),
+      historyFile: (id) => path.join(hydraHome(), "sessions", id, "history.jsonl"),
       extensionsDir: () => path.join(hydraHome(), "extensions"),
       extensionLogFile: (name) => path.join(hydraHome(), "extensions", `${name}.log`),
       extensionPidFile: (name) => path.join(hydraHome(), "extensions", `${name}.pid`),
@@ -215,6 +220,32 @@ function extractHydraMeta(meta) {
       out.resume = parsed.data;
     }
   }
+  if (typeof obj.currentModel === "string") {
+    out.currentModel = obj.currentModel;
+  }
+  if (typeof obj.currentMode === "string") {
+    out.currentMode = obj.currentMode;
+  }
+  if (Array.isArray(obj.availableCommands)) {
+    const cmds = [];
+    for (const raw of obj.availableCommands) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        continue;
+      }
+      const c = raw;
+      if (typeof c.name !== "string") {
+        continue;
+      }
+      const cmd = { name: c.name };
+      if (typeof c.description === "string") {
+        cmd.description = c.description;
+      }
+      cmds.push(cmd);
+    }
+    if (cmds.length > 0) {
+      out.availableCommands = cmds;
+    }
+  }
   return out;
 }
 function mergeMeta(passthrough, ours) {
@@ -502,6 +533,25 @@ function withCode(err, code) {
   err.code = code;
   return err;
 }
+function isStateUpdate(method, params) {
+  if (method !== "session/update") {
+    return false;
+  }
+  const obj = params ?? {};
+  const kind = obj.update?.sessionUpdate;
+  return typeof kind === "string" && STATE_UPDATE_KINDS.has(kind);
+}
+function sameAdvertisedCommands(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i]?.name !== b[i]?.name || a[i]?.description !== b[i]?.description) {
+      return false;
+    }
+  }
+  return true;
+}
 function captureInternalChunk(capture, params) {
   const obj = params ?? {};
   const update = obj.update ?? {};
@@ -564,7 +614,7 @@ function firstLine(text, max) {
   }
   return void 0;
 }
-var HYDRA_ID_ALPHABET, generateHydraId, HYDRA_SESSION_PREFIX, Session;
+var HYDRA_ID_ALPHABET, generateHydraId, HYDRA_SESSION_PREFIX, Session, STATE_UPDATE_KINDS;
 var init_session = __esm({
   "src/core/session.ts"() {
     "use strict";
@@ -586,14 +636,26 @@ var init_session = __esm({
       agentMeta;
       agentArgs;
       title;
+      // Snapshot state delivered to attaching clients via the attach
+      // response _meta rather than via history replay (which would be
+      // stale-prone for snapshot-shaped events).
+      currentModel;
+      currentMode;
       updatedAt;
       clients = /* @__PURE__ */ new Map();
       history = [];
+      historyStore;
       promptQueue = [];
       promptInFlight = false;
       closed = false;
       closeHandlers = [];
       titleHandlers = [];
+      // Subscribers notified after every entry that's actually persisted to
+      // history (skipping snapshot-shaped events filtered by
+      // recordAndBroadcast). The HTTP /v1/sessions/:id/history?follow=1
+      // endpoint uses this to tail a live session's conversation stream
+      // without participating in turns or prompts.
+      broadcastHandlers = [];
       // True once we've observed our first session/prompt; gates the
       // first-prompt-seeded title so subsequent prompts don't churn it.
       firstPromptSeeded = false;
@@ -613,12 +675,18 @@ var init_session = __esm({
       idleTimer;
       spawnReplacementAgent;
       agentChangeHandlers = [];
-      // Last available_commands_update we observed from the agent. Stored so
-      // we can re-broadcast a merged (hydra ∪ agent) list whenever either
-      // half changes — most importantly when a fresh client attaches and
-      // replays history, since the in-cache update is the daemon's merged
-      // form (the agent's raw form is never broadcast).
+      // Last available_commands_update we observed from the agent. Stored
+      // so we can re-broadcast a merged (hydra ∪ agent) list whenever
+      // either half changes, and persisted to meta.json so a fresh attach
+      // can deliver the merged list via _meta without depending on history
+      // replay.
       agentAdvertisedCommands = [];
+      // Persist hooks for snapshot-shaped state. SessionManager hooks these
+      // to mirror changes into meta.json so cold-resurrect attaches can
+      // surface the latest snapshot via the attach response _meta.
+      agentCommandsHandlers = [];
+      modelHandlers = [];
+      modeHandlers = [];
       constructor(init) {
         this.sessionId = init.sessionId ?? `${HYDRA_SESSION_PREFIX}${generateHydraId()}`;
         this.cwd = init.cwd;
@@ -628,11 +696,19 @@ var init_session = __esm({
         this.agentMeta = init.agentMeta;
         this.agentArgs = init.agentArgs;
         this.title = init.title;
+        this.currentModel = init.currentModel;
+        this.currentMode = init.currentMode;
+        if (init.agentCommands && init.agentCommands.length > 0) {
+          this.agentAdvertisedCommands = [...init.agentCommands];
+        }
         this.idleTimeoutMs = init.idleTimeoutMs ?? 0;
         this.spawnReplacementAgent = init.spawnReplacementAgent;
+        this.historyStore = init.historyStore;
+        if (init.seedHistory && init.seedHistory.length > 0) {
+          this.history = [...init.seedHistory];
+        }
         this.updatedAt = Date.now();
         this.wireAgent(this.agent);
-        this.broadcastMergedCommands();
       }
       broadcastMergedCommands() {
         const merged = [
@@ -661,8 +737,15 @@ var init_session = __esm({
           }
           const agentCmds = extractAdvertisedCommands(params);
           if (agentCmds !== null) {
-            this.agentAdvertisedCommands = agentCmds;
-            this.broadcastMergedCommands();
+            this.setAgentAdvertisedCommands(agentCmds);
+            return;
+          }
+          if (this.maybeApplyAgentModel(params)) {
+            this.recordAndBroadcast("session/update", params);
+            return;
+          }
+          if (this.maybeApplyAgentMode(params)) {
+            this.recordAndBroadcast("session/update", params);
             return;
           }
           this.maybeApplyAgentSessionInfo(params);
@@ -684,6 +767,27 @@ var init_session = __esm({
       get attachedCount() {
         return this.clients.size;
       }
+      // Snapshot of the current in-memory replay history. Used by the
+      // HTTP history endpoint to deliver the "what's accumulated so far"
+      // prefix before optionally tailing with onBroadcast. Returns a copy
+      // so callers can't mutate our cache.
+      getHistorySnapshot() {
+        return [...this.history];
+      }
+      // Subscribe to recordable broadcast entries — fires once per entry
+      // that lands in history (so snapshot-shaped session_info/model/mode/
+      // available_commands updates do NOT trigger this; they're broadcast
+      // live but not recorded). Returns an unsubscribe function the caller
+      // must invoke when done.
+      onBroadcast(handler) {
+        this.broadcastHandlers.push(handler);
+        return () => {
+          const i = this.broadcastHandlers.indexOf(handler);
+          if (i >= 0) {
+            this.broadcastHandlers.splice(i, 1);
+          }
+        };
+      }
       attach(client, historyPolicy) {
         if (this.closed) {
           throw withCode(
@@ -889,6 +993,91 @@ var init_session = __esm({
         this.firstPromptSeeded = true;
         this.setTitle(seed);
       }
+      // Apply an agent-emitted current_model_update. Returns true if the
+      // notification was a model update (caller still needs to broadcast
+      // it). Returns false otherwise so the caller can try the next kind.
+      maybeApplyAgentModel(params) {
+        const obj = params ?? {};
+        const update = obj.update ?? {};
+        if (update.sessionUpdate !== "current_model_update") {
+          return false;
+        }
+        const raw = typeof update.currentModel === "string" ? update.currentModel : typeof update.model === "string" ? update.model : void 0;
+        if (raw === void 0) {
+          return true;
+        }
+        const trimmed = raw.trim();
+        if (!trimmed || trimmed === this.currentModel) {
+          return true;
+        }
+        this.currentModel = trimmed;
+        for (const handler of this.modelHandlers) {
+          try {
+            handler(trimmed);
+          } catch {
+          }
+        }
+        return true;
+      }
+      maybeApplyAgentMode(params) {
+        const obj = params ?? {};
+        const update = obj.update ?? {};
+        if (update.sessionUpdate !== "current_mode_update") {
+          return false;
+        }
+        const raw = typeof update.currentMode === "string" ? update.currentMode : typeof update.mode === "string" ? update.mode : void 0;
+        if (raw === void 0) {
+          return true;
+        }
+        const trimmed = raw.trim();
+        if (!trimmed || trimmed === this.currentMode) {
+          return true;
+        }
+        this.currentMode = trimmed;
+        for (const handler of this.modeHandlers) {
+          try {
+            handler(trimmed);
+          } catch {
+          }
+        }
+        return true;
+      }
+      // Update the cached agent command list, fire persist handlers, and
+      // broadcast the merged list to attached clients. Idempotent on a
+      // structurally identical list so we don't churn meta.json on noisy
+      // re-emissions.
+      setAgentAdvertisedCommands(commands) {
+        if (sameAdvertisedCommands(this.agentAdvertisedCommands, commands)) {
+          this.broadcastMergedCommands();
+          return;
+        }
+        this.agentAdvertisedCommands = commands;
+        for (const handler of this.agentCommandsHandlers) {
+          try {
+            handler(commands);
+          } catch {
+          }
+        }
+        this.broadcastMergedCommands();
+      }
+      // Subscribe to snapshot-state updates. SessionManager wires these to
+      // persist the new value into meta.json so cold resurrect can restore
+      // them via the attach response _meta.
+      onAgentCommandsChange(handler) {
+        this.agentCommandsHandlers.push(handler);
+      }
+      onModelChange(handler) {
+        this.modelHandlers.push(handler);
+      }
+      onModeChange(handler) {
+        this.modeHandlers.push(handler);
+      }
+      // Returns a freshly merged command list (hydra ∪ agent) for callers
+      // that need a snapshot — notably acp-ws.ts's buildResponseMeta when
+      // assembling the attach response.
+      mergedAvailableCommands() {
+        return [...hydraCommandsAsAdvertised(), ...this.agentAdvertisedCommands];
+      }
       // Pick up an agent-emitted session_info_update and store its title
       // as our canonical record. The notification is also forwarded to
       // clients via the surrounding recordAndBroadcast call. Authoritative
@@ -1199,9 +1388,34 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       }
       recordAndBroadcast(method, params, excludeClientId) {
         const rewritten = this.rewriteForClient(params);
-        this.history.push({ method, params: rewritten, recordedAt: Date.now() });
-        if (this.history.length > 1e3) {
-          this.history = this.history.slice(-500);
+        const recordable = !isStateUpdate(method, rewritten);
+        if (recordable) {
+          const entry = {
+            method,
+            params: rewritten,
+            recordedAt: Date.now()
+          };
+          this.history.push(entry);
+          let trimmed = false;
+          if (this.history.length > 1e3) {
+            this.history = this.history.slice(-500);
+            trimmed = true;
+          }
+          if (this.historyStore) {
+            if (trimmed) {
+              void this.historyStore.rewrite(this.sessionId, [...this.history]).catch(() => void 0);
+            } else {
+              void this.historyStore.append(this.sessionId, entry).catch(
+                () => void 0
+              );
+            }
+          }
+          for (const handler of this.broadcastHandlers) {
+            try {
+              handler(entry);
+            } catch {
+            }
+          }
         }
         this.updatedAt = Date.now();
         for (const client of this.clients.values()) {
@@ -1297,6 +1511,12 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         }
       }
     };
+    STATE_UPDATE_KINDS = /* @__PURE__ */ new Set([
+      "session_info_update",
+      "current_model_update",
+      "current_mode_update",
+      "available_commands_update"
+    ]);
   }
 });
 
@@ -1552,13 +1772,248 @@ var init_sessions = __esm({
   }
 });
 
+// src/shim/resilient-ws.ts
+import { setTimeout as sleep3 } from "timers/promises";
+import { WebSocket } from "ws";
+function isResponse(msg) {
+  return !("method" in msg) && "id" in msg && msg.id !== void 0;
+}
+async function openWs(url, subprotocols) {
+  return new Promise((resolve2, reject) => {
+    const ws = new WebSocket(url, subprotocols);
+    const onOpen = () => {
+      ws.off("error", onError);
+      resolve2(wsToMessageStream(ws));
+    };
+    const onError = (err) => {
+      ws.off("open", onOpen);
+      reject(err);
+    };
+    ws.once("open", onOpen);
+    ws.once("error", onError);
+  });
+}
+var BACKOFF_INITIAL_MS, BACKOFF_MAX_MS, BACKOFF_MULTIPLIER, MAX_RECONNECT_ATTEMPTS, ResilientWsStream;
+var init_resilient_ws = __esm({
+  "src/shim/resilient-ws.ts"() {
+    "use strict";
+    init_ws_stream();
+    init_types();
+    BACKOFF_INITIAL_MS = 200;
+    BACKOFF_MAX_MS = 5e3;
+    BACKOFF_MULTIPLIER = 2;
+    MAX_RECONNECT_ATTEMPTS = 60;
+    ResilientWsStream = class {
+      constructor(opts) {
+        this.opts = opts;
+      }
+      opts;
+      current;
+      outboundQueue = [];
+      messageHandlers = [];
+      closeHandlers = [];
+      destroyed = false;
+      firstConnect = true;
+      reconnectInFlight;
+      connectGate;
+      releaseConnectGate;
+      pendingRequests = /* @__PURE__ */ new Map();
+      async start() {
+        await this.connectWithRetry();
+      }
+      onMessage(handler) {
+        this.messageHandlers.push(handler);
+      }
+      onClose(handler) {
+        this.closeHandlers.push(handler);
+      }
+      async send(message) {
+        if (this.destroyed) {
+          throw new Error("resilient ws stream is destroyed");
+        }
+        if (this.connectGate || !this.current) {
+          this.outboundQueue.push(message);
+          return;
+        }
+        try {
+          await this.current.send(message);
+        } catch (err) {
+          this.outboundQueue.push(message);
+          this.scheduleReconnect(err);
+        }
+      }
+      // Send a request directly and resolve when the matching response arrives
+      // on the same connection. Used by onConnect handlers to await replay-attach
+      // responses before letting the outbound queue drain. Bypasses the
+      // connectGate intentionally.
+      async request(message) {
+        if (this.destroyed) {
+          throw new Error("resilient ws stream is destroyed");
+        }
+        if (!this.current) {
+          throw new Error("resilient ws stream not connected");
+        }
+        const id = message.id;
+        const promise = new Promise((resolve2, reject) => {
+          this.pendingRequests.set(id, { resolve: resolve2, reject });
+        });
+        try {
+          await this.current.send(message);
+        } catch (err) {
+          this.pendingRequests.delete(id);
+          throw err;
+        }
+        return promise;
+      }
+      async close() {
+        this.destroyed = true;
+        if (this.current) {
+          await this.current.close().catch(() => void 0);
+        }
+        for (const handler of this.closeHandlers) {
+          handler();
+        }
+      }
+      async connectWithRetry() {
+        let attempt = 0;
+        let backoff = BACKOFF_INITIAL_MS;
+        while (!this.destroyed) {
+          try {
+            const stream = await openWs(this.opts.url, this.opts.subprotocols);
+            this.bindStream(stream);
+            const wasFirst = this.firstConnect;
+            this.firstConnect = false;
+            this.connectGate = new Promise((resolve2) => {
+              this.releaseConnectGate = resolve2;
+            });
+            try {
+              if (this.opts.onConnect) {
+                try {
+                  await this.opts.onConnect(wasFirst);
+                } catch (err) {
+                  this.log(
+                    `hydra-acp: post-connect handler failed: ${err.message}`
+                  );
+                }
+              }
+            } finally {
+              this.releaseConnectGate?.();
+              this.releaseConnectGate = void 0;
+              this.connectGate = void 0;
+            }
+            await this.flushQueue();
+            return;
+          } catch (err) {
+            attempt += 1;
+            if (this.opts.onConnectFailure) {
+              this.opts.onConnectFailure(err);
+            }
+            if (attempt >= MAX_RECONNECT_ATTEMPTS) {
+              throw new Error(
+                `hydra-acp: gave up reconnecting after ${attempt} attempts: ${err.message}`
+              );
+            }
+            this.log(
+              `hydra-acp: connect attempt ${attempt} failed (${err.message}); retrying in ${backoff}ms`
+            );
+            await sleep3(backoff);
+            backoff = Math.min(backoff * BACKOFF_MULTIPLIER, BACKOFF_MAX_MS);
+          }
+        }
+      }
+      bindStream(stream) {
+        this.current = stream;
+        stream.onMessage((msg) => {
+          if (isResponse(msg)) {
+            const pending = this.pendingRequests.get(msg.id);
+            if (pending) {
+              this.pendingRequests.delete(msg.id);
+              pending.resolve(msg);
+            }
+          }
+          for (const handler of this.messageHandlers) {
+            handler(msg);
+          }
+        });
+        stream.onClose((err) => {
+          if (this.destroyed) {
+            return;
+          }
+          this.current = void 0;
+          if (this.pendingRequests.size > 0) {
+            const reason = err ?? new Error("ws closed before response");
+            for (const { reject } of this.pendingRequests.values()) {
+              reject(reason);
+            }
+            this.pendingRequests.clear();
+          }
+          this.scheduleReconnect(err);
+        });
+      }
+      async flushQueue() {
+        if (!this.current) {
+          return;
+        }
+        const queue = this.outboundQueue;
+        this.outboundQueue = [];
+        for (const msg of queue) {
+          try {
+            await this.current.send(msg);
+          } catch (err) {
+            this.outboundQueue.unshift(msg);
+            this.scheduleReconnect(err);
+            return;
+          }
+        }
+      }
+      scheduleReconnect(err) {
+        if (this.destroyed || this.reconnectInFlight) {
+          return;
+        }
+        this.log(
+          `hydra-acp: connection lost (${err?.message ?? "no error"}); reconnecting...`
+        );
+        if (this.opts.onDisconnect) {
+          try {
+            this.opts.onDisconnect(err);
+          } catch (hookErr) {
+            this.log(
+              `hydra-acp: onDisconnect handler threw: ${hookErr.message}`
+            );
+          }
+        }
+        this.reconnectInFlight = (async () => {
+          try {
+            await this.connectWithRetry();
+          } catch (final) {
+            for (const handler of this.closeHandlers) {
+              handler(final);
+            }
+            this.destroyed = true;
+          } finally {
+            this.reconnectInFlight = void 0;
+          }
+        })();
+      }
+      log(line) {
+        if (this.opts.log) {
+          this.opts.log(line);
+          return;
+        }
+        process.stderr.write(`${line}
+`);
+      }
+    };
+  }
+});
+
 // src/tui/history.ts
-import { promises as fs8 } from "fs";
+import { promises as fs9 } from "fs";
 import * as path4 from "path";
 async function loadHistory(file) {
   let text;
   try {
-    text = await fs8.readFile(file, "utf8");
+    text = await fs9.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return [];
@@ -1598,9 +2053,9 @@ function appendEntry(history, entry) {
   return out;
 }
 async function saveHistory(file, history) {
-  await fs8.mkdir(path4.dirname(file), { recursive: true });
+  await fs9.mkdir(path4.dirname(file), { recursive: true });
   const lines = history.map((entry) => JSON.stringify(entry));
-  await fs8.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
+  await fs9.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
 }
 var HISTORY_CAP;
 var init_history = __esm({
@@ -2622,8 +3077,24 @@ var init_screen = __esm({
         const w = this.term.width;
         this.term.moveTo(1, 1).eraseLineAfter();
         const usage = formatUsage(this.header.usage);
-        const cwdRoom = Math.max(8, w - 40 - (usage ? usage.length + 3 : 0));
-        this.term.bold("hydra")(" \xB7 ").cyan(this.header.agent)(" \xB7 ").dim(truncate(this.header.cwd, cwdRoom))(" \xB7 ").yellow(shortId(this.header.sessionId));
+        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);
@@ -2840,6 +3311,8 @@ var init_screen = __esm({
           if (this.banner.elapsedMs !== void 0 && this.banner.elapsedMs >= 1e3) {
             this.term(" ").dim(formatElapsed(this.banner.elapsedMs));
           }
+        } else if (this.banner.status === "disconnected") {
+          this.term.brightRed(`${dot} ${this.banner.status}`);
         } else {
           this.term.brightGreen(`${dot} ${this.banner.status}`);
         }
@@ -3340,10 +3813,19 @@ function mapUpdate(update) {
       return mapUsage(u);
     case "available_commands_update":
       return mapAvailableCommands(u);
+    case "session_info_update":
+      return mapSessionInfo(u);
     default:
       return { kind: "unknown", sessionUpdate: tag, raw: update };
   }
 }
+function mapSessionInfo(u) {
+  const title = readString(u, "title");
+  if (title === void 0) {
+    return null;
+  }
+  return { kind: "session-info", title };
+}
 function mapAvailableCommands(u) {
   const list = u.availableCommands ?? u.commands;
   if (!Array.isArray(list)) {
@@ -3584,6 +4066,8 @@ function formatEvent(event) {
       return [];
     case "available-commands":
       return [];
+    case "session-info":
+      return [];
     case "unknown":
       return [];
   }
@@ -3849,8 +4333,7 @@ var init_format = __esm({
 });
 
 // src/tui/app.ts
-import WebSocket2 from "ws";
-import { once } from "events";
+import { nanoid as nanoid3 } from "nanoid";
 import termkit from "terminal-kit";
 async function runTuiApp(opts) {
   const config = await ensureConfig();
@@ -3867,9 +4350,31 @@ async function runSession(term, config, opts) {
     term.grabInput(false);
     process.exit(0);
   }
-  const ws = await openWs2(config);
-  const stream = wsToMessageStream(ws);
+  const protocol = config.daemon.tls ? "wss" : "ws";
+  const wsUrl = `${protocol}://${config.daemon.host}:${config.daemon.port}/acp`;
+  const subprotocols = ["acp.v1", `hydra-acp-token.${config.daemon.authToken}`];
+  let onReconnect = null;
+  let onDisconnectHook = null;
+  const stream = new ResilientWsStream({
+    url: wsUrl,
+    subprotocols,
+    onConnect: async (firstConnect) => {
+      if (firstConnect) {
+        return;
+      }
+      if (onReconnect) {
+        await onReconnect();
+      }
+    },
+    onDisconnect: (err) => {
+      if (onDisconnectHook) {
+        onDisconnectHook(err);
+      }
+    },
+    log: () => void 0
+  });
   const conn = new JsonRpcConnection(stream);
+  await stream.start();
   let bufferedEvents = [];
   let applyRenderEvent = null;
   const appendRender = (event) => {
@@ -4033,6 +4538,10 @@ async function runSession(term, config, opts) {
   let resolvedSessionId = ctx.sessionId;
   let resolvedAgentId = ctx.agentId;
   let resolvedCwd = ctx.cwd;
+  let resolvedTitle;
+  let initialModel;
+  let initialMode;
+  let initialCommands;
   if (ctx.sessionId === "__new__") {
     const created = await conn.request("session/new", {
       cwd: ctx.cwd,
@@ -4048,6 +4557,16 @@ async function runSession(term, config, opts) {
     if (hydraMeta.cwd) {
       resolvedCwd = hydraMeta.cwd;
     }
+    if (hydraMeta.name) {
+      resolvedTitle = hydraMeta.name;
+    }
+    initialModel = hydraMeta.currentModel;
+    initialMode = hydraMeta.currentMode;
+    if (hydraMeta.availableCommands) {
+      initialCommands = hydraMeta.availableCommands.map(
+        (c) => c.description !== void 0 ? { name: c.name, description: c.description } : { name: c.name }
+      );
+    }
   } else {
     const attached = await conn.request("session/attach", {
       sessionId: ctx.sessionId,
@@ -4063,8 +4582,17 @@ async function runSession(term, config, opts) {
     if (hydraMeta.cwd) {
       resolvedCwd = hydraMeta.cwd;
     }
+    if (hydraMeta.name) {
+      resolvedTitle = hydraMeta.name;
+    }
+    initialModel = hydraMeta.currentModel;
+    initialMode = hydraMeta.currentMode;
+    if (hydraMeta.availableCommands) {
+      initialCommands = hydraMeta.availableCommands.map(
+        (c) => c.description !== void 0 ? { name: c.name, description: c.description } : { name: c.name }
+      );
+    }
   }
-  void upstreamSessionId;
   const historyFile = paths.tuiHistoryFile();
   let history = await loadHistory(historyFile).catch(() => []);
   const dispatcher = new InputDispatcher({ history });
@@ -4102,7 +4630,7 @@ async function runSession(term, config, opts) {
     { name: "/demo-plan", description: "Inject synthetic plan events (UI test)" },
     { name: "/demo-tool", description: "Inject a synthetic tool-call sequence (UI test)" }
   ];
-  let agentCommands = [];
+  let agentCommands = initialCommands ?? [];
   const allCommands = () => {
     const seen = /* @__PURE__ */ new Set();
     const out = [];
@@ -4226,8 +4754,15 @@ async function runSession(term, config, opts) {
   screen.setHeader({
     agent: headerName,
     cwd: resolvedCwd,
-    sessionId: resolvedSessionId
+    sessionId: resolvedSessionId,
+    title: resolvedTitle
   });
+  if (initialMode) {
+    screen.appendLines(formatEvent({ kind: "mode-changed", mode: initialMode }));
+  }
+  if (initialModel) {
+    screen.appendLines(formatEvent({ kind: "model-changed", model: initialModel }));
+  }
   let finishSession = null;
   const sessionDone = new Promise((resolve2) => {
     finishSession = resolve2;
@@ -4313,10 +4848,7 @@ async function runSession(term, config, opts) {
     process.off("SIGINT", sigintHandler);
     screen.stop();
     saveHistory(historyFile, history).catch(() => void 0);
-    try {
-      ws.close();
-    } catch {
-    }
+    void stream.close().catch(() => void 0);
   };
   const stop = (code = 0) => {
     teardown();
@@ -4709,6 +5241,12 @@ async function runSession(term, config, opts) {
       refreshCompletions();
       return;
     }
+    if (event.kind === "session-info") {
+      if (event.title !== void 0) {
+        screen.setHeader({ title: event.title });
+      }
+      return;
+    }
     if (event.kind === "usage-update") {
       let changed = false;
       if (event.used !== void 0 && usage.used !== event.used) {
@@ -4804,6 +5342,95 @@ async function runSession(term, config, opts) {
   } finally {
     screen.resumeRepaint();
   }
+  const resetInFlightUiState = () => {
+    if (pendingPermission) {
+      const resolve2 = pendingPermission.resolve;
+      pendingPermission = null;
+      screen.setPermissionPrompt(null);
+      resolve2({ outcome: { outcome: "cancelled" } });
+    }
+    closeAgentText();
+    if (toolsBlockStartedAt !== null) {
+      if (toolCallOrder.length > 0) {
+        toolsBlockEndedAt = Date.now();
+        renderToolsBlock();
+        screen.clearKey("tools");
+      } else {
+        screen.removeBlock("tools");
+      }
+      toolStates.clear();
+      toolCallOrder.length = 0;
+      toolsBlockStartedAt = null;
+      toolsBlockEndedAt = null;
+      toolsExpanded = false;
+    }
+    screen.clearKey("plan");
+    if (pendingTurns > 0) {
+      adjustPendingTurns(-pendingTurns);
+    }
+  };
+  onDisconnectHook = () => {
+    screen.setBanner({ status: "disconnected", elapsedMs: void 0 });
+  };
+  onReconnect = async () => {
+    resetInFlightUiState();
+    const initReq = {
+      jsonrpc: "2.0",
+      id: `tui-reinit-${nanoid3()}`,
+      method: "initialize",
+      params: {
+        protocolVersion: 1,
+        clientCapabilities: {
+          fs: { readTextFile: false, writeTextFile: false },
+          terminal: false
+        },
+        clientInfo: { name: "hydra-acp-tui", version: "0.1.0" }
+      }
+    };
+    try {
+      await stream.request(initReq);
+    } catch {
+    }
+    const attachReq = {
+      jsonrpc: "2.0",
+      id: `tui-reattach-${nanoid3()}`,
+      method: "session/attach",
+      params: {
+        sessionId: resolvedSessionId,
+        historyPolicy: "none",
+        clientInfo: { name: "hydra-acp-tui", version: "0.1.0" },
+        ...upstreamSessionId !== void 0 ? {
+          _meta: {
+            [HYDRA_META_KEY]: {
+              resume: {
+                upstreamSessionId,
+                agentId: resolvedAgentId,
+                cwd: resolvedCwd
+              }
+            }
+          }
+        } : {}
+      }
+    };
+    try {
+      const resp = await stream.request(attachReq);
+      if (resp.error) {
+        throw new Error(resp.error.message);
+      }
+    } catch (err) {
+      screen.appendLines([
+        {
+          prefix: "  ",
+          body: `reattach failed: ${err.message}`,
+          bodyStyle: "tool-status-fail"
+        }
+      ]);
+    }
+    screen.setBanner({
+      status: pendingTurns > 0 ? "running" : "ready",
+      elapsedMs: pendingTurns > 0 ? 0 : void 0
+    });
+  };
   conn.onClose((err) => {
     if (err) {
       term.red(`
@@ -4869,23 +5496,13 @@ function newCtx(opts, cwd, config) {
     cwd
   };
 }
-async function openWs2(config) {
-  const protocol = config.daemon.tls ? "wss" : "ws";
-  const url = `${protocol}://${config.daemon.host}:${config.daemon.port}/acp`;
-  const ws = new WebSocket2(url, [
-    "acp.v1",
-    `hydra-acp-token.${config.daemon.authToken}`
-  ]);
-  await once(ws, "open");
-  return ws;
-}
 var PLAN_PREFIX_TEXT;
 var init_app = __esm({
   "src/tui/app.ts"() {
     "use strict";
     init_connection();
-    init_ws_stream();
     init_types();
+    init_resilient_ws();
     init_config();
     init_daemon_bootstrap();
     init_paths();
@@ -5013,7 +5630,7 @@ import { setTimeout as sleep2 } from "timers/promises";
 
 // src/daemon/server.ts
 init_config();
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as fsp2 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
@@ -5330,6 +5947,10 @@ init_paths();
 import * as fs4 from "fs/promises";
 import * as path2 from "path";
 import { z as z4 } from "zod";
+var PersistedAgentCommand = z4.object({
+  name: z4.string(),
+  description: z4.string().optional()
+});
 var SessionRecord = z4.object({
   version: z4.literal(1),
   sessionId: z4.string(),
@@ -5338,6 +5959,13 @@ var SessionRecord = z4.object({
   cwd: z4.string(),
   title: z4.string().optional(),
   agentArgs: z4.array(z4.string()).optional(),
+  // Snapshot of "what is currently true about this session" carried in
+  // meta.json so a late-attaching or cold-resurrected client can be
+  // told via the attach response _meta without depending on history
+  // replay of a snapshot-shaped notification.
+  currentModel: z4.string().optional(),
+  currentMode: z4.string().optional(),
+  agentCommands: z4.array(PersistedAgentCommand).optional(),
   createdAt: z4.string(),
   updatedAt: z4.string()
 });
@@ -5350,7 +5978,7 @@ function assertSafeId(id) {
 var SessionStore = class {
   async write(record) {
     assertSafeId(record.sessionId);
-    await fs4.mkdir(paths.sessionsDir(), { recursive: true });
+    await fs4.mkdir(paths.sessionDir(record.sessionId), { recursive: true });
     const full = { version: 1, ...record };
     await fs4.writeFile(
       paths.sessionFile(record.sessionId),
@@ -5390,6 +6018,14 @@ var SessionStore = class {
         throw err;
       }
     }
+    try {
+      await fs4.rmdir(paths.sessionDir(sessionId));
+    } catch (err) {
+      const e = err;
+      if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
+        throw err;
+      }
+    }
   }
   async list() {
     let entries;
@@ -5404,11 +6040,7 @@ var SessionStore = class {
     }
     const records = [];
     for (const entry of entries) {
-      if (!entry.endsWith(".json")) {
-        continue;
-      }
-      const id = entry.slice(0, -".json".length);
-      const record = await this.read(id);
+      const record = await this.read(entry);
       if (record) {
         records.push(record);
       }
@@ -5425,11 +6057,137 @@ function recordFromMemorySession(args) {
     cwd: args.cwd,
     title: args.title,
     agentArgs: args.agentArgs,
+    currentModel: args.currentModel,
+    currentMode: args.currentMode,
+    agentCommands: args.agentCommands,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
   };
 }
 
+// src/core/history-store.ts
+init_paths();
+import * as fs5 from "fs/promises";
+var SESSION_ID_PATTERN2 = /^[A-Za-z0-9_-]+$/;
+var MAX_ENTRIES = 1e3;
+var HistoryStore = class {
+  // Serialize writes per session id so appends and rewrites don't
+  // interleave JSONL lines on disk. The chain swallows errors so one
+  // failed append doesn't poison every subsequent write.
+  writeQueues = /* @__PURE__ */ new Map();
+  async append(sessionId, entry) {
+    if (!SESSION_ID_PATTERN2.test(sessionId)) {
+      return;
+    }
+    return this.enqueue(sessionId, async () => {
+      await fs5.mkdir(paths.sessionDir(sessionId), { recursive: true });
+      const line = JSON.stringify(entry) + "\n";
+      await fs5.appendFile(paths.historyFile(sessionId), line, {
+        encoding: "utf8",
+        mode: 384
+      });
+    });
+  }
+  async rewrite(sessionId, entries) {
+    if (!SESSION_ID_PATTERN2.test(sessionId)) {
+      return;
+    }
+    return this.enqueue(sessionId, async () => {
+      await fs5.mkdir(paths.sessionDir(sessionId), { recursive: true });
+      const body = entries.length === 0 ? "" : entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+      await fs5.writeFile(paths.historyFile(sessionId), body, {
+        encoding: "utf8",
+        mode: 384
+      });
+    });
+  }
+  async load(sessionId) {
+    if (!SESSION_ID_PATTERN2.test(sessionId)) {
+      return [];
+    }
+    const pending = this.writeQueues.get(sessionId);
+    if (pending) {
+      await pending;
+    }
+    let raw;
+    try {
+      raw = await fs5.readFile(paths.historyFile(sessionId), "utf8");
+    } catch (err) {
+      const e = err;
+      if (e.code === "ENOENT") {
+        return [];
+      }
+      throw err;
+    }
+    const out = [];
+    for (const line of raw.split("\n")) {
+      if (line.length === 0) {
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        continue;
+      }
+      const obj = parsed;
+      if (typeof obj.method !== "string") {
+        continue;
+      }
+      if (typeof obj.recordedAt !== "number") {
+        continue;
+      }
+      out.push({
+        method: obj.method,
+        params: obj.params,
+        recordedAt: obj.recordedAt
+      });
+    }
+    if (out.length > MAX_ENTRIES) {
+      return out.slice(-MAX_ENTRIES);
+    }
+    return out;
+  }
+  async delete(sessionId) {
+    if (!SESSION_ID_PATTERN2.test(sessionId)) {
+      return;
+    }
+    return this.enqueue(sessionId, async () => {
+      try {
+        await fs5.unlink(paths.historyFile(sessionId));
+      } catch (err) {
+        const e = err;
+        if (e.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      try {
+        await fs5.rmdir(paths.sessionDir(sessionId));
+      } catch (err) {
+        const e = err;
+        if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
+          throw err;
+        }
+      }
+    });
+  }
+  enqueue(sessionId, task) {
+    const prev = this.writeQueues.get(sessionId) ?? Promise.resolve();
+    const task$ = prev.then(task, task);
+    const settled = task$.catch(() => void 0);
+    this.writeQueues.set(sessionId, settled);
+    void settled.finally(() => {
+      if (this.writeQueues.get(sessionId) === settled) {
+        this.writeQueues.delete(sessionId);
+      }
+    });
+    return task$;
+  }
+};
+
 // src/core/session-manager.ts
 init_types();
 var SessionManager = class {
@@ -5437,6 +6195,7 @@ var SessionManager = class {
     this.registry = registry;
     this.spawner = spawner ?? ((opts) => AgentInstance.spawn(opts));
     this.store = store ?? new SessionStore();
+    this.histories = new HistoryStore();
     this.idleTimeoutMs = options.idleTimeoutMs ?? 0;
   }
   registry;
@@ -5444,7 +6203,12 @@ var SessionManager = class {
   resurrectionInflight = /* @__PURE__ */ new Map();
   spawner;
   store;
+  histories;
   idleTimeoutMs;
+  // Serialize meta.json read-modify-write operations per session id so
+  // concurrent snapshot updates (e.g. an agent emitting model + mode
+  // back-to-back) don't lose writes via interleaved reads.
+  metaWriteQueues = /* @__PURE__ */ new Map();
   async create(params) {
     const fresh = await this.bootstrapAgent({
       agentId: params.agentId,
@@ -5461,7 +6225,8 @@ var SessionManager = class {
       title: params.title,
       agentArgs: params.agentArgs,
       idleTimeoutMs: this.idleTimeoutMs,
-      spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] })
+      spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
+      historyStore: this.histories
     });
     await this.attachManagerHooks(session);
     return session;
@@ -5537,7 +6302,12 @@ var SessionManager = class {
       title: params.title,
       agentArgs: params.agentArgs,
       idleTimeoutMs: this.idleTimeoutMs,
-      spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] })
+      spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
+      historyStore: this.histories,
+      seedHistory: params.seedHistory,
+      currentModel: params.currentModel,
+      currentMode: params.currentMode,
+      agentCommands: params.agentCommands
     });
     await this.attachManagerHooks(session);
     return session;
@@ -5591,6 +6361,7 @@ var SessionManager = class {
       this.sessions.delete(session.sessionId);
       if (deleteRecord) {
         void this.store.delete(session.sessionId).catch(() => void 0);
+        void this.histories.delete(session.sessionId).catch(() => void 0);
       }
     });
     session.onTitleChange((title) => {
@@ -5601,6 +6372,24 @@ var SessionManager = class {
         () => void 0
       );
     });
+    session.onModelChange((model) => {
+      void this.persistSnapshot(session.sessionId, { currentModel: model }).catch(
+        () => void 0
+      );
+    });
+    session.onModeChange((mode) => {
+      void this.persistSnapshot(session.sessionId, { currentMode: mode }).catch(
+        () => void 0
+      );
+    });
+    session.onAgentCommandsChange((commands) => {
+      void this.persistSnapshot(session.sessionId, {
+        agentCommands: commands.map((c) => ({
+          name: c.name,
+          ...c.description !== void 0 ? { description: c.description } : {}
+        }))
+      }).catch(() => void 0);
+    });
     this.sessions.set(session.sessionId, session);
     await this.store.write(
       recordFromMemorySession({
@@ -5609,22 +6398,45 @@ var SessionManager = class {
         agentId: session.agentId,
         cwd: session.cwd,
         title: session.title,
-        agentArgs: session.agentArgs
+        agentArgs: session.agentArgs,
+        currentModel: session.currentModel,
+        currentMode: session.currentMode
       })
     ).catch(() => void 0);
   }
+  // Resolve a session's recorded history without forcing a resurrect.
+  // Returns the in-memory snapshot if the session is hot, falls back
+  // to the on-disk history file otherwise. Returns undefined if the
+  // session id is unknown to both the live map and disk store, so the
+  // caller can distinguish "no history yet" (empty array) from "404".
+  async getHistory(sessionId) {
+    const live = this.sessions.get(sessionId);
+    if (live) {
+      return live.getHistorySnapshot();
+    }
+    const record = await this.store.read(sessionId);
+    if (!record) {
+      return void 0;
+    }
+    return this.histories.load(sessionId).catch(() => []);
+  }
   async loadFromDisk(sessionId) {
     const record = await this.store.read(sessionId);
     if (!record) {
       return void 0;
     }
+    const seedHistory = await this.histories.load(sessionId).catch(() => []);
     return {
       hydraSessionId: record.sessionId,
       upstreamSessionId: record.upstreamSessionId,
       agentId: record.agentId,
       cwd: record.cwd,
       title: record.title,
-      agentArgs: record.agentArgs
+      agentArgs: record.agentArgs,
+      seedHistory: seedHistory.length > 0 ? seedHistory : void 0,
+      currentModel: record.currentModel,
+      currentMode: record.currentMode,
+      agentCommands: record.agentCommands
     };
   }
   get(sessionId) {
@@ -5712,14 +6524,16 @@ var SessionManager = class {
   // record's title in sync with what was broadcast to clients so a
   // daemon restart (and later resurrect) restores the same title.
   async persistTitle(sessionId, title) {
-    const record = await this.store.read(sessionId);
-    if (!record) {
-      return;
-    }
-    await this.store.write({
-      ...record,
-      title,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    await this.enqueueMetaWrite(sessionId, async () => {
+      const record = await this.store.read(sessionId);
+      if (!record) {
+        return;
+      }
+      await this.store.write({
+        ...record,
+        title,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
     });
   }
   // Persist an agent swap from /hydra switch. The on-disk record's
@@ -5727,17 +6541,52 @@ var SessionManager = class {
   // later resurrect) brings the session back up on the agent the user
   // most recently switched to, not the one it was originally created on.
   async persistAgentChange(sessionId, agentId, upstreamSessionId) {
-    const record = await this.store.read(sessionId);
-    if (!record) {
-      return;
-    }
-    await this.store.write({
-      ...record,
-      agentId,
-      upstreamSessionId,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    await this.enqueueMetaWrite(sessionId, async () => {
+      const record = await this.store.read(sessionId);
+      if (!record) {
+        return;
+      }
+      await this.store.write({
+        ...record,
+        agentId,
+        upstreamSessionId,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
     });
   }
+  // Update one or more snapshot fields (model, mode, commands) in
+  // meta.json. Used so cold-resurrect can deliver the latest snapshot
+  // to attaching clients via the attach response _meta. No-op if the
+  // session record has gone away (race with deleteRecord).
+  async persistSnapshot(sessionId, update) {
+    await this.enqueueMetaWrite(sessionId, async () => {
+      const record = await this.store.read(sessionId);
+      if (!record) {
+        return;
+      }
+      await this.store.write({
+        ...record,
+        ...update.currentModel !== void 0 ? { currentModel: update.currentModel } : {},
+        ...update.currentMode !== void 0 ? { currentMode: update.currentMode } : {},
+        ...update.agentCommands !== void 0 ? { agentCommands: update.agentCommands } : {},
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+  }
+  // Serialize meta.json writes per session id so concurrent
+  // read-modify-write operations don't interleave reads.
+  enqueueMetaWrite(sessionId, task) {
+    const prev = this.metaWriteQueues.get(sessionId) ?? Promise.resolve();
+    const next = prev.then(task, task);
+    const settled = next.catch(() => void 0);
+    this.metaWriteQueues.set(sessionId, settled);
+    void settled.finally(() => {
+      if (this.metaWriteQueues.get(sessionId) === settled) {
+        this.metaWriteQueues.delete(sessionId);
+      }
+    });
+    return next;
+  }
   async closeAll() {
     const sessions = [...this.sessions.values()];
     await Promise.allSettled(sessions.map((s) => s.close()));
@@ -5748,7 +6597,7 @@ var SessionManager = class {
 // src/core/extensions.ts
 init_paths();
 import { spawn as spawn2 } from "child_process";
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as fsp from "fs/promises";
 import * as path3 from "path";
 var RESTART_BASE_MS = 1e3;
@@ -6031,7 +6880,7 @@ var ExtensionManager = class {
     }
     const ext = entry.config;
     const command = ext.command.length > 0 ? ext.command : [ext.name];
-    const logStream = fs5.createWriteStream(paths.extensionLogFile(ext.name), {
+    const logStream = fs6.createWriteStream(paths.extensionLogFile(ext.name), {
       flags: "a"
     });
     logStream.write(
@@ -6081,7 +6930,7 @@ var ExtensionManager = class {
     }
     if (typeof child.pid === "number") {
       try {
-        fs5.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
+        fs6.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
 `, {
           encoding: "utf8",
           mode: 384
@@ -6106,7 +6955,7 @@ var ExtensionManager = class {
     });
     child.on("exit", (code, signal) => {
       try {
-        fs5.unlinkSync(paths.extensionPidFile(ext.name));
+        fs6.unlinkSync(paths.extensionPidFile(ext.name));
       } catch {
       }
       logStream.write(
@@ -6222,8 +7071,7 @@ init_config();
 function registerSessionRoutes(app, manager, defaults) {
   app.get("/v1/sessions", async (request) => {
     const query = request.query;
-    const all = query?.all === "true" || query?.all === "1";
-    const sessions = await manager.list({ cwd: query?.cwd, all });
+    const sessions = await manager.list({ cwd: query?.cwd });
     return { sessions };
   });
   app.post("/v1/sessions", async (request, reply) => {
@@ -6261,6 +7109,50 @@ function registerSessionRoutes(app, manager, defaults) {
     }
     reply.code(204).send();
   });
+  app.get("/v1/sessions/:id/history", async (request, reply) => {
+    const raw = request.params.id;
+    const query = request.query;
+    const follow = query?.follow === "1" || query?.follow === "true";
+    const id = await manager.resolveCanonicalId(raw) ?? raw;
+    const live = manager.get(id);
+    let snapshot;
+    let unsubscribe;
+    if (live) {
+      snapshot = live.getHistorySnapshot();
+      if (follow) {
+        unsubscribe = live.onBroadcast((entry) => {
+          if (reply.raw.writableEnded) {
+            return;
+          }
+          reply.raw.write(JSON.stringify(entry) + "\n");
+        });
+      }
+    } else {
+      const cold = await manager.getHistory(id);
+      if (cold === void 0) {
+        reply.code(404).send({ error: "session not found" });
+        return reply;
+      }
+      snapshot = cold;
+    }
+    reply.raw.setHeader("Content-Type", "application/x-ndjson");
+    reply.raw.setHeader("Cache-Control", "no-cache");
+    reply.raw.statusCode = 200;
+    for (const entry of snapshot ?? []) {
+      reply.raw.write(JSON.stringify(entry) + "\n");
+    }
+    if (!unsubscribe) {
+      reply.raw.end();
+      return reply;
+    }
+    request.raw.on("close", () => {
+      unsubscribe?.();
+      if (!reply.raw.writableEnded) {
+        reply.raw.end();
+      }
+    });
+    return reply;
+  });
 }
 
 // src/daemon/routes/agents.ts
@@ -6651,6 +7543,16 @@ function buildResponseMeta(session) {
   if (session.agentArgs && session.agentArgs.length > 0) {
     ours.agentArgs = session.agentArgs;
   }
+  if (session.currentModel !== void 0) {
+    ours.currentModel = session.currentModel;
+  }
+  if (session.currentMode !== void 0) {
+    ours.currentMode = session.currentMode;
+  }
+  const commands = session.mergedAvailableCommands();
+  if (commands.length > 0) {
+    ours.availableCommands = commands;
+  }
   return mergeMeta(session.agentMeta, ours);
 }
 function buildInitializeResult() {
@@ -6771,7 +7673,7 @@ async function startDaemon(config) {
     await manager.closeAll();
     await app.close();
     try {
-      fs6.unlinkSync(paths.pidFile());
+      fs7.unlinkSync(paths.pidFile());
     } catch {
     }
     try {
@@ -6810,7 +7712,7 @@ function ensureLoopbackOrTls(config) {
 init_daemon_bootstrap();
 
 // src/cli/commands/log-tail.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as fsp3 from "fs/promises";
 async function runLogTail(logPath, argv, notFoundMessage) {
   const opts = parseLogTailFlags(argv);
@@ -6834,7 +7736,7 @@ async function runLogTail(logPath, argv, notFoundMessage) {
   process.stdout.write(`-- following ${logPath} --
 `);
   let pending = false;
-  const watcher = fs7.watch(logPath, () => {
+  const watcher = fs8.watch(logPath, () => {
     if (pending) {
       return;
     }
@@ -7592,226 +8494,7 @@ function maxLen3(headerCell, values) {
 // src/shim/proxy.ts
 init_config();
 init_daemon_bootstrap();
-
-// src/shim/resilient-ws.ts
-init_ws_stream();
-init_types();
-import { setTimeout as sleep3 } from "timers/promises";
-import { WebSocket } from "ws";
-var BACKOFF_INITIAL_MS = 200;
-var BACKOFF_MAX_MS = 5e3;
-var BACKOFF_MULTIPLIER = 2;
-var MAX_RECONNECT_ATTEMPTS = 60;
-var ResilientWsStream = class {
-  constructor(opts) {
-    this.opts = opts;
-  }
-  opts;
-  current;
-  outboundQueue = [];
-  messageHandlers = [];
-  closeHandlers = [];
-  destroyed = false;
-  firstConnect = true;
-  reconnectInFlight;
-  connectGate;
-  releaseConnectGate;
-  pendingRequests = /* @__PURE__ */ new Map();
-  async start() {
-    await this.connectWithRetry();
-  }
-  onMessage(handler) {
-    this.messageHandlers.push(handler);
-  }
-  onClose(handler) {
-    this.closeHandlers.push(handler);
-  }
-  async send(message) {
-    if (this.destroyed) {
-      throw new Error("resilient ws stream is destroyed");
-    }
-    if (this.connectGate || !this.current) {
-      this.outboundQueue.push(message);
-      return;
-    }
-    try {
-      await this.current.send(message);
-    } catch (err) {
-      this.outboundQueue.push(message);
-      this.scheduleReconnect(err);
-    }
-  }
-  // Send a request directly and resolve when the matching response arrives
-  // on the same connection. Used by onConnect handlers to await replay-attach
-  // responses before letting the outbound queue drain. Bypasses the
-  // connectGate intentionally.
-  async request(message) {
-    if (this.destroyed) {
-      throw new Error("resilient ws stream is destroyed");
-    }
-    if (!this.current) {
-      throw new Error("resilient ws stream not connected");
-    }
-    const id = message.id;
-    const promise = new Promise((resolve2, reject) => {
-      this.pendingRequests.set(id, { resolve: resolve2, reject });
-    });
-    try {
-      await this.current.send(message);
-    } catch (err) {
-      this.pendingRequests.delete(id);
-      throw err;
-    }
-    return promise;
-  }
-  async close() {
-    this.destroyed = true;
-    if (this.current) {
-      await this.current.close().catch(() => void 0);
-    }
-    for (const handler of this.closeHandlers) {
-      handler();
-    }
-  }
-  async connectWithRetry() {
-    let attempt = 0;
-    let backoff = BACKOFF_INITIAL_MS;
-    while (!this.destroyed) {
-      try {
-        const stream = await openWs(this.opts.url, this.opts.subprotocols);
-        this.bindStream(stream);
-        const wasFirst = this.firstConnect;
-        this.firstConnect = false;
-        this.connectGate = new Promise((resolve2) => {
-          this.releaseConnectGate = resolve2;
-        });
-        try {
-          if (this.opts.onConnect) {
-            try {
-              await this.opts.onConnect(wasFirst);
-            } catch (err) {
-              this.log(
-                `hydra-acp: post-connect handler failed: ${err.message}`
-              );
-            }
-          }
-        } finally {
-          this.releaseConnectGate?.();
-          this.releaseConnectGate = void 0;
-          this.connectGate = void 0;
-        }
-        await this.flushQueue();
-        return;
-      } catch (err) {
-        attempt += 1;
-        if (this.opts.onConnectFailure) {
-          this.opts.onConnectFailure(err);
-        }
-        if (attempt >= MAX_RECONNECT_ATTEMPTS) {
-          throw new Error(
-            `hydra-acp: gave up reconnecting after ${attempt} attempts: ${err.message}`
-          );
-        }
-        this.log(
-          `hydra-acp: connect attempt ${attempt} failed (${err.message}); retrying in ${backoff}ms`
-        );
-        await sleep3(backoff);
-        backoff = Math.min(backoff * BACKOFF_MULTIPLIER, BACKOFF_MAX_MS);
-      }
-    }
-  }
-  bindStream(stream) {
-    this.current = stream;
-    stream.onMessage((msg) => {
-      if (isResponse(msg)) {
-        const pending = this.pendingRequests.get(msg.id);
-        if (pending) {
-          this.pendingRequests.delete(msg.id);
-          pending.resolve(msg);
-        }
-      }
-      for (const handler of this.messageHandlers) {
-        handler(msg);
-      }
-    });
-    stream.onClose((err) => {
-      if (this.destroyed) {
-        return;
-      }
-      this.current = void 0;
-      if (this.pendingRequests.size > 0) {
-        const reason = err ?? new Error("ws closed before response");
-        for (const { reject } of this.pendingRequests.values()) {
-          reject(reason);
-        }
-        this.pendingRequests.clear();
-      }
-      this.scheduleReconnect(err);
-    });
-  }
-  async flushQueue() {
-    if (!this.current) {
-      return;
-    }
-    const queue = this.outboundQueue;
-    this.outboundQueue = [];
-    for (const msg of queue) {
-      try {
-        await this.current.send(msg);
-      } catch (err) {
-        this.outboundQueue.unshift(msg);
-        this.scheduleReconnect(err);
-        return;
-      }
-    }
-  }
-  scheduleReconnect(err) {
-    if (this.destroyed || this.reconnectInFlight) {
-      return;
-    }
-    this.log(
-      `hydra-acp: connection lost (${err?.message ?? "no error"}); reconnecting...`
-    );
-    this.reconnectInFlight = (async () => {
-      try {
-        await this.connectWithRetry();
-      } catch (final) {
-        for (const handler of this.closeHandlers) {
-          handler(final);
-        }
-        this.destroyed = true;
-      } finally {
-        this.reconnectInFlight = void 0;
-      }
-    })();
-  }
-  log(line) {
-    if (this.opts.log) {
-      this.opts.log(line);
-      return;
-    }
-    process.stderr.write(`${line}
-`);
-  }
-};
-function isResponse(msg) {
-  return !("method" in msg) && "id" in msg && msg.id !== void 0;
-}
-async function openWs(url, subprotocols) {
-  return new Promise((resolve2, reject) => {
-    const ws = new WebSocket(url, subprotocols);
-    const onOpen = () => {
-      ws.off("error", onError);
-      resolve2(wsToMessageStream(ws));
-    };
-    const onError = (err) => {
-      ws.off("open", onOpen);
-      reject(err);
-    };
-    ws.once("open", onOpen);
-    ws.once("error", onError);
-  });
-}
+init_resilient_ws();
 
 // src/shim/session-tracker.ts
 init_types();