@hydra-acp/cli 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/daemon/server.ts
-import * as fs5 from "fs";
+import * as fs7 from "fs";
 import * as fsp2 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
@@ -20,6 +20,11 @@ function hydraHome() {
   if (override && override.length > 0) {
     return path.resolve(override);
   }
+  if (process.env.VITEST) {
+    throw new Error(
+      "HYDRA_ACP_HOME is unset under VITEST; vitest.setup.ts must run first"
+    );
+  }
   return path.join(os.homedir(), ".hydra-acp");
 }
 var paths = {
@@ -32,11 +37,17 @@ var paths = {
   agentsDir: () => path.join(hydraHome(), "agents"),
   agentDir: (id) => path.join(hydraHome(), "agents", id),
   sessionsDir: () => path.join(hydraHome(), "sessions"),
-  sessionFile: (id) => path.join(hydraHome(), "sessions", `${id}.json`),
+  // One directory per session id under sessions/. Co-locates the
+  // session record, its transcript, and any future per-session state
+  // (uploads, scratch, etc.) so the lifecycle is just "rm -rf the dir".
+  sessionDir: (id) => path.join(hydraHome(), "sessions", id),
+  sessionFile: (id) => path.join(hydraHome(), "sessions", id, "meta.json"),
+  historyFile: (id) => path.join(hydraHome(), "sessions", id, "history.jsonl"),
   extensionsDir: () => path.join(hydraHome(), "extensions"),
   extensionLogFile: (name) => path.join(hydraHome(), "extensions", `${name}.log`),
   extensionPidFile: (name) => path.join(hydraHome(), "extensions", `${name}.pid`),
-  tuiHistoryFile: () => path.join(hydraHome(), "tui-history")
+  tuiHistoryFile: (id) => path.join(hydraHome(), "sessions", id, "prompt-history"),
+  tuiLogFile: () => path.join(hydraHome(), "tui.log")
 };
 
 // src/core/config.ts
@@ -64,7 +75,11 @@ var TuiConfig = z.object({
   // /clear, ^L, resize — bypass this throttle. Default 1000 (1 Hz) keeps
   // CPU low during heavy streaming; bump to 250 for 4 Hz, 100 for ~10 Hz,
   // or 0 to disable throttling entirely.
-  repaintThrottleMs: z.number().int().nonnegative().default(1e3)
+  repaintThrottleMs: z.number().int().nonnegative().default(1e3),
+  // Cap on logical lines retained in the in-memory scrollback render
+  // buffer. Oldest lines are dropped on overflow. The on-disk session
+  // history is unaffected; this only bounds the TUI's local view buffer.
+  maxScrollbackLines: z.number().int().positive().default(1e4)
 });
 var ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
 var ExtensionBody = z.object({
@@ -89,7 +104,7 @@ var HydraConfig = z.object({
   // recency and truncated to this count. `--all` overrides in the CLI.
   sessionListColdLimit: z.number().int().nonnegative().default(20),
   extensions: z.record(ExtensionName, ExtensionBody).default({}),
-  tui: TuiConfig.default({ repaintThrottleMs: 1e3 })
+  tui: TuiConfig.default({ repaintThrottleMs: 1e3, maxScrollbackLines: 1e4 })
 });
 function extensionList(config) {
   return Object.entries(config.extensions).map(([name, body]) => ({
@@ -332,6 +347,9 @@ function planSpawn(agent, extraArgs = []) {
   throw new Error(`Agent ${agent.id} has no usable distribution method.`);
 }
 
+// src/core/session-manager.ts
+import * as fs5 from "fs/promises";
+
 // src/core/agent-instance.ts
 import { spawn } from "child_process";
 
@@ -410,6 +428,35 @@ function extractHydraMeta(meta) {
       out.resume = parsed.data;
     }
   }
+  if (typeof obj.currentModel === "string") {
+    out.currentModel = obj.currentModel;
+  }
+  if (typeof obj.currentMode === "string") {
+    out.currentMode = obj.currentMode;
+  }
+  if (typeof obj.turnStartedAt === "number" && obj.turnStartedAt > 0) {
+    out.turnStartedAt = obj.turnStartedAt;
+  }
+  if (Array.isArray(obj.availableCommands)) {
+    const cmds = [];
+    for (const raw of obj.availableCommands) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        continue;
+      }
+      const c = raw;
+      if (typeof c.name !== "string") {
+        continue;
+      }
+      const cmd = { name: c.name };
+      if (typeof c.description === "string") {
+        cmd.description = c.description;
+      }
+      cmds.push(cmd);
+    }
+    if (cmds.length > 0) {
+      out.availableCommands = cmds;
+    }
+  }
   return out;
 }
 function mergeMeta(passthrough, ours) {
@@ -779,14 +826,26 @@ var Session = class {
   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;
@@ -806,12 +865,18 @@ var Session = class {
   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;
@@ -821,11 +886,22 @@ var Session = class {
     this.agentMeta = init.agentMeta;
     this.agentArgs = init.agentArgs;
     this.title = init.title;
+    this.currentModel = init.currentModel;
+    this.currentMode = init.currentMode;
+    if (init.agentCommands && init.agentCommands.length > 0) {
+      this.agentAdvertisedCommands = [...init.agentCommands];
+    }
     this.idleTimeoutMs = init.idleTimeoutMs ?? 0;
     this.spawnReplacementAgent = init.spawnReplacementAgent;
+    if (init.firstPromptSeeded) {
+      this.firstPromptSeeded = true;
+    }
+    this.historyStore = init.historyStore;
+    if (init.seedHistory && init.seedHistory.length > 0) {
+      this.history = [...init.seedHistory];
+    }
     this.updatedAt = Date.now();
     this.wireAgent(this.agent);
-    this.broadcastMergedCommands();
   }
   broadcastMergedCommands() {
     const merged = [
@@ -854,8 +930,15 @@ var Session = class {
       }
       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);
@@ -877,6 +960,50 @@ var Session = class {
   get attachedCount() {
     return this.clients.size;
   }
+  // Wall-clock when the in-flight agent turn began, or undefined when
+  // idle. Derived from history: the most recent prompt_received without
+  // a later turn_complete is the outstanding turn, and its recordedAt
+  // is when the prompt was first broadcast. Used by buildResponseMeta
+  // so a fresh client reattaching mid-turn boots up with the busy
+  // banner showing real elapsed time.
+  get turnStartedAt() {
+    for (let i = this.history.length - 1; i >= 0; i--) {
+      const entry = this.history[i];
+      if (!entry) {
+        continue;
+      }
+      const params = entry.params;
+      const kind = params?.update?.sessionUpdate;
+      if (kind === "turn_complete") {
+        return void 0;
+      }
+      if (kind === "prompt_received") {
+        return entry.recordedAt;
+      }
+    }
+    return void 0;
+  }
+  // Snapshot of the current in-memory replay history. Used by the
+  // HTTP history endpoint to deliver the "what's accumulated so far"
+  // prefix before optionally tailing with onBroadcast. Returns a copy
+  // so callers can't mutate our cache.
+  getHistorySnapshot() {
+    return [...this.history];
+  }
+  // Subscribe to recordable broadcast entries — fires once per entry
+  // that lands in history (so snapshot-shaped session_info/model/mode/
+  // available_commands updates do NOT trigger this; they're broadcast
+  // live but not recorded). Returns an unsubscribe function the caller
+  // must invoke when done.
+  onBroadcast(handler) {
+    this.broadcastHandlers.push(handler);
+    return () => {
+      const i = this.broadcastHandlers.indexOf(handler);
+      if (i >= 0) {
+        this.broadcastHandlers.splice(i, 1);
+      }
+    };
+  }
   attach(client, historyPolicy) {
     if (this.closed) {
       throw withCode(
@@ -933,13 +1060,19 @@ var Session = class {
     this.broadcastPromptReceived(client, params);
     this.maybeSeedTitleFromPrompt(params);
     return this.enqueuePrompt(async () => {
-      const response = await this.agent.connection.request(
-        "session/prompt",
-        {
-          ...params,
-          sessionId: this.upstreamSessionId
-        }
-      );
+      let response;
+      try {
+        response = await this.agent.connection.request(
+          "session/prompt",
+          {
+            ...params,
+            sessionId: this.upstreamSessionId
+          }
+        );
+      } catch (err) {
+        this.broadcastTurnComplete(client.clientId, { stopReason: "error" });
+        throw err;
+      }
       this.broadcastTurnComplete(client.clientId, response);
       return response;
     });
@@ -1027,6 +1160,13 @@ var Session = class {
       return;
     }
     this.cancelIdleTimer();
+    if (opts.regenTitle && this.firstPromptSeeded) {
+      const timeoutMs = opts.regenTitleTimeoutMs ?? 5e3;
+      await Promise.race([
+        this.runTitleRegen().catch(() => void 0),
+        new Promise((r) => setTimeout(r, timeoutMs).unref?.())
+      ]);
+    }
     await this.agent.kill().catch(() => void 0);
     this.markClosed({ deleteRecord: opts.deleteRecord ?? false });
   }
@@ -1075,13 +1215,98 @@ var Session = class {
     }
     const promptParams = params ?? {};
     const text = extractPromptText(promptParams.prompt);
-    const seed = firstLine(text, 80);
+    const seed = firstLine(text, 200);
     if (!seed) {
       return;
     }
     this.firstPromptSeeded = true;
     this.setTitle(seed);
   }
+  // Apply an agent-emitted current_model_update. Returns true if the
+  // notification was a model update (caller still needs to broadcast
+  // it). Returns false otherwise so the caller can try the next kind.
+  maybeApplyAgentModel(params) {
+    const obj = params ?? {};
+    const update = obj.update ?? {};
+    if (update.sessionUpdate !== "current_model_update") {
+      return false;
+    }
+    const raw = typeof update.currentModel === "string" ? update.currentModel : typeof update.model === "string" ? update.model : void 0;
+    if (raw === void 0) {
+      return true;
+    }
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed === this.currentModel) {
+      return true;
+    }
+    this.currentModel = trimmed;
+    for (const handler of this.modelHandlers) {
+      try {
+        handler(trimmed);
+      } catch {
+      }
+    }
+    return true;
+  }
+  maybeApplyAgentMode(params) {
+    const obj = params ?? {};
+    const update = obj.update ?? {};
+    if (update.sessionUpdate !== "current_mode_update") {
+      return false;
+    }
+    const raw = typeof update.currentMode === "string" ? update.currentMode : typeof update.mode === "string" ? update.mode : void 0;
+    if (raw === void 0) {
+      return true;
+    }
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed === this.currentMode) {
+      return true;
+    }
+    this.currentMode = trimmed;
+    for (const handler of this.modeHandlers) {
+      try {
+        handler(trimmed);
+      } catch {
+      }
+    }
+    return true;
+  }
+  // Update the cached agent command list, fire persist handlers, and
+  // broadcast the merged list to attached clients. Idempotent on a
+  // structurally identical list so we don't churn meta.json on noisy
+  // re-emissions.
+  setAgentAdvertisedCommands(commands) {
+    if (sameAdvertisedCommands(this.agentAdvertisedCommands, commands)) {
+      this.broadcastMergedCommands();
+      return;
+    }
+    this.agentAdvertisedCommands = commands;
+    for (const handler of this.agentCommandsHandlers) {
+      try {
+        handler(commands);
+      } catch {
+      }
+    }
+    this.broadcastMergedCommands();
+  }
+  // Subscribe to snapshot-state updates. SessionManager wires these to
+  // persist the new value into meta.json so cold resurrect can restore
+  // them via the attach response _meta.
+  onAgentCommandsChange(handler) {
+    this.agentCommandsHandlers.push(handler);
+  }
+  onModelChange(handler) {
+    this.modelHandlers.push(handler);
+  }
+  onModeChange(handler) {
+    this.modeHandlers.push(handler);
+  }
+  // Returns a freshly merged command list (hydra ∪ agent) for callers
+  // that need a snapshot — notably acp-ws.ts's buildResponseMeta when
+  // assembling the attach response.
+  mergedAvailableCommands() {
+    return [...hydraCommandsAsAdvertised(), ...this.agentAdvertisedCommands];
+  }
   // Pick up an agent-emitted session_info_update and store its title
   // as our canonical record. The notification is also forwarded to
   // clients via the surrounding recordAndBroadcast call. Authoritative
@@ -1369,7 +1594,8 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
     }
     this.idleTimer = setTimeout(() => {
       this.idleTimer = void 0;
-      void this.close({ deleteRecord: false }).catch(() => void 0);
+      const opts = this.firstPromptSeeded ? { deleteRecord: false, regenTitle: true } : { deleteRecord: true };
+      void this.close(opts).catch(() => void 0);
     }, this.idleTimeoutMs);
     if (typeof this.idleTimer.unref === "function") {
       this.idleTimer.unref();
@@ -1392,9 +1618,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()) {
@@ -1494,6 +1745,31 @@ function withCode(err, code) {
   err.code = code;
   return err;
 }
+var STATE_UPDATE_KINDS = /* @__PURE__ */ new Set([
+  "session_info_update",
+  "current_model_update",
+  "current_mode_update",
+  "available_commands_update"
+]);
+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 ?? {};
@@ -1561,6 +1837,10 @@ function firstLine(text, max) {
 import * as fs3 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(),
@@ -1569,6 +1849,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()
 });
@@ -1581,7 +1868,7 @@ function assertSafeId(id) {
 var SessionStore = class {
   async write(record) {
     assertSafeId(record.sessionId);
-    await fs3.mkdir(paths.sessionsDir(), { recursive: true });
+    await fs3.mkdir(paths.sessionDir(record.sessionId), { recursive: true });
     const full = { version: 1, ...record };
     await fs3.writeFile(
       paths.sessionFile(record.sessionId),
@@ -1621,6 +1908,14 @@ var SessionStore = class {
         throw err;
       }
     }
+    try {
+      await fs3.rmdir(paths.sessionDir(sessionId));
+    } catch (err) {
+      const e = err;
+      if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
+        throw err;
+      }
+    }
   }
   async list() {
     let entries;
@@ -1635,11 +1930,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);
       }
@@ -1656,17 +1947,143 @@ 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
+import * as fs4 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 fs4.mkdir(paths.sessionDir(sessionId), { recursive: true });
+      const line = JSON.stringify(entry) + "\n";
+      await fs4.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 fs4.mkdir(paths.sessionDir(sessionId), { recursive: true });
+      const body = entries.length === 0 ? "" : entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+      await fs4.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 fs4.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 fs4.unlink(paths.historyFile(sessionId));
+      } catch (err) {
+        const e = err;
+        if (e.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      try {
+        await fs4.rmdir(paths.sessionDir(sessionId));
+      } catch (err) {
+        const e = err;
+        if (e.code !== "ENOENT" && 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
 var SessionManager = class {
   constructor(registry, spawner, store, options = {}) {
     this.registry = registry;
     this.spawner = spawner ?? ((opts) => AgentInstance.spawn(opts));
     this.store = store ?? new SessionStore();
+    this.histories = new HistoryStore();
     this.idleTimeoutMs = options.idleTimeoutMs ?? 0;
   }
   registry;
@@ -1674,7 +2091,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,
@@ -1691,7 +2113,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;
@@ -1767,7 +2190,13 @@ var SessionManager = class {
       title: params.title,
       agentArgs: params.agentArgs,
       idleTimeoutMs: this.idleTimeoutMs,
-      spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] })
+      spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
+      historyStore: this.histories,
+      seedHistory: params.seedHistory,
+      currentModel: params.currentModel,
+      currentMode: params.currentMode,
+      agentCommands: params.agentCommands,
+      firstPromptSeeded: true
     });
     await this.attachManagerHooks(session);
     return session;
@@ -1821,6 +2250,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) => {
@@ -1831,6 +2261,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({
@@ -1839,22 +2287,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) {
@@ -1896,13 +2367,14 @@ var SessionManager = class {
         continue;
       }
       liveIds.add(session.sessionId);
+      const used = await historyMtimeIso(session.sessionId) ?? new Date(session.updatedAt).toISOString();
       entries.push({
         sessionId: session.sessionId,
         upstreamSessionId: session.upstreamSessionId,
         cwd: session.cwd,
         title: session.title,
         agentId: session.agentId,
-        updatedAt: new Date(session.updatedAt).toISOString(),
+        updatedAt: used,
         attachedClients: session.attachedCount,
         status: "live"
       });
@@ -1915,13 +2387,14 @@ var SessionManager = class {
       if (filter.cwd && r.cwd !== filter.cwd) {
         continue;
       }
+      const used = await historyMtimeIso(r.sessionId) ?? r.updatedAt;
       entries.push({
         sessionId: r.sessionId,
         upstreamSessionId: r.upstreamSessionId,
         cwd: r.cwd,
         title: r.title,
         agentId: r.agentId,
-        updatedAt: r.updatedAt,
+        updatedAt: used,
         attachedClients: 0,
         status: "cold"
       });
@@ -1937,19 +2410,25 @@ var SessionManager = class {
     await this.store.delete(sessionId).catch(() => void 0);
     return true;
   }
+  async hasRecord(sessionId) {
+    const record = await this.store.read(sessionId).catch(() => void 0);
+    return record !== void 0;
+  }
   // Persist a title update from Session.setTitle. The on-disk record
   // was written at create time; updating it here keeps the session
   // record's title in sync with what was broadcast to clients so a
   // daemon restart (and later resurrect) restores the same title.
   async persistTitle(sessionId, title) {
-    const record = await this.store.read(sessionId);
-    if (!record) {
-      return;
-    }
-    await this.store.write({
-      ...record,
-      title,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    await this.enqueueMetaWrite(sessionId, async () => {
+      const record = await this.store.read(sessionId);
+      if (!record) {
+        return;
+      }
+      await this.store.write({
+        ...record,
+        title,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
     });
   }
   // Persist an agent swap from /hydra switch. The on-disk record's
@@ -1957,16 +2436,51 @@ 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()];
@@ -1974,10 +2488,18 @@ var SessionManager = class {
     this.sessions.clear();
   }
 };
+async function historyMtimeIso(sessionId) {
+  try {
+    const st = await fs5.stat(paths.historyFile(sessionId));
+    return new Date(st.mtimeMs).toISOString();
+  } catch {
+    return void 0;
+  }
+}
 
 // src/core/extensions.ts
 import { spawn as spawn2 } from "child_process";
-import * as fs4 from "fs";
+import * as fs6 from "fs";
 import * as fsp from "fs/promises";
 import * as path3 from "path";
 var RESTART_BASE_MS = 1e3;
@@ -2260,7 +2782,7 @@ var ExtensionManager = class {
     }
     const ext = entry.config;
     const command = ext.command.length > 0 ? ext.command : [ext.name];
-    const logStream = fs4.createWriteStream(paths.extensionLogFile(ext.name), {
+    const logStream = fs6.createWriteStream(paths.extensionLogFile(ext.name), {
       flags: "a"
     });
     logStream.write(
@@ -2310,7 +2832,7 @@ var ExtensionManager = class {
     }
     if (typeof child.pid === "number") {
       try {
-        fs4.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
+        fs6.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
 `, {
           encoding: "utf8",
           mode: 384
@@ -2335,7 +2857,7 @@ var ExtensionManager = class {
     });
     child.on("exit", (code, signal) => {
       try {
-        fs4.unlinkSync(paths.extensionPidFile(ext.name));
+        fs6.unlinkSync(paths.extensionPidFile(ext.name));
       } catch {
       }
       logStream.write(
@@ -2447,8 +2969,7 @@ function constantTimeEqual(a, b) {
 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) => {
@@ -2470,6 +2991,22 @@ function registerSessionRoutes(app, manager, defaults) {
       reply.code(500).send({ error: err.message });
     }
   });
+  app.post("/v1/sessions/:id/kill", async (request, reply) => {
+    const raw = request.params.id;
+    const id = await manager.resolveCanonicalId(raw) ?? raw;
+    const session = manager.get(id);
+    if (session) {
+      await session.close({ deleteRecord: false });
+      reply.code(204).send();
+      return;
+    }
+    const exists = await manager.hasRecord(id);
+    if (!exists) {
+      reply.code(404).send({ error: "session not found" });
+      return;
+    }
+    reply.code(204).send();
+  });
   app.delete("/v1/sessions/:id", async (request, reply) => {
     const raw = request.params.id;
     const id = await manager.resolveCanonicalId(raw) ?? raw;
@@ -2486,6 +3023,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
@@ -2633,6 +3214,16 @@ function parseRegisterBody(body) {
   };
 }
 
+// src/daemon/routes/config.ts
+function registerConfigRoutes(app, defaults) {
+  app.get("/v1/config", async () => {
+    return {
+      defaultAgent: defaults.defaultAgent,
+      defaultCwd: defaults.defaultCwd
+    };
+  });
+}
+
 // src/daemon/acp-ws.ts
 import { nanoid as nanoid2 } from "nanoid";
 
@@ -2946,6 +3537,19 @@ function buildResponseMeta(session) {
   if (session.agentArgs && session.agentArgs.length > 0) {
     ours.agentArgs = session.agentArgs;
   }
+  if (session.currentModel !== void 0) {
+    ours.currentModel = session.currentModel;
+  }
+  if (session.currentMode !== void 0) {
+    ours.currentMode = session.currentMode;
+  }
+  const commands = session.mergedAvailableCommands();
+  if (commands.length > 0) {
+    ours.availableCommands = commands;
+  }
+  if (session.turnStartedAt !== void 0) {
+    ours.turnStartedAt = session.turnStartedAt;
+  }
   return mergeMeta(session.agentMeta, ours);
 }
 function buildInitializeResult() {
@@ -3031,6 +3635,10 @@ async function startDaemon(config) {
   });
   registerAgentRoutes(app, registry);
   registerExtensionRoutes(app, extensions);
+  registerConfigRoutes(app, {
+    defaultAgent: config.defaultAgent,
+    defaultCwd: config.defaultCwd
+  });
   registerAcpWsEndpoint(app, {
     config,
     manager,
@@ -3066,7 +3674,7 @@ async function startDaemon(config) {
     await manager.closeAll();
     await app.close();
     try {
-      fs5.unlinkSync(paths.pidFile());
+      fs7.unlinkSync(paths.pidFile());
     } catch {
     }
     try {