@hydra-acp/cli 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/daemon/server.ts
-import * as fs6 from "fs";
+import * as fs8 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 = {
@@ -41,7 +46,8 @@ var paths = {
   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
@@ -56,7 +62,7 @@ var DaemonConfig = z.object({
   authToken: z.string().min(16),
   logLevel: z.enum(["debug", "info", "warn", "error"]).default("info"),
   tls: TlsConfig.optional(),
-  sessionIdleTimeoutSeconds: z.number().int().nonnegative().default(30)
+  sessionIdleTimeoutSeconds: z.number().int().nonnegative().default(3600)
 });
 var RegistryConfig = z.object({
   url: z.string().url().default(REGISTRY_URL_DEFAULT),
@@ -69,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({
@@ -94,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]) => ({
@@ -127,8 +137,7 @@ async function ensureConfig() {
     if (e.code !== "ENOENT") {
       throw err;
     }
-    const config = defaultConfig();
-    await writeConfig(config);
+    const config = await writeMinimalInitConfig();
     process.stderr.write(
       `hydra-acp: initialized ${paths.config()} with a fresh auth token.
 `
@@ -144,6 +153,16 @@ async function writeConfig(config) {
     mode: 384
   });
 }
+async function writeMinimalInitConfig(authToken) {
+  const token = authToken ?? generateAuthToken();
+  const minimal = { daemon: { authToken: token } };
+  await fs.mkdir(paths.home(), { recursive: true });
+  await fs.writeFile(paths.config(), JSON.stringify(minimal, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+  return HydraConfig.parse(minimal);
+}
 function generateAuthToken() {
   const bytes = new Uint8Array(32);
   crypto.getRandomValues(bytes);
@@ -337,6 +356,10 @@ function planSpawn(agent, extraArgs = []) {
   throw new Error(`Agent ${agent.id} has no usable distribution method.`);
 }
 
+// src/core/session-manager.ts
+import * as fs6 from "fs/promises";
+import { customAlphabet as customAlphabet3 } from "nanoid";
+
 // src/core/agent-instance.ts
 import { spawn } from "child_process";
 
@@ -351,7 +374,8 @@ var JsonRpcErrorCodes = {
   SessionNotFound: -32001,
   PermissionDenied: -32002,
   AlreadyAttached: -32003,
-  AgentNotInstalled: -32005
+  AgentNotInstalled: -32005,
+  BundleAlreadyImported: -32010
 };
 var InitializeParams = z3.object({
   protocolVersion: z3.number().optional(),
@@ -421,6 +445,9 @@ function extractHydraMeta(meta) {
   if (typeof obj.currentMode === "string") {
     out.currentMode = obj.currentMode;
   }
+  if (typeof obj.turnStartedAt === "number" && obj.turnStartedAt > 0) {
+    out.turnStartedAt = obj.turnStartedAt;
+  }
   if (Array.isArray(obj.availableCommands)) {
     const cmds = [];
     for (const raw of obj.availableCommands) {
@@ -797,6 +824,8 @@ function hydraCommandsAsAdvertised() {
 var HYDRA_ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 var generateHydraId = customAlphabet(HYDRA_ID_ALPHABET, 16);
 var HYDRA_SESSION_PREFIX = "hydra_session_";
+var MAX_HISTORY_ENTRIES = 1e3;
+var COMPACT_EVERY = 200;
 var Session = class {
   sessionId;
   cwd;
@@ -816,8 +845,8 @@ var Session = class {
   currentModel;
   currentMode;
   updatedAt;
+  createdAt;
   clients = /* @__PURE__ */ new Map();
-  history = [];
   historyStore;
   promptQueue = [];
   promptInFlight = false;
@@ -833,6 +862,15 @@ var Session = class {
   // True once we've observed our first session/prompt; gates the
   // first-prompt-seeded title so subsequent prompts don't churn it.
   firstPromptSeeded = false;
+  // Wall-clock when the active prompt started, undefined when idle.
+  // Bumped by broadcastPromptReceived, cleared by broadcastTurnComplete.
+  // Drives the mid-turn elapsed counter delivered to fresh attachers.
+  promptStartedAt;
+  // Counts appends since the last compaction. When it hits COMPACT_EVERY
+  // we ask the history store to trim the file to the most recent
+  // MAX_HISTORY_ENTRIES. Keeps file growth bounded without per-append
+  // file-size checks.
+  appendCount = 0;
   // Permission requests that have been broadcast to one or more
   // clients but have not yet resolved. Replayed to clients that
   // attach mid-flight so a late joiner sees the prompt instead of an
@@ -847,6 +885,12 @@ var Session = class {
   internalPromptCapture;
   idleTimeoutMs;
   idleTimer;
+  // Time of the last recordable broadcast (or session creation, if
+  // none yet). Drives the inactivity-based idle close; deliberately
+  // does NOT include snapshot state pings (model/mode/title/commands)
+  // or attach/detach, which would otherwise let passive observers
+  // and noisy state churn keep a quiet session alive forever.
+  lastRecordedAt;
   spawnReplacementAgent;
   agentChangeHandlers = [];
   // Last available_commands_update we observed from the agent. Stored
@@ -877,12 +921,15 @@ var Session = class {
     }
     this.idleTimeoutMs = init.idleTimeoutMs ?? 0;
     this.spawnReplacementAgent = init.spawnReplacementAgent;
-    this.historyStore = init.historyStore;
-    if (init.seedHistory && init.seedHistory.length > 0) {
-      this.history = [...init.seedHistory];
+    if (init.firstPromptSeeded) {
+      this.firstPromptSeeded = true;
     }
+    this.historyStore = init.historyStore;
     this.updatedAt = Date.now();
+    this.createdAt = init.createdAt ?? this.updatedAt;
+    this.lastRecordedAt = this.updatedAt;
     this.wireAgent(this.agent);
+    this.scheduleIdleCheck();
   }
   broadcastMergedCommands() {
     const merged = [
@@ -941,12 +988,21 @@ 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];
+  // Wall-clock when the in-flight agent turn began, or undefined when
+  // idle. Tracked in-memory by broadcastPromptReceived/broadcastTurnComplete
+  // so the daemon can hand a fresh attacher mid-turn the right elapsed
+  // time without scanning history.
+  get turnStartedAt() {
+    return this.promptStartedAt;
+  }
+  // Read the persisted history from disk. Returns [] if no history
+  // file exists (fresh session, never prompted). Used by attach() and
+  // the HTTP /history endpoint.
+  async getHistorySnapshot() {
+    if (!this.historyStore) {
+      return [];
+    }
+    return this.historyStore.load(this.sessionId).catch(() => []);
   }
   // Subscribe to recordable broadcast entries — fires once per entry
   // that lands in history (so snapshot-shaped session_info/model/mode/
@@ -962,6 +1018,10 @@ var Session = class {
       }
     };
   }
+  // Register a client and (asynchronously) load the replay slice it
+  // should receive. Validation errors throw synchronously so callers
+  // can rely on either the registration being in effect or having
+  // thrown; the disk-load is the only async work.
   attach(client, historyPolicy) {
     if (this.closed) {
       throw withCode(
@@ -977,14 +1037,10 @@ var Session = class {
     }
     this.clients.set(client.clientId, client);
     this.updatedAt = Date.now();
-    this.cancelIdleTimer();
-    if (historyPolicy === "none") {
-      return [];
-    }
-    if (historyPolicy === "pending_only") {
-      return [];
+    if (historyPolicy === "none" || historyPolicy === "pending_only") {
+      return Promise.resolve([]);
     }
-    return [...this.history];
+    return this.getHistorySnapshot();
   }
   // Dispatch in-flight permission requests to a freshly-attached
   // client. Called by the daemon's WS handler *after* it finishes
@@ -998,7 +1054,6 @@ var Session = class {
   detach(clientId) {
     if (this.clients.delete(clientId)) {
       this.updatedAt = Date.now();
-      this.maybeStartIdleTimer();
     }
   }
   async prompt(clientId, params) {
@@ -1018,13 +1073,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;
     });
@@ -1038,6 +1099,7 @@ var Session = class {
     if (client.clientInfo?.version) {
       sentBy.version = client.clientInfo.version;
     }
+    this.promptStartedAt = Date.now();
     this.recordAndBroadcast(
       "session/update",
       {
@@ -1074,6 +1136,7 @@ var Session = class {
     if (stopReason !== void 0) {
       update.stopReason = stopReason;
     }
+    this.promptStartedAt = void 0;
     this.recordAndBroadcast(
       "session/update",
       {
@@ -1112,6 +1175,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 });
   }
@@ -1160,7 +1230,7 @@ var Session = class {
     }
     const promptParams = params ?? {};
     const text = extractPromptText(promptParams.prompt);
-    const seed = firstLine(text, 80);
+    const seed = firstLine(text, 200);
     if (!seed) {
       return;
     }
@@ -1252,6 +1322,12 @@ var Session = class {
   mergedAvailableCommands() {
     return [...hydraCommandsAsAdvertised(), ...this.agentAdvertisedCommands];
   }
+  // The agent's own advertised commands (not merged with hydra verbs).
+  // Used by SessionManager to persist into meta.json so cold resurrect
+  // can re-deliver via the attach response _meta.
+  agentOnlyAdvertisedCommands() {
+    return [...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
@@ -1383,7 +1459,7 @@ var Session = class {
     const spawnAgent = this.spawnReplacementAgent;
     return this.enqueuePrompt(async () => {
       const oldAgentId = this.agentId;
-      const transcript = this.buildSwitchTranscript(oldAgentId);
+      const transcript = await this.buildSwitchTranscript(oldAgentId);
       const fresh = await spawnAgent({
         agentId: newAgentId,
         cwd: this.cwd,
@@ -1415,15 +1491,20 @@ var Session = class {
       return { stopReason: "end_turn" };
     });
   }
-  // Walk this.history (rewritten-for-clients notification cache) and
-  // produce a labeled transcript suitable for handing to a fresh agent.
-  // Includes user prompts, agent replies, and tool-call outcomes; skips
-  // hydra-synthesized markers (so multi-hop switches don't accumulate
-  // banners) and other update kinds we don't think the next agent
-  // benefits from re-seeing (plans, thoughts, mode/model/usage).
-  buildSwitchTranscript(prevAgentId) {
+  // Walk the persisted history and produce a labeled transcript suitable
+  // for handing to a fresh agent. Includes user prompts, agent replies,
+  // and tool-call outcomes; skips hydra-synthesized markers (so multi-hop
+  // switches don't accumulate banners) and other update kinds we don't
+  // think the next agent benefits from re-seeing (plans, thoughts,
+  // mode/model/usage).
+  //
+  // The header text defaults to the agent-swap framing; callers like
+  // seedFromImport pass a custom header when the new agent is taking
+  // over an imported session rather than swapping mid-conversation.
+  async buildSwitchTranscript(prevAgentId, headerOverride) {
     const lines = [];
-    for (const note of this.history) {
+    const history = await this.getHistorySnapshot();
+    for (const note of history) {
       if (note.method !== "session/update") {
         continue;
       }
@@ -1477,29 +1558,53 @@ var Session = class {
     if (current) {
       coalesced.push(`<${current.speaker}>: ${current.text.trim()}`);
     }
+    const intro = headerOverride?.intro ?? `You are taking over this conversation from ${prevAgentId}. Below is the transcript so far.`;
+    const followup = headerOverride?.followup ?? `Each line is prefixed with its speaker. Continue from where ${prevAgentId} left off, responding to the user's most recent message.`;
     return [
-      `You are taking over this conversation from ${prevAgentId}. Below is the transcript so far.`,
-      `Each line is prefixed with its speaker. Continue from where ${prevAgentId} left off, responding to the user's most recent message.`,
+      intro,
+      followup,
       "",
       "--- begin transcript ---",
       ...coalesced,
       "--- end transcript ---"
     ].join("\n");
   }
+  // Replay the persisted history into a freshly-spawned agent so an
+  // imported session has context. Called by SessionManager.doResurrect
+  // on the first wake-up of a session whose meta.json has an empty
+  // upstreamSessionId (the import marker). Wrapped in enqueuePrompt so
+  // any user prompts arriving mid-seed queue behind it (mirrors the
+  // /hydra switch path so the agent isn't asked to respond to a user
+  // turn before it has absorbed the imported transcript). Best-effort:
+  // if the agent fails to absorb the transcript we still leave the
+  // session usable — the user just continues without context.
+  async seedFromImport() {
+    await this.enqueuePrompt(async () => {
+      const transcript = await this.buildSwitchTranscript(this.agentId, {
+        intro: "You are continuing a conversation that was imported from another hydra. Below is the transcript so far.",
+        followup: "Each line is prefixed with its speaker. Treat this as context for the next user message; do not re-respond to earlier turns."
+      });
+      if (!transcript) {
+        return void 0;
+      }
+      await this.runInternalPrompt(transcript).catch(() => void 0);
+      return void 0;
+    });
+  }
   // Tell every attached client (a) the agent identity has changed
-  // (session_info_update with an agentId field — clients that already
-  // listen for title updates pick this up; older clients ignore unknown
-  // fields harmlessly) and (b) drop a visible banner into the transcript
-  // so users see the switch rather than just suddenly getting answers
-  // from a different agent. Both updates carry _meta["hydra-acp"].synthetic
+  // (session_info_update carrying agentId inside _meta["hydra-acp"] —
+  // the ACP schema for session_info_update is just title/updatedAt/_meta,
+  // so non-hydra clients harmlessly ignore the extension; hydra-aware
+  // ones read it and relabel) and (b) drop a visible banner into the
+  // transcript so users see the switch rather than just suddenly getting
+  // answers from a different agent. Both updates carry synthetic=true
   // so a future /hydra switch's transcript builder filters them out.
   broadcastAgentSwitch(oldAgentId, newAgentId) {
     this.recordAndBroadcast("session/update", {
       sessionId: this.sessionId,
       update: {
         sessionUpdate: "session_info_update",
-        agentId: newAgentId,
-        _meta: { "hydra-acp": { synthetic: true } }
+        _meta: { "hydra-acp": { synthetic: true, agentId: newAgentId } }
       }
     });
     this.recordAndBroadcast("session/update", {
@@ -1530,21 +1635,55 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       handler(opts);
     }
   }
-  maybeStartIdleTimer() {
-    if (this.closed || this.clients.size > 0 || this.idleTimeoutMs <= 0) {
+  // Last meaningful activity timestamp. Bumped only by recordable
+  // broadcasts in recordAndBroadcast — the same signal historyMtimeIso
+  // uses for the picker. Initialized at construction (and seeded from
+  // the newest entry on resurrect) so the inactivity window starts
+  // ticking from a sensible floor when there's no history yet.
+  get lastActivityAt() {
+    return this.lastRecordedAt;
+  }
+  // (Re-)arm the idle timer to fire when the inactivity window
+  // elapses past lastActivityAt. Called once at construction and after
+  // every recorded broadcast. The previous design gated on
+  // clients.size === 0; we drop that gate because extensions
+  // (slack/notifier/approver/browser) hold persistent attaches that
+  // would otherwise keep a quiet session alive forever.
+  scheduleIdleCheck() {
+    if (this.closed || this.idleTimeoutMs <= 0) {
       return;
     }
+    const dueAt = this.lastActivityAt + this.idleTimeoutMs;
+    this.armIdleTimer(Math.max(0, dueAt - Date.now()));
+  }
+  armIdleTimer(delay) {
     if (this.idleTimer) {
-      return;
+      clearTimeout(this.idleTimer);
     }
     this.idleTimer = setTimeout(() => {
       this.idleTimer = void 0;
-      void this.close({ deleteRecord: false }).catch(() => void 0);
-    }, this.idleTimeoutMs);
+      this.checkIdle();
+    }, delay);
     if (typeof this.idleTimer.unref === "function") {
       this.idleTimer.unref();
     }
   }
+  checkIdle() {
+    if (this.closed || this.idleTimeoutMs <= 0) {
+      return;
+    }
+    if (this.turnStartedAt !== void 0 || this.inFlightPermissions.size > 0) {
+      this.armIdleTimer(this.idleTimeoutMs);
+      return;
+    }
+    const idle = Date.now() - this.lastActivityAt;
+    if (idle < this.idleTimeoutMs) {
+      this.armIdleTimer(this.idleTimeoutMs - idle);
+      return;
+    }
+    const opts = this.firstPromptSeeded ? { deleteRecord: false, regenTitle: true } : { deleteRecord: true };
+    void this.close(opts).catch(() => void 0);
+  }
   cancelIdleTimer() {
     if (this.idleTimer) {
       clearTimeout(this.idleTimer);
@@ -1569,17 +1708,14 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         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;
-      }
+      this.lastRecordedAt = entry.recordedAt;
+      this.appendCount += 1;
       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(
+        const store = this.historyStore;
+        void store.append(this.sessionId, entry).catch(() => void 0);
+        if (this.appendCount >= COMPACT_EVERY) {
+          this.appendCount = 0;
+          void store.compact(this.sessionId, MAX_HISTORY_ENTRIES).catch(
             () => void 0
           );
         }
@@ -1590,6 +1726,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         } catch {
         }
       }
+      this.scheduleIdleCheck();
     }
     this.updatedAt = Date.now();
     for (const client of this.clients.values()) {
@@ -1780,7 +1917,14 @@ function firstLine(text, max) {
 // src/core/session-store.ts
 import * as fs3 from "fs/promises";
 import * as path2 from "path";
+import { customAlphabet as customAlphabet2 } from "nanoid";
 import { z as z4 } from "zod";
+var HYDRA_ID_ALPHABET2 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var generateRawId = customAlphabet2(HYDRA_ID_ALPHABET2, 16);
+var HYDRA_LINEAGE_PREFIX = "hydra_lineage_";
+function generateLineageId() {
+  return `${HYDRA_LINEAGE_PREFIX}${generateRawId()}`;
+}
 var PersistedAgentCommand = z4.object({
   name: z4.string(),
   description: z4.string().optional()
@@ -1788,7 +1932,20 @@ var PersistedAgentCommand = z4.object({
 var SessionRecord = z4.object({
   version: z4.literal(1),
   sessionId: z4.string(),
+  // Optional for back-compat with records written before this field
+  // existed; mergeForPersistence generates one on next write so any
+  // touched session converges to having a lineageId. A record that
+  // never gets written again (truly cold and untouched) just won't
+  // participate in lineage-based dedup, which is correct — it was
+  // never exported, so no incoming bundle can claim its lineage.
+  lineageId: z4.string().optional(),
   upstreamSessionId: z4.string(),
+  // When non-empty, marks a session that was created by import and is
+  // waiting for its first attach to bootstrap a fresh upstream agent
+  // and replay the imported history as a takeover transcript. The
+  // origin's local id at export time, kept for debuggability and as a
+  // breadcrumb in `sessions list` (informational, not used for routing).
+  importedFromSessionId: z4.string().optional(),
   agentId: z4.string(),
   cwd: z4.string(),
   title: z4.string().optional(),
@@ -1861,6 +2018,25 @@ var SessionStore = class {
       }
     }
   }
+  // Find a persisted session by lineageId. Used by SessionManager.import
+  // to detect bundles that have already been imported (lineageId match)
+  // so we can either error out or, with replace:true, overwrite.
+  // Returns undefined if no record has that lineageId. Records that
+  // pre-date the lineageId field simply don't match — which is
+  // correct: they were never exported, so no incoming bundle can
+  // legitimately claim their lineage.
+  async findByLineageId(lineageId) {
+    if (lineageId.length === 0) {
+      return void 0;
+    }
+    const all = await this.list().catch(() => []);
+    for (const record of all) {
+      if (record.lineageId === lineageId) {
+        return record;
+      }
+    }
+    return void 0;
+  }
   async list() {
     let entries;
     try {
@@ -1886,7 +2062,9 @@ function recordFromMemorySession(args) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
     sessionId: args.sessionId,
+    lineageId: args.lineageId,
     upstreamSessionId: args.upstreamSessionId,
+    importedFromSessionId: args.importedFromSessionId,
     agentId: args.agentId,
     cwd: args.cwd,
     title: args.title,
@@ -1934,6 +2112,36 @@ var HistoryStore = class {
       });
     });
   }
+  // Trim the on-disk history file to the most recent maxEntries lines.
+  // Runs through the same per-session write queue as append/rewrite so
+  // it's safe to invoke alongside ongoing writes; a no-op if the file is
+  // already at or below the cap.
+  async compact(sessionId, maxEntries) {
+    if (!SESSION_ID_PATTERN2.test(sessionId)) {
+      return;
+    }
+    return this.enqueue(sessionId, async () => {
+      let raw;
+      try {
+        raw = await fs4.readFile(paths.historyFile(sessionId), "utf8");
+      } catch (err) {
+        const e = err;
+        if (e.code === "ENOENT") {
+          return;
+        }
+        throw err;
+      }
+      const lines = raw.split("\n").filter((l) => l.length > 0);
+      if (lines.length <= maxEntries) {
+        return;
+      }
+      const trimmed = lines.slice(-maxEntries);
+      await fs4.writeFile(paths.historyFile(sessionId), trimmed.join("\n") + "\n", {
+        encoding: "utf8",
+        mode: 384
+      });
+    });
+  }
   async load(sessionId) {
     if (!SESSION_ID_PATTERN2.test(sessionId)) {
       return [];
@@ -2021,7 +2229,18 @@ var HistoryStore = class {
   }
 };
 
+// src/tui/history.ts
+import { promises as fs5 } from "fs";
+import * as path3 from "path";
+async function saveHistory(file, history) {
+  await fs5.mkdir(path3.dirname(file), { recursive: true });
+  const lines = history.map((entry) => JSON.stringify(entry));
+  await fs5.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
+}
+
 // src/core/session-manager.ts
+var HYDRA_ID_ALPHABET3 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var generateRawSessionId = customAlphabet3(HYDRA_ID_ALPHABET3, 16);
 var SessionManager = class {
   constructor(registry, spawner, store, options = {}) {
     this.registry = registry;
@@ -2100,6 +2319,9 @@ var SessionManager = class {
       err.code = JsonRpcErrorCodes.AgentNotInstalled;
       throw err;
     }
+    if (params.upstreamSessionId === "") {
+      return this.doResurrectFromImport(params);
+    }
     const plan = planSpawn(agentDef, params.agentArgs ?? []);
     const agent = this.spawner({
       agentId: params.agentId,
@@ -2136,12 +2358,53 @@ var SessionManager = class {
       idleTimeoutMs: this.idleTimeoutMs,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       historyStore: this.histories,
-      seedHistory: params.seedHistory,
       currentModel: params.currentModel,
       currentMode: params.currentMode,
-      agentCommands: params.agentCommands
+      agentCommands: params.agentCommands,
+      // Only gate the first-prompt title heuristic when we actually have
+      // a title to preserve. A title-less session (lost to a write race
+      // or never seeded) should re-derive from the next prompt rather
+      // than stay stuck.
+      firstPromptSeeded: !!params.title,
+      createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0
+    });
+    await this.attachManagerHooks(session);
+    return session;
+  }
+  // First-attach path for a session that was created via import(). The
+  // on-disk meta.json carries upstreamSessionId="" as the import
+  // marker; bootstrap a fresh agent (gets a real upstream id) and kick
+  // off seedFromImport so the agent absorbs the historical transcript.
+  // attachManagerHooks rewrites meta.json with the new upstreamSessionId,
+  // so subsequent resurrects of this session use the normal session/load
+  // path.
+  async doResurrectFromImport(params) {
+    const fresh = await this.bootstrapAgent({
+      agentId: params.agentId,
+      cwd: params.cwd,
+      agentArgs: params.agentArgs,
+      mcpServers: []
+    });
+    const session = new Session({
+      sessionId: params.hydraSessionId,
+      cwd: params.cwd,
+      agentId: params.agentId,
+      agent: fresh.agent,
+      upstreamSessionId: fresh.upstreamSessionId,
+      agentMeta: fresh.agentMeta,
+      title: params.title,
+      agentArgs: params.agentArgs,
+      idleTimeoutMs: this.idleTimeoutMs,
+      spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
+      historyStore: this.histories,
+      currentModel: params.currentModel,
+      currentMode: params.currentMode,
+      agentCommands: params.agentCommands,
+      firstPromptSeeded: !!params.title,
+      createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0
     });
     await this.attachManagerHooks(session);
+    void session.seedFromImport().catch(() => void 0);
     return session;
   }
   // Bootstrap a fresh agent process: registry resolve → spawn → initialize
@@ -2223,28 +2486,20 @@ var SessionManager = class {
       }).catch(() => void 0);
     });
     this.sessions.set(session.sessionId, session);
-    await this.store.write(
-      recordFromMemorySession({
-        sessionId: session.sessionId,
-        upstreamSessionId: session.upstreamSessionId,
-        agentId: session.agentId,
-        cwd: session.cwd,
-        title: session.title,
-        agentArgs: session.agentArgs,
-        currentModel: session.currentModel,
-        currentMode: session.currentMode
-      })
-    ).catch(() => void 0);
+    await this.enqueueMetaWrite(session.sessionId, async () => {
+      const existing = await this.store.read(session.sessionId);
+      const merged = mergeForPersistence(session, existing);
+      await this.store.write(merged);
+    }).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".
+  // Always loads from disk — that's the source of truth whether the
+  // session is hot or cold. 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();
+    if (this.sessions.has(sessionId)) {
+      return this.histories.load(sessionId).catch(() => []);
     }
     const record = await this.store.read(sessionId);
     if (!record) {
@@ -2257,20 +2512,41 @@ var SessionManager = class {
     if (!record) {
       return void 0;
     }
-    const seedHistory = await this.histories.load(sessionId).catch(() => []);
+    let title = record.title;
+    if (!title) {
+      title = await this.deriveTitleFromHistory(sessionId);
+    }
     return {
       hydraSessionId: record.sessionId,
       upstreamSessionId: record.upstreamSessionId,
       agentId: record.agentId,
       cwd: record.cwd,
-      title: record.title,
+      title,
       agentArgs: record.agentArgs,
-      seedHistory: seedHistory.length > 0 ? seedHistory : void 0,
       currentModel: record.currentModel,
       currentMode: record.currentMode,
-      agentCommands: record.agentCommands
+      agentCommands: record.agentCommands,
+      createdAt: record.createdAt
     };
   }
+  // Best-effort: peek at the persisted history's first prompt and use
+  // its first line (capped to 200 chars) as a session title. Returns
+  // undefined if no usable prompt is found or any I/O fails.
+  async deriveTitleFromHistory(sessionId) {
+    const history = await this.histories.load(sessionId).catch(() => []);
+    for (const entry of history) {
+      const params = entry.params;
+      if (params?.update?.sessionUpdate !== "prompt_received") {
+        continue;
+      }
+      const text = extractPromptText(params.update.prompt);
+      const line = firstLine(text, 200);
+      if (line) {
+        return line;
+      }
+    }
+    return void 0;
+  }
   get(sessionId) {
     return this.sessions.get(sessionId);
   }
@@ -2310,13 +2586,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"
       });
@@ -2329,13 +2606,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"
       });
@@ -2343,6 +2621,111 @@ var SessionManager = class {
     entries.sort((a, b) => a.updatedAt < b.updatedAt ? 1 : -1);
     return entries;
   }
+  // Build an export bundle for a session, reading meta + history from
+  // disk. Backfills lineageId if the on-disk record pre-dates that
+  // field. Returns undefined if the session doesn't exist. Callers
+  // populate the bundle's exportedFrom metadata themselves.
+  async exportBundle(sessionId) {
+    const record = await this.store.read(sessionId);
+    if (!record) {
+      return void 0;
+    }
+    let withLineage;
+    if (record.lineageId) {
+      withLineage = record;
+    } else {
+      const lineageId = generateLineageId();
+      const backfilled = { ...record, lineageId };
+      await this.enqueueMetaWrite(sessionId, async () => {
+        const latest = await this.store.read(sessionId);
+        if (!latest) {
+          return;
+        }
+        if (latest.lineageId) {
+          return;
+        }
+        await this.store.write({ ...latest, lineageId });
+      }).catch(() => void 0);
+      withLineage = backfilled;
+    }
+    const history = await this.histories.load(sessionId).catch(() => []);
+    const promptHistory = await loadPromptHistorySafely(sessionId);
+    return { record: withLineage, history, promptHistory };
+  }
+  // Create a local session from an imported bundle. Without `replace`,
+  // a bundle with a lineageId we already have on disk throws
+  // BundleAlreadyImported citing the existing local id. With
+  // `replace: true`, the existing record is overwritten in-place (its
+  // local sessionId is preserved so bookmarks/Slack thread links still
+  // resolve), and any live in-memory session is closed so the next
+  // attach triggers the import-reseed path.
+  async importBundle(bundle, opts = {}) {
+    const existing = await this.store.findByLineageId(bundle.session.lineageId);
+    if (existing) {
+      if (!opts.replace) {
+        const err = new Error(
+          `bundle already imported as ${existing.sessionId}`
+        );
+        err.code = JsonRpcErrorCodes.BundleAlreadyImported;
+        err.existingSessionId = existing.sessionId;
+        throw err;
+      }
+      const live = this.sessions.get(existing.sessionId);
+      if (live) {
+        await live.close({ deleteRecord: false }).catch(() => void 0);
+      }
+      await this.writeImportedRecord({
+        sessionId: existing.sessionId,
+        bundle,
+        preservedCreatedAt: existing.createdAt
+      });
+      return {
+        sessionId: existing.sessionId,
+        importedFromSessionId: bundle.session.sessionId,
+        replaced: true
+      };
+    }
+    const newId = `${HYDRA_SESSION_PREFIX}${generateRawSessionId()}`;
+    await this.writeImportedRecord({ sessionId: newId, bundle });
+    return {
+      sessionId: newId,
+      importedFromSessionId: bundle.session.sessionId,
+      replaced: false
+    };
+  }
+  // Write the imported bundle's history.jsonl, prompt-history (if
+  // present), and meta.json. upstreamSessionId is left empty as the
+  // marker that the first attach should bootstrap a fresh agent and
+  // run seedFromImport rather than calling session/load.
+  async writeImportedRecord(args) {
+    await this.histories.rewrite(
+      args.sessionId,
+      args.bundle.history
+    );
+    if (args.bundle.promptHistory && args.bundle.promptHistory.length > 0) {
+      await saveHistory(
+        paths.tuiHistoryFile(args.sessionId),
+        args.bundle.promptHistory
+      ).catch(() => void 0);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.enqueueMetaWrite(args.sessionId, async () => {
+      await this.store.write({
+        sessionId: args.sessionId,
+        lineageId: args.bundle.session.lineageId,
+        upstreamSessionId: "",
+        importedFromSessionId: args.bundle.session.sessionId,
+        agentId: args.bundle.session.agentId,
+        cwd: args.bundle.session.cwd,
+        title: args.bundle.session.title,
+        currentModel: args.bundle.session.currentModel,
+        currentMode: args.bundle.session.currentMode,
+        agentCommands: args.bundle.session.agentCommands,
+        createdAt: args.preservedCreatedAt ?? now,
+        updatedAt: now
+      });
+    });
+  }
   async deleteRecord(sessionId) {
     const record = await this.store.read(sessionId);
     if (!record) {
@@ -2351,6 +2734,10 @@ var SessionManager = class {
     await this.store.delete(sessionId).catch(() => void 0);
     return true;
   }
+  async hasRecord(sessionId) {
+    const record = await this.store.read(sessionId).catch(() => void 0);
+    return record !== void 0;
+  }
   // Persist a title update from Session.setTitle. The on-disk record
   // was written at create time; updating it here keeps the session
   // record's title in sync with what was broadcast to clients so a
@@ -2424,13 +2811,75 @@ var SessionManager = class {
     await Promise.allSettled(sessions.map((s) => s.close()));
     this.sessions.clear();
   }
+  // Wait for every pending meta.json write to settle. Daemon shutdown
+  // hooks call this so a SIGTERM doesn't kill the process mid-write
+  // and lose a freshly-set title (or model/mode/commands).
+  async flushMetaWrites() {
+    const pending = [...this.metaWriteQueues.values()];
+    if (pending.length === 0) {
+      return;
+    }
+    await Promise.allSettled(pending);
+  }
 };
+function mergeForPersistence(session, existing) {
+  const persistedCommands = session.mergedAvailableCommands().length > 0 ? session.agentOnlyAdvertisedCommands().map((c) => {
+    if (c.description !== void 0) {
+      return { name: c.name, description: c.description };
+    }
+    return { name: c.name };
+  }) : void 0;
+  const agentCommands = persistedCommands ?? existing?.agentCommands;
+  return recordFromMemorySession({
+    sessionId: session.sessionId,
+    lineageId: existing?.lineageId ?? generateLineageId(),
+    upstreamSessionId: session.upstreamSessionId,
+    importedFromSessionId: existing?.importedFromSessionId,
+    agentId: session.agentId,
+    cwd: session.cwd,
+    title: session.title,
+    agentArgs: session.agentArgs,
+    currentModel: session.currentModel ?? existing?.currentModel,
+    currentMode: session.currentMode ?? existing?.currentMode,
+    agentCommands,
+    createdAt: existing?.createdAt ?? new Date(session.createdAt).toISOString()
+  });
+}
+async function loadPromptHistorySafely(sessionId) {
+  try {
+    const raw = await fs6.readFile(paths.tuiHistoryFile(sessionId), "utf8");
+    const out = [];
+    for (const line of raw.split("\n")) {
+      if (line.length === 0) {
+        continue;
+      }
+      try {
+        const decoded = JSON.parse(line);
+        if (typeof decoded === "string") {
+          out.push(decoded);
+        }
+      } catch {
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+async function historyMtimeIso(sessionId) {
+  try {
+    const st = await fs6.stat(paths.historyFile(sessionId));
+    return new Date(st.mtimeMs).toISOString();
+  } catch {
+    return void 0;
+  }
+}
 
 // src/core/extensions.ts
 import { spawn as spawn2 } from "child_process";
-import * as fs5 from "fs";
+import * as fs7 from "fs";
 import * as fsp from "fs/promises";
-import * as path3 from "path";
+import * as path4 from "path";
 var RESTART_BASE_MS = 1e3;
 var RESTART_CAP_MS = 6e4;
 var STOP_GRACE_MS = 3e3;
@@ -2672,7 +3121,7 @@ var ExtensionManager = class {
       if (!entry.endsWith(".pid")) {
         continue;
       }
-      const pidPath = path3.join(paths.extensionsDir(), entry);
+      const pidPath = path4.join(paths.extensionsDir(), entry);
       let pid;
       try {
         const raw = await fsp.readFile(pidPath, "utf8");
@@ -2711,7 +3160,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 = fs7.createWriteStream(paths.extensionLogFile(ext.name), {
       flags: "a"
     });
     logStream.write(
@@ -2761,7 +3210,7 @@ var ExtensionManager = class {
     }
     if (typeof child.pid === "number") {
       try {
-        fs5.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
+        fs7.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
 `, {
           encoding: "utf8",
           mode: 384
@@ -2786,7 +3235,7 @@ var ExtensionManager = class {
     });
     child.on("exit", (code, signal) => {
       try {
-        fs5.unlinkSync(paths.extensionPidFile(ext.name));
+        fs7.unlinkSync(paths.extensionPidFile(ext.name));
       } catch {
       }
       logStream.write(
@@ -2895,6 +3344,75 @@ function constantTimeEqual(a, b) {
 }
 
 // src/daemon/routes/sessions.ts
+import * as os2 from "os";
+
+// src/core/bundle.ts
+import { z as z5 } from "zod";
+var HistoryEntrySchema = z5.object({
+  method: z5.string(),
+  params: z5.unknown(),
+  recordedAt: z5.number()
+});
+var BundleSession = z5.object({
+  // The exporter's local id. Regenerated fresh on import (sessionId is
+  // the local namespace; lineageId is what survives across hops).
+  sessionId: z5.string(),
+  // Required on bundles — the export path backfills if the source
+  // record was written before lineageId existed.
+  lineageId: z5.string(),
+  agentId: z5.string(),
+  cwd: z5.string(),
+  title: z5.string().optional(),
+  currentModel: z5.string().optional(),
+  currentMode: z5.string().optional(),
+  agentCommands: z5.array(PersistedAgentCommand).optional(),
+  createdAt: z5.string(),
+  updatedAt: z5.string()
+});
+var Bundle = z5.object({
+  version: z5.literal(1),
+  exportedAt: z5.string(),
+  exportedFrom: z5.object({
+    hydraVersion: z5.string(),
+    machine: z5.string()
+  }),
+  session: BundleSession,
+  history: z5.array(HistoryEntrySchema),
+  promptHistory: z5.array(z5.string()).optional()
+});
+function encodeBundle(params) {
+  const bundle = {
+    version: 1,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    exportedFrom: {
+      hydraVersion: params.hydraVersion,
+      machine: params.machine
+    },
+    session: {
+      sessionId: params.record.sessionId,
+      lineageId: params.record.lineageId,
+      agentId: params.record.agentId,
+      cwd: params.record.cwd,
+      ...params.record.title !== void 0 ? { title: params.record.title } : {},
+      ...params.record.currentModel !== void 0 ? { currentModel: params.record.currentModel } : {},
+      ...params.record.currentMode !== void 0 ? { currentMode: params.record.currentMode } : {},
+      ...params.record.agentCommands !== void 0 ? { agentCommands: params.record.agentCommands } : {},
+      createdAt: params.record.createdAt,
+      updatedAt: params.record.updatedAt
+    },
+    history: params.history
+  };
+  if (params.promptHistory !== void 0) {
+    bundle.promptHistory = params.promptHistory;
+  }
+  return bundle;
+}
+function decodeBundle(raw) {
+  return Bundle.parse(raw);
+}
+
+// src/daemon/routes/sessions.ts
+var HYDRA_VERSION = "0.1.0";
 function registerSessionRoutes(app, manager, defaults) {
   app.get("/v1/sessions", async (request) => {
     const query = request.query;
@@ -2920,6 +3438,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;
@@ -2936,6 +3470,61 @@ function registerSessionRoutes(app, manager, defaults) {
     }
     reply.code(204).send();
   });
+  app.get("/v1/sessions/:id/export", async (request, reply) => {
+    const raw = request.params.id;
+    const id = await manager.resolveCanonicalId(raw) ?? raw;
+    const exported = await manager.exportBundle(id);
+    if (!exported) {
+      reply.code(404).send({ error: "session not found" });
+      return;
+    }
+    const bundle = encodeBundle({
+      record: exported.record,
+      history: exported.history,
+      promptHistory: exported.promptHistory.length > 0 ? exported.promptHistory : void 0,
+      hydraVersion: HYDRA_VERSION,
+      machine: os2.hostname()
+    });
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    reply.header(
+      "Content-Disposition",
+      `attachment; filename="hydra-${id}-${stamp}.hydra"`
+    );
+    reply.code(200).send(bundle);
+  });
+  app.post("/v1/sessions/import", async (request, reply) => {
+    const body = request.body ?? {};
+    if (body.bundle === void 0) {
+      reply.code(400).send({ error: "missing bundle" });
+      return;
+    }
+    let bundle;
+    try {
+      bundle = decodeBundle(body.bundle);
+    } catch (err) {
+      reply.code(400).send({
+        error: "invalid bundle",
+        details: err.message
+      });
+      return;
+    }
+    try {
+      const result = await manager.importBundle(bundle, {
+        replace: body.replace === true
+      });
+      reply.code(201).send(result);
+    } catch (err) {
+      const e = err;
+      if (e.code === JsonRpcErrorCodes.BundleAlreadyImported) {
+        reply.code(409).send({
+          error: "bundle already imported",
+          existingSessionId: e.existingSessionId
+        });
+        return;
+      }
+      reply.code(500).send({ error: e.message });
+    }
+  });
   app.get("/v1/sessions/:id/history", async (request, reply) => {
     const raw = request.params.id;
     const query = request.query;
@@ -2944,16 +3533,22 @@ function registerSessionRoutes(app, manager, defaults) {
     const live = manager.get(id);
     let snapshot;
     let unsubscribe;
+    let snapshotDone = false;
+    const pending = [];
     if (live) {
-      snapshot = live.getHistorySnapshot();
       if (follow) {
         unsubscribe = live.onBroadcast((entry) => {
           if (reply.raw.writableEnded) {
             return;
           }
-          reply.raw.write(JSON.stringify(entry) + "\n");
+          if (snapshotDone) {
+            reply.raw.write(JSON.stringify(entry) + "\n");
+          } else {
+            pending.push(entry);
+          }
         });
       }
+      snapshot = await live.getHistorySnapshot();
     } else {
       const cold = await manager.getHistory(id);
       if (cold === void 0) {
@@ -2965,9 +3560,23 @@ function registerSessionRoutes(app, manager, defaults) {
     reply.raw.setHeader("Content-Type", "application/x-ndjson");
     reply.raw.setHeader("Cache-Control", "no-cache");
     reply.raw.statusCode = 200;
+    const snapshotKeys = /* @__PURE__ */ new Set();
     for (const entry of snapshot ?? []) {
       reply.raw.write(JSON.stringify(entry) + "\n");
+      const e = entry;
+      if (typeof e.recordedAt === "number") {
+        snapshotKeys.add(String(e.recordedAt));
+      }
+    }
+    for (const entry of pending) {
+      const e = entry;
+      const key = typeof e.recordedAt === "number" ? String(e.recordedAt) : "";
+      if (key && snapshotKeys.has(key)) {
+        continue;
+      }
+      reply.raw.write(JSON.stringify(entry) + "\n");
     }
+    snapshotDone = true;
     if (!unsubscribe) {
       reply.raw.end();
       return reply;
@@ -3127,6 +3736,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";
 
@@ -3202,7 +3821,7 @@ function wsToMessageStream(ws) {
 }
 
 // src/daemon/acp-ws.ts
-var HYDRA_VERSION = "0.1.0";
+var HYDRA_VERSION2 = "0.1.0";
 var HYDRA_PROTOCOL_VERSION = 1;
 function registerAcpWsEndpoint(app, deps) {
   app.get("/acp", { websocket: true }, (socket, request) => {
@@ -3248,7 +3867,7 @@ function registerAcpWsEndpoint(app, deps) {
         agentArgs: hydraMeta.agentArgs
       });
       const client = bindClientToSession(connection, session, state);
-      session.attach(client, "full");
+      await session.attach(client, "full");
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
         clientId: client.clientId
@@ -3267,14 +3886,22 @@ function registerAcpWsEndpoint(app, deps) {
       const lookupId = hydraHints ? params.sessionId : await deps.manager.resolveCanonicalId(params.sessionId) ?? params.sessionId;
       let session = deps.manager.get(lookupId);
       if (!session) {
-        let resurrectParams = hydraHints ? {
-          hydraSessionId: params.sessionId,
-          upstreamSessionId: hydraHints.upstreamSessionId,
-          agentId: hydraHints.agentId,
-          cwd: hydraHints.cwd,
-          title: hydraHints.title,
-          agentArgs: hydraHints.agentArgs
-        } : await deps.manager.loadFromDisk(lookupId);
+        const fromDisk = await deps.manager.loadFromDisk(lookupId);
+        let resurrectParams = fromDisk;
+        if (hydraHints) {
+          resurrectParams = {
+            hydraSessionId: params.sessionId,
+            upstreamSessionId: hydraHints.upstreamSessionId,
+            agentId: hydraHints.agentId,
+            cwd: hydraHints.cwd,
+            title: hydraHints.title ?? fromDisk?.title,
+            agentArgs: hydraHints.agentArgs ?? fromDisk?.agentArgs,
+            currentModel: fromDisk?.currentModel,
+            currentMode: fromDisk?.currentMode,
+            agentCommands: fromDisk?.agentCommands,
+            createdAt: fromDisk?.createdAt
+          };
+        }
         if (!resurrectParams) {
           const err = new Error(
             `session ${params.sessionId} not found and no resume hints provided`
@@ -3290,13 +3917,13 @@ function registerAcpWsEndpoint(app, deps) {
         state,
         params.clientInfo
       );
-      const replay = session.attach(client, params.historyPolicy);
+      const replay = await session.attach(client, params.historyPolicy);
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
         clientId: client.clientId
       });
       app.log.info(
-        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size}`
+        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} replayed=${replay.length}`
       );
       for (const note of replay) {
         await connection.notify(note.method, note.params);
@@ -3392,7 +4019,7 @@ function registerAcpWsEndpoint(app, deps) {
         session = await deps.manager.resurrect(fromDisk);
       }
       const client = bindClientToSession(connection, session, state);
-      const replay = session.attach(client, "pending_only");
+      const replay = await session.attach(client, "pending_only");
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
         clientId: client.clientId
@@ -3450,12 +4077,15 @@ function buildResponseMeta(session) {
   if (commands.length > 0) {
     ours.availableCommands = commands;
   }
+  if (session.turnStartedAt !== void 0) {
+    ours.turnStartedAt = session.turnStartedAt;
+  }
   return mergeMeta(session.agentMeta, ours);
 }
 function buildInitializeResult() {
   return {
     protocolVersion: HYDRA_PROTOCOL_VERSION,
-    agentInfo: { name: "hydra", version: HYDRA_VERSION },
+    agentInfo: { name: "hydra", version: HYDRA_VERSION2 },
     agentCapabilities: {
       // hydra is a transparent proxy: prompt blocks and MCP server configs are
       // forwarded to the underlying agent unchanged. We claim the union of
@@ -3494,7 +4124,7 @@ function bindClientToSession(connection, session, state, clientInfo) {
 }
 
 // src/daemon/server.ts
-var HYDRA_VERSION2 = "0.1.0";
+var HYDRA_VERSION3 = "0.1.0";
 async function startDaemon(config) {
   ensureLoopbackOrTls(config);
   const httpsOptions = config.daemon.tls ? {
@@ -3528,13 +4158,17 @@ async function startDaemon(config) {
     idleTimeoutMs: config.daemon.sessionIdleTimeoutSeconds * 1e3
   });
   const extensions = new ExtensionManager(extensionList(config));
-  registerHealthRoutes(app, HYDRA_VERSION2);
+  registerHealthRoutes(app, HYDRA_VERSION3);
   registerSessionRoutes(app, manager, {
     agentId: config.defaultAgent,
     cwd: config.defaultCwd
   });
   registerAgentRoutes(app, registry);
   registerExtensionRoutes(app, extensions);
+  registerConfigRoutes(app, {
+    defaultAgent: config.defaultAgent,
+    defaultCwd: config.defaultCwd
+  });
   registerAcpWsEndpoint(app, {
     config,
     manager,
@@ -3568,9 +4202,10 @@ async function startDaemon(config) {
   const shutdown = async () => {
     await extensions.stop();
     await manager.closeAll();
+    await manager.flushMetaWrites();
     await app.close();
     try {
-      fs6.unlinkSync(paths.pidFile());
+      fs8.unlinkSync(paths.pidFile());
     } catch {
     }
     try {