@hydra-acp/cli 0.1.1 → 0.1.2

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/daemon/server.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as fsp2 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
@@ -32,7 +32,12 @@ 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`),
@@ -410,6 +415,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) {
@@ -779,14 +810,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 +849,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 +870,19 @@ 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;
+    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 +911,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 +941,27 @@ var Session = class {
   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(
@@ -1082,6 +1167,91 @@ var Session = class {
     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
@@ -1392,9 +1562,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 +1689,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 +1781,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 +1793,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 +1812,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 +1852,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 +1874,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 +1891,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 +2035,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 +2057,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 +2134,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;
@@ -1821,6 +2193,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 +2204,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 +2230,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) {
@@ -1942,14 +2356,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
@@ -1957,17 +2373,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()));
@@ -1977,7 +2428,7 @@ var SessionManager = class {
 
 // src/core/extensions.ts
 import { spawn as spawn2 } from "child_process";
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 import * as fsp from "fs/promises";
 import * as path3 from "path";
 var RESTART_BASE_MS = 1e3;
@@ -2260,7 +2711,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 = fs5.createWriteStream(paths.extensionLogFile(ext.name), {
       flags: "a"
     });
     logStream.write(
@@ -2310,7 +2761,7 @@ var ExtensionManager = class {
     }
     if (typeof child.pid === "number") {
       try {
-        fs4.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
+        fs5.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
 `, {
           encoding: "utf8",
           mode: 384
@@ -2335,7 +2786,7 @@ var ExtensionManager = class {
     });
     child.on("exit", (code, signal) => {
       try {
-        fs4.unlinkSync(paths.extensionPidFile(ext.name));
+        fs5.unlinkSync(paths.extensionPidFile(ext.name));
       } catch {
       }
       logStream.write(
@@ -2447,8 +2898,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) => {
@@ -2486,6 +2936,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
@@ -2946,6 +3440,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() {
@@ -3066,7 +3570,7 @@ async function startDaemon(config) {
     await manager.closeAll();
     await app.close();
     try {
-      fs5.unlinkSync(paths.pidFile());
+      fs6.unlinkSync(paths.pidFile());
     } catch {
     }
     try {