@hydra-acp/cli 0.1.3 → 0.1.5

package/dist/cli.js

@@ -37,7 +37,11 @@ var init_paths = __esm({
       currentLogFile: () => path.join(hydraHome(), "current.log"),
       registryCache: () => path.join(hydraHome(), "registry.json"),
       agentsDir: () => path.join(hydraHome(), "agents"),
-      agentDir: (id) => path.join(hydraHome(), "agents", id),
+      // <platformKey>/<agentId>/<version>/ — platform at the top so a Hydra
+      // home shared between machines (NFS, rsync'd dotfiles) keeps each
+      // machine's binaries cleanly separated. `ls agents/` immediately
+      // shows which platforms have ever installed anything.
+      agentInstallDir: (id, platformKey, version) => path.join(hydraHome(), "agents", platformKey, id, version),
       sessionsDir: () => path.join(hydraHome(), "sessions"),
       // One directory per session id under sessions/. Co-locates the
       // session record, its transcript, and any future per-session state
@@ -89,8 +93,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.
 `
@@ -99,9 +102,23 @@ async function ensureConfig() {
   }
   return loadConfig();
 }
-async function writeConfig(config) {
+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(config, null, 2) + "\n", {
+  await fs.writeFile(paths.config(), JSON.stringify(minimal, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+  return HydraConfig.parse(minimal);
+}
+async function updateConfigField(mutate) {
+  const path7 = paths.config();
+  const text = await fs.readFile(path7, "utf8");
+  const raw = JSON.parse(text);
+  mutate(raw);
+  HydraConfig.parse(raw);
+  await fs.writeFile(path7, JSON.stringify(raw, null, 2) + "\n", {
     encoding: "utf8",
     mode: 384
   });
@@ -115,13 +132,6 @@ function generateAuthToken() {
   }
   return `hydra_token_${hex}`;
 }
-function defaultConfig() {
-  return HydraConfig.parse({
-    daemon: {
-      authToken: generateAuthToken()
-    }
-  });
-}
 function expandHome(p) {
   if (p === "~" || p === "$HOME") {
     return homedir2();
@@ -150,7 +160,7 @@ var init_config = __esm({
       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)
     });
     RegistryConfig = z.object({
       url: z.string().url().default(REGISTRY_URL_DEFAULT),
@@ -183,6 +193,14 @@ var init_config = __esm({
       daemon: DaemonConfig,
       registry: RegistryConfig.default({ url: REGISTRY_URL_DEFAULT, ttlHours: 24 }),
       defaultAgent: z.string().default("claude-acp"),
+      // Optional per-agent default model id. When a brand-new agent process
+      // is spawned (session/new path), hydra issues session/set_model with
+      // the matching entry so the user lands on their preferred model from
+      // the first prompt. Not applied on resurrect — those sessions keep
+      // whatever the user last selected. Keys are agent ids; values are the
+      // raw model id strings the agent expects (claude-acp: "claude-opus-4-7",
+      // opencode: "openai/gpt-5-codex" or "ncp-anthropic/claude-opus-4-7", …).
+      defaultModels: z.record(z.string(), z.string()).default({}),
       // Where new sessions land when POST /v1/sessions omits cwd. Stored as
       // a literal string ("~", "~/dev", "$HOME/work") so the config file is
       // portable across machines; expanded via expandHome at use time.
@@ -264,7 +282,7 @@ function extractHydraMeta(meta) {
 function mergeMeta(passthrough, ours) {
   return { ...passthrough ?? {}, [HYDRA_META_KEY]: ours };
 }
-var JsonRpcErrorCodes, InitializeParams, HistoryPolicy, SessionNewParams, SessionResumeHints, SessionAttachParams, HYDRA_META_KEY, SessionDetachParams, SessionListParams, SessionListEntry, SessionListResult, SessionPromptParams, SessionCancelParams, ProxyInitializeParams;
+var JsonRpcErrorCodes, InitializeParams, HistoryPolicy, SessionNewParams, SessionResumeHints, SessionAttachParams, HYDRA_META_KEY, SessionDetachParams, SessionListParams, SessionListUsage, SessionListEntry, SessionListResult, SessionPromptParams, SessionCancelParams, ProxyInitializeParams;
 var init_types = __esm({
   "src/acp/types.ts"() {
     "use strict";
@@ -277,7 +295,8 @@ var init_types = __esm({
       SessionNotFound: -32001,
       PermissionDenied: -32002,
       AlreadyAttached: -32003,
-      AgentNotInstalled: -32005
+      AgentNotInstalled: -32005,
+      BundleAlreadyImported: -32010
     };
     InitializeParams = z3.object({
       protocolVersion: z3.number().optional(),
@@ -318,12 +337,24 @@ var init_types = __esm({
       cursor: z3.string().optional(),
       limit: z3.number().int().positive().max(200).optional()
     });
+    SessionListUsage = z3.object({
+      used: z3.number().optional(),
+      size: z3.number().optional(),
+      costAmount: z3.number().optional(),
+      costCurrency: z3.string().optional()
+    });
     SessionListEntry = z3.object({
       sessionId: z3.string(),
       upstreamSessionId: z3.string().optional(),
       cwd: z3.string(),
       title: z3.string().optional(),
       agentId: z3.string().optional(),
+      // Last-known model id, so list views can render `<agent>(<model>)`
+      // without resurrecting cold sessions to look it up.
+      currentModel: z3.string().optional(),
+      // Last-known usage snapshot so list views can show per-session cost
+      // (and tokens, in callers that care) without resurrecting cold sessions.
+      currentUsage: SessionListUsage.optional(),
       updatedAt: z3.string(),
       attachedClients: z3.number().int().nonnegative(),
       status: z3.enum(["live", "cold"]).default("live"),
@@ -401,9 +432,9 @@ var init_connection = __esm({
         }
         const id = nanoid();
         const message = { jsonrpc: "2.0", id, method, params };
-        const response = new Promise((resolve2, reject) => {
+        const response = new Promise((resolve5, reject) => {
           this.pending.set(id, {
-            resolve: (result) => resolve2(result),
+            resolve: (result) => resolve5(result),
             reject
           });
           this.stream.send(message).catch((err) => {
@@ -527,8 +558,8 @@ var init_hydra_commands = __esm({
         description: "Regenerate the session title via the agent (or set manually with an arg)"
       },
       {
-        verb: "switch",
-        name: "/hydra switch",
+        verb: "agent",
+        name: "/hydra agent",
         argsHint: "<agent>",
         description: "Swap the agent backing this session, preserving context"
       }
@@ -627,7 +658,7 @@ function firstLine(text, max) {
   }
   return void 0;
 }
-var HYDRA_ID_ALPHABET, generateHydraId, HYDRA_SESSION_PREFIX, Session, STATE_UPDATE_KINDS;
+var HYDRA_ID_ALPHABET, generateHydraId, HYDRA_SESSION_PREFIX, MAX_HISTORY_ENTRIES, COMPACT_EVERY, Session, STATE_UPDATE_KINDS;
 var init_session = __esm({
   "src/core/session.ts"() {
     "use strict";
@@ -636,10 +667,12 @@ var init_session = __esm({
     HYDRA_ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     generateHydraId = customAlphabet(HYDRA_ID_ALPHABET, 16);
     HYDRA_SESSION_PREFIX = "hydra_session_";
+    MAX_HISTORY_ENTRIES = 1e3;
+    COMPACT_EVERY = 200;
     Session = class {
       sessionId;
       cwd;
-      // agent / agentId / upstreamSessionId are mutable so /hydra switch can
+      // agent / agentId / upstreamSessionId are mutable so /hydra agent can
       // replace the underlying agent process while keeping the same Session
       // record. agentMeta is the metadata returned by the agent at session/new
       // time; it gets refreshed on switch too.
@@ -654,9 +687,10 @@ var init_session = __esm({
       // stale-prone for snapshot-shaped events).
       currentModel;
       currentMode;
+      currentUsage;
       updatedAt;
+      createdAt;
       clients = /* @__PURE__ */ new Map();
-      history = [];
       historyStore;
       promptQueue = [];
       promptInFlight = false;
@@ -672,6 +706,15 @@ var init_session = __esm({
       // 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
@@ -686,6 +729,12 @@ var init_session = __esm({
       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
@@ -700,6 +749,7 @@ var init_session = __esm({
       agentCommandsHandlers = [];
       modelHandlers = [];
       modeHandlers = [];
+      usageHandlers = [];
       constructor(init) {
         this.sessionId = init.sessionId ?? `${HYDRA_SESSION_PREFIX}${generateHydraId()}`;
         this.cwd = init.cwd;
@@ -711,6 +761,7 @@ var init_session = __esm({
         this.title = init.title;
         this.currentModel = init.currentModel;
         this.currentMode = init.currentMode;
+        this.currentUsage = init.currentUsage;
         if (init.agentCommands && init.agentCommands.length > 0) {
           this.agentAdvertisedCommands = [...init.agentCommands];
         }
@@ -720,11 +771,11 @@ var init_session = __esm({
           this.firstPromptSeeded = true;
         }
         this.historyStore = init.historyStore;
-        if (init.seedHistory && init.seedHistory.length > 0) {
-          this.history = [...init.seedHistory];
-        }
         this.updatedAt = Date.now();
+        this.createdAt = init.createdAt ?? this.updatedAt;
+        this.lastRecordedAt = this.updatedAt;
         this.wireAgent(this.agent);
+        this.scheduleIdleCheck();
       }
       broadcastMergedCommands() {
         const merged = [
@@ -740,7 +791,7 @@ var init_session = __esm({
         });
       }
       // Register session/update, session/request_permission, and onExit
-      // handlers on an agent connection. Re-run on every /hydra switch so
+      // handlers on an agent connection. Re-run on every /hydra agent so
       // the new agent is plumbed identically. The exit handler's identity
       // check is what makes switching safe: when the *old* agent exits as
       // part of a swap, this.agent has already been replaced, so we no-op
@@ -764,6 +815,10 @@ var init_session = __esm({
             this.recordAndBroadcast("session/update", params);
             return;
           }
+          if (this.maybeApplyAgentUsage(params)) {
+            this.recordAndBroadcast("session/update", params);
+            return;
+          }
           this.maybeApplyAgentSessionInfo(params);
           this.recordAndBroadcast("session/update", params);
         });
@@ -784,34 +839,20 @@ var init_session = __esm({
         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.
+      // 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() {
-        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;
+        return this.promptStartedAt;
       }
-      // 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];
+      // 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/
@@ -827,6 +868,10 @@ var init_session = __esm({
           }
         };
       }
+      // 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(
@@ -842,14 +887,10 @@ var init_session = __esm({
         }
         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
@@ -863,7 +904,6 @@ var init_session = __esm({
       detach(clientId) {
         if (this.clients.delete(clientId)) {
           this.updatedAt = Date.now();
-          this.maybeStartIdleTimer();
         }
       }
       async prompt(clientId, params) {
@@ -909,6 +949,7 @@ var init_session = __esm({
         if (client.clientInfo?.version) {
           sentBy.version = client.clientInfo.version;
         }
+        this.promptStartedAt = Date.now();
         this.recordAndBroadcast(
           "session/update",
           {
@@ -945,6 +986,7 @@ var init_session = __esm({
         if (stopReason !== void 0) {
           update.stopReason = stopReason;
         }
+        this.promptStartedAt = void 0;
         this.recordAndBroadcast(
           "session/update",
           {
@@ -1094,6 +1136,49 @@ var init_session = __esm({
         }
         return true;
       }
+      // usage_update carries any subset of {used, size, cost.amount,
+      // cost.currency}. Merge non-undefined fields onto currentUsage so a
+      // sparse update preserves prior values, and fire usage handlers only
+      // if something actually changed.
+      maybeApplyAgentUsage(params) {
+        const obj = params ?? {};
+        const update = obj.update ?? {};
+        if (update.sessionUpdate !== "usage_update") {
+          return false;
+        }
+        const next = { ...this.currentUsage ?? {} };
+        let changed = false;
+        if (typeof update.used === "number" && next.used !== update.used) {
+          next.used = update.used;
+          changed = true;
+        }
+        if (typeof update.size === "number" && next.size !== update.size) {
+          next.size = update.size;
+          changed = true;
+        }
+        if (update.cost && typeof update.cost === "object") {
+          const cost = update.cost;
+          if (typeof cost.amount === "number" && next.costAmount !== cost.amount) {
+            next.costAmount = cost.amount;
+            changed = true;
+          }
+          if (typeof cost.currency === "string" && next.costCurrency !== cost.currency) {
+            next.costCurrency = cost.currency;
+            changed = true;
+          }
+        }
+        if (!changed) {
+          return true;
+        }
+        this.currentUsage = next;
+        for (const handler of this.usageHandlers) {
+          try {
+            handler(next);
+          } 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
@@ -1124,12 +1209,21 @@ var init_session = __esm({
       onModeChange(handler) {
         this.modeHandlers.push(handler);
       }
+      onUsageChange(handler) {
+        this.usageHandlers.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];
       }
+      // 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
@@ -1180,8 +1274,8 @@ var init_session = __esm({
         switch (verb) {
           case "title":
             return this.runTitleCommand(arg);
-          case "switch":
-            return this.runSwitchCommand(arg);
+          case "agent":
+            return this.runAgentCommand(arg);
           default: {
             const err = new Error(
               `no dispatcher for /hydra verb ${verb}`
@@ -1217,7 +1311,7 @@ var init_session = __esm({
       }
       // Send a prompt to the underlying agent and capture its reply chunks
       // privately (no fan-out to clients, no recording into history). Used
-      // by /hydra title's regen path and /hydra switch's transcript-injection
+      // by /hydra title's regen path and /hydra agent's transcript-injection
       // path. Returns the joined agent_message_chunk text.
       async runInternalPrompt(text) {
         if (this.internalPromptCapture) {
@@ -1239,10 +1333,10 @@ var init_session = __esm({
       // record. Spawns the new agent first so a failure leaves the old one
       // intact; then injects a synthesized transcript so the new agent has
       // context for the next turn.
-      runSwitchCommand(newAgentId) {
+      runAgentCommand(newAgentId) {
         if (!newAgentId) {
           throw withCode(
-            new Error("/hydra switch requires an agent id"),
+            new Error("/hydra agent requires an agent id"),
             JsonRpcErrorCodes.InvalidParams
           );
         }
@@ -1261,7 +1355,7 @@ var init_session = __esm({
         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,
@@ -1293,15 +1387,20 @@ var init_session = __esm({
           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;
           }
@@ -1355,29 +1454,53 @@ var init_session = __esm({
         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 agent 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
-      // so a future /hydra switch's transcript builder filters them out.
+      // (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 agent'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", {
@@ -1408,22 +1531,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;
-          const opts = this.firstPromptSeeded ? { deleteRecord: false, regenTitle: true } : { deleteRecord: true };
-          void this.close(opts).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);
@@ -1448,17 +1604,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
               );
             }
@@ -1469,6 +1622,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
             } catch {
             }
           }
+          this.scheduleIdleCheck();
         }
         this.updatedAt = Date.now();
         for (const client of this.clients.values()) {
@@ -1487,7 +1641,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
           );
         }
         const clientParams = this.rewriteForClient(params);
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve5, reject) => {
           let settled = false;
           const outbound = [];
           const entry = { addClient: sendTo };
@@ -1522,7 +1676,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
                     result
                   }).catch(() => void 0);
                 }
-                resolve2(result);
+                resolve5(result);
               });
             }).catch((err) => {
               settle(() => reject(err));
@@ -1534,16 +1688,16 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         });
       }
       async enqueuePrompt(task) {
-        return new Promise((resolve2, reject) => {
-          const run = async () => {
+        return new Promise((resolve5, reject) => {
+          const run2 = async () => {
             try {
               const result = await task();
-              resolve2(result);
+              resolve5(result);
             } catch (err) {
               reject(err);
             }
           };
-          this.promptQueue.push(run);
+          this.promptQueue.push(run2);
           void this.drainQueue();
         });
       }
@@ -1568,11 +1722,70 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       "session_info_update",
       "current_model_update",
       "current_mode_update",
-      "available_commands_update"
+      "available_commands_update",
+      "usage_update"
     ]);
   }
 });
 
+// src/tui/history.ts
+import { promises as fs7 } from "fs";
+import * as path4 from "path";
+async function loadHistory(file) {
+  let text;
+  try {
+    text = await fs7.readFile(file, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return [];
+    }
+    throw err;
+  }
+  return parseHistory(text);
+}
+function parseHistory(text) {
+  const out = [];
+  for (const rawLine of text.split("\n")) {
+    if (rawLine.length === 0) {
+      continue;
+    }
+    try {
+      const decoded = JSON.parse(rawLine);
+      if (typeof decoded === "string") {
+        out.push(decoded);
+      }
+    } catch {
+    }
+  }
+  return out;
+}
+function appendEntry(history, entry) {
+  const trimmed = entry.replace(/\n+$/, "");
+  if (trimmed.length === 0) {
+    return history;
+  }
+  if (history.length > 0 && history[history.length - 1] === trimmed) {
+    return history;
+  }
+  const out = history.concat(trimmed);
+  if (out.length > HISTORY_CAP) {
+    return out.slice(out.length - HISTORY_CAP);
+  }
+  return out;
+}
+async function saveHistory(file, history) {
+  await fs7.mkdir(path4.dirname(file), { recursive: true });
+  const lines = history.map((entry) => JSON.stringify(entry));
+  await fs7.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
+}
+var HISTORY_CAP;
+var init_history = __esm({
+  "src/tui/history.ts"() {
+    "use strict";
+    HISTORY_CAP = 500;
+  }
+});
+
 // src/acp/ws-stream.ts
 function wsToMessageStream(ws) {
   const messageHandlers = [];
@@ -1618,13 +1831,13 @@ function wsToMessageStream(ws) {
         throw new Error("ws is closed");
       }
       const text = JSON.stringify(message);
-      await new Promise((resolve2, reject) => {
+      await new Promise((resolve5, reject) => {
         ws.send(text, (err) => {
           if (err) {
             reject(err);
             return;
           }
-          resolve2();
+          resolve5();
         });
       });
     },
@@ -1651,7 +1864,7 @@ var init_ws_stream = __esm({
 });
 
 // src/core/daemon-bootstrap.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { setTimeout as sleep } from "timers/promises";
 async function ensureDaemonReachable(config) {
   if (await pingHealth(config)) {
@@ -1678,11 +1891,15 @@ function spawnDaemonDetached() {
   if (!cliPath) {
     throw new Error("Cannot determine hydra-acp binary path to spawn daemon");
   }
-  const child = spawn3(process.execPath, [cliPath, "daemon", "start"], {
-    detached: true,
-    stdio: "ignore",
-    env: process.env
-  });
+  const child = spawn4(
+    process.execPath,
+    [cliPath, "daemon", "start", "--foreground"],
+    {
+      detached: true,
+      stdio: "ignore",
+      env: process.env
+    }
+  );
   child.unref();
 }
 async function waitForDaemonReady(config, timeoutMs = 15e3) {
@@ -1703,25 +1920,80 @@ var init_daemon_bootstrap = __esm({
   }
 });
 
+// src/core/agent-display.ts
+function shortenModel(model) {
+  if (!model) {
+    return void 0;
+  }
+  const idx = model.lastIndexOf("/");
+  if (idx === -1) {
+    return model;
+  }
+  return model.slice(idx + 1);
+}
+function formatAgentWithModel(agentId, model) {
+  const agent = agentId ?? "?";
+  const short = shortenModel(model);
+  if (!short) {
+    return agent;
+  }
+  return `${agent}${AGENT_MODEL_SEP}${short}`;
+}
+function formatAgentCell(agentId, model, usage) {
+  const base = formatAgentWithModel(agentId, model);
+  if (!usage || typeof usage.costAmount !== "number") {
+    return base;
+  }
+  const compact = formatCostCompact(usage.costAmount, usage.costCurrency);
+  if (compact === null) {
+    return base;
+  }
+  return `${base} ${compact}`;
+}
+function formatCost(amount, currency) {
+  const sign = currency === "USD" || currency === void 0 ? "$" : "";
+  const decimals = amount >= 1 ? 2 : 4;
+  return `${sign}${amount.toFixed(decimals)}${currency && currency !== "USD" ? ` ${currency}` : ""}`;
+}
+function formatCostCompact(amount, currency) {
+  const whole = Math.round(amount);
+  if (whole === 0) {
+    return null;
+  }
+  const sign = currency === "USD" || currency === void 0 ? "$" : "";
+  return `${sign}${whole}${currency && currency !== "USD" ? ` ${currency}` : ""}`;
+}
+var AGENT_MODEL_SEP;
+var init_agent_display = __esm({
+  "src/core/agent-display.ts"() {
+    "use strict";
+    AGENT_MODEL_SEP = "\u2022";
+  }
+});
+
 // src/cli/session-row.ts
 function toRow(s, now = Date.now()) {
   return {
     session: stripHydraSessionPrefix(s.sessionId),
     upstream: s.upstreamSessionId ?? "-",
-    status: (s.status ?? "live").toUpperCase(),
-    clients: s.status === "cold" ? "-" : String(s.attachedClients),
-    agent: s.agentId ?? "?",
+    state: formatState(s.status, s.attachedClients),
+    agent: formatAgentCell(s.agentId, s.currentModel, s.currentUsage),
     age: formatRelativeAge(s.updatedAt, now),
     title: s.title ?? "-",
     cwd: s.cwd
   };
 }
+function formatState(status, clients) {
+  if (status === "cold") {
+    return "COLD";
+  }
+  return `LIVE(${clients})`;
+}
 function computeWidths(rows) {
   return {
     session: maxLen(HEADER.session, rows.map((r) => r.session)),
     upstream: maxLen(HEADER.upstream, rows.map((r) => r.upstream)),
-    status: maxLen(HEADER.status, rows.map((r) => r.status)),
-    clients: maxLen(HEADER.clients, rows.map((r) => r.clients)),
+    state: maxLen(HEADER.state, rows.map((r) => r.state)),
     agent: maxLen(HEADER.agent, rows.map((r) => r.agent)),
     age: maxLen(HEADER.age, rows.map((r) => r.age)),
     title: maxLen(HEADER.title, rows.map((r) => r.title))
@@ -1776,8 +2048,7 @@ function formatRow(r, w, maxWidth) {
   const fixed = [
     r.session.padEnd(w.session),
     r.upstream.padEnd(w.upstream),
-    r.status.padEnd(w.status),
-    r.clients.padStart(w.clients),
+    r.state.padEnd(w.state),
     r.agent.padEnd(w.agent),
     r.age.padStart(w.age)
   ].join(SEP);
@@ -1827,12 +2098,12 @@ var HEADER, SEP, MIN_CWD, TITLE_MAX_WIDTH;
 var init_session_row = __esm({
   "src/cli/session-row.ts"() {
     "use strict";
+    init_agent_display();
     init_session();
     HEADER = {
       session: "SESSION",
       upstream: "UPSTREAM",
-      status: "STATUS",
-      clients: "CLIENTS",
+      state: "STATE",
       agent: "AGENT",
       age: "AGE",
       title: "TITLE",
@@ -1845,6 +2116,8 @@ var init_session_row = __esm({
 });
 
 // src/cli/commands/sessions.ts
+import * as fs12 from "fs/promises";
+import * as path6 from "path";
 async function runSessionsList(opts = {}) {
   const config = await loadConfig();
   const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
@@ -1933,6 +2206,111 @@ async function runSessionsRm(id) {
   process.stdout.write(`Removed ${id}
 `);
 }
+async function runSessionsExport(id, outPath) {
+  if (!id) {
+    process.stderr.write(
+      "Usage: hydra-acp sessions export <session-id> [--out <file>]\n"
+    );
+    process.exit(2);
+  }
+  const config = await loadConfig();
+  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetch(
+    `${baseUrl}/v1/sessions/${encodeURIComponent(id)}/export`,
+    {
+      headers: { Authorization: `Bearer ${config.daemon.authToken}` }
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    process.stderr.write(`Daemon returned HTTP ${response.status}: ${text}
+`);
+    process.exit(1);
+  }
+  const body = await response.text();
+  if (!outPath) {
+    process.stdout.write(body);
+    if (!body.endsWith("\n")) {
+      process.stdout.write("\n");
+    }
+    return;
+  }
+  const resolved = outPath === "." ? deriveFilenameFrom(response, id) : outPath;
+  await fs12.mkdir(path6.dirname(path6.resolve(resolved)), { recursive: true });
+  await fs12.writeFile(resolved, body, { encoding: "utf8", mode: 384 });
+  process.stdout.write(`Wrote ${resolved}
+`);
+}
+async function runSessionsImport(file, opts = {}) {
+  if (!file) {
+    process.stderr.write(
+      "Usage: hydra-acp sessions import <file>|- [--replace]\n"
+    );
+    process.exit(2);
+  }
+  let body;
+  if (file === "-") {
+    body = await readStdin();
+  } else {
+    body = await fs12.readFile(file, "utf8");
+  }
+  let bundle;
+  try {
+    bundle = JSON.parse(body);
+  } catch (err) {
+    process.stderr.write(`Failed to parse bundle: ${err.message}
+`);
+    process.exit(1);
+  }
+  const config = await loadConfig();
+  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetch(`${baseUrl}/v1/sessions/import`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.daemon.authToken}`
+    },
+    body: JSON.stringify({ bundle, replace: opts.replace === true })
+  });
+  if (response.status === 409) {
+    const detail = await response.json().catch(() => ({}));
+    process.stderr.write(
+      `Bundle already imported as ${detail.existingSessionId ?? "unknown"}. Use --replace to overwrite.
+`
+    );
+    process.exit(1);
+  }
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    process.stderr.write(`Daemon returned HTTP ${response.status}: ${text}
+`);
+    process.exit(1);
+  }
+  const result = await response.json();
+  process.stdout.write(
+    result.replaced ? `Replaced ${result.sessionId} (from ${result.importedFromSessionId})
+` : `Imported as ${result.sessionId} (from ${result.importedFromSessionId})
+`
+  );
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function deriveFilenameFrom(response, id) {
+  const cd = response.headers.get("content-disposition");
+  if (cd) {
+    const match = cd.match(/filename="([^"]+)"/);
+    if (match) {
+      return match[1];
+    }
+  }
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return `hydra-${id}-${stamp}.hydra`;
+}
 function httpBase(host, port, tls) {
   const protocol = tls ? "https" : "http";
   return `${protocol}://${host}:${port}`;
@@ -1952,11 +2330,11 @@ function isResponse(msg) {
   return !("method" in msg) && "id" in msg && msg.id !== void 0;
 }
 async function openWs(url, subprotocols) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve5, reject) => {
     const ws = new WebSocket(url, subprotocols);
     const onOpen = () => {
       ws.off("error", onError);
-      resolve2(wsToMessageStream(ws));
+      resolve5(wsToMessageStream(ws));
     };
     const onError = (err) => {
       ws.off("open", onOpen);
@@ -2027,8 +2405,8 @@ var init_resilient_ws = __esm({
           throw new Error("resilient ws stream not connected");
         }
         const id = message.id;
-        const promise = new Promise((resolve2, reject) => {
-          this.pendingRequests.set(id, { resolve: resolve2, reject });
+        const promise = new Promise((resolve5, reject) => {
+          this.pendingRequests.set(id, { resolve: resolve5, reject });
         });
         try {
           await this.current.send(message);
@@ -2056,8 +2434,8 @@ var init_resilient_ws = __esm({
             this.bindStream(stream);
             const wasFirst = this.firstConnect;
             this.firstConnect = false;
-            this.connectGate = new Promise((resolve2) => {
-              this.releaseConnectGate = resolve2;
+            this.connectGate = new Promise((resolve5) => {
+              this.releaseConnectGate = resolve5;
             });
             try {
               if (this.opts.onConnect) {
@@ -2180,64 +2558,6 @@ var init_resilient_ws = __esm({
   }
 });
 
-// src/tui/history.ts
-import { promises as fs10 } from "fs";
-import * as path4 from "path";
-async function loadHistory(file) {
-  let text;
-  try {
-    text = await fs10.readFile(file, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      return [];
-    }
-    throw err;
-  }
-  return parseHistory(text);
-}
-function parseHistory(text) {
-  const out = [];
-  for (const rawLine of text.split("\n")) {
-    if (rawLine.length === 0) {
-      continue;
-    }
-    try {
-      const decoded = JSON.parse(rawLine);
-      if (typeof decoded === "string") {
-        out.push(decoded);
-      }
-    } catch {
-    }
-  }
-  return out;
-}
-function appendEntry(history, entry) {
-  const trimmed = entry.replace(/\n+$/, "");
-  if (trimmed.length === 0) {
-    return history;
-  }
-  if (history.length > 0 && history[history.length - 1] === trimmed) {
-    return history;
-  }
-  const out = history.concat(trimmed);
-  if (out.length > HISTORY_CAP) {
-    return out.slice(out.length - HISTORY_CAP);
-  }
-  return out;
-}
-async function saveHistory(file, history) {
-  await fs10.mkdir(path4.dirname(file), { recursive: true });
-  const lines = history.map((entry) => JSON.stringify(entry));
-  await fs10.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
-}
-var HISTORY_CAP;
-var init_history = __esm({
-  "src/tui/history.ts"() {
-    "use strict";
-    HISTORY_CAP = 500;
-  }
-});
-
 // src/tui/discovery.ts
 async function listSessions(config, opts = {}, fetchImpl = fetch) {
   const base = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
@@ -2266,6 +2586,8 @@ async function listSessions(config, opts = {}, fetchImpl = fetch) {
     status: s.status ?? "live",
     upstreamSessionId: s.upstreamSessionId,
     agentId: s.agentId,
+    currentModel: s.currentModel,
+    currentUsage: s.currentUsage,
     title: s.title
   }));
 }
@@ -2468,7 +2790,7 @@ async function pickSession(term, opts) {
   };
   renderFromScratch();
   term.hideCursor();
-  return await new Promise((resolve2) => {
+  return await new Promise((resolve5) => {
     let resolved = false;
     const onResize = () => {
       if (resolved) {
@@ -2590,6 +2912,11 @@ async function pickSession(term, opts) {
       }
       clearTransient();
       if (data?.isCharacter) {
+        if (name === "r" || name === "R") {
+          const currentId = selectedIdx > 0 ? visible[selectedIdx - 1]?.sessionId : void 0;
+          void refresh(currentId);
+          return;
+        }
         if ((name === "k" || name === "K") && selectedIdx > 0) {
           const session = visible[selectedIdx - 1];
           if (!session) {
@@ -2650,12 +2977,12 @@ async function pickSession(term, opts) {
         case "KP_ENTER": {
           cleanup();
           if (selectedIdx === 0) {
-            resolve2({ kind: "new" });
+            resolve5({ kind: "new" });
             return;
           }
           const session = visible[selectedIdx - 1];
           if (!session) {
-            resolve2({ kind: "abort" });
+            resolve5({ kind: "abort" });
             return;
           }
           const result = {
@@ -2665,13 +2992,13 @@ async function pickSession(term, opts) {
           if (session.agentId !== void 0) {
             result.agentId = session.agentId;
           }
-          resolve2(result);
+          resolve5(result);
           return;
         }
         case "ESCAPE":
         case "CTRL_C":
           cleanup();
-          resolve2({ kind: "abort" });
+          resolve5({ kind: "abort" });
           return;
       }
     };
@@ -2703,6 +3030,7 @@ var init_picker = __esm({
 });
 
 // src/tui/screen.ts
+import os3 from "os";
 import stringWidth from "string-width";
 import wrapAnsi from "wrap-ansi";
 function formattedLineSig(zone, width, line) {
@@ -2853,6 +3181,12 @@ function wrap(text, width) {
   if (text.length === 0) {
     return [""];
   }
+  if (!NON_ASCII.test(text)) {
+    return wrapAscii(text, width);
+  }
+  return wrapVisible(text, width);
+}
+function wrapAscii(text, width) {
   const out = [];
   let remaining = text;
   while (remaining.length > width) {
@@ -2875,14 +3209,91 @@ function wrap(text, width) {
   out.push(remaining);
   return out;
 }
+function wrapVisible(text, width) {
+  const out = [];
+  const graphemes = [];
+  for (const { segment } of SEGMENTER.segment(text)) {
+    graphemes.push({ seg: segment, w: stringWidth(segment) });
+  }
+  let i = 0;
+  while (i < graphemes.length) {
+    let chunk = "";
+    let chunkW = 0;
+    let lastSpaceI = -1;
+    let chunkAtLastSpace = "";
+    while (i < graphemes.length) {
+      const g = graphemes[i];
+      if (chunkW + g.w > width) {
+        break;
+      }
+      if (g.seg === " ") {
+        lastSpaceI = i;
+        chunkAtLastSpace = chunk;
+      }
+      chunk += g.seg;
+      chunkW += g.w;
+      i += 1;
+    }
+    if (i >= graphemes.length) {
+      out.push(chunk);
+      break;
+    }
+    if (lastSpaceI >= 0) {
+      out.push(chunkAtLastSpace);
+      i = lastSpaceI + 1;
+    } else if (chunk.length === 0) {
+      out.push(graphemes[i].seg);
+      i += 1;
+    } else {
+      out.push(chunk);
+    }
+  }
+  return out;
+}
+function shortenHomePath(p) {
+  const home = os3.homedir();
+  if (!home) {
+    return p;
+  }
+  if (p === home) {
+    return "~";
+  }
+  if (p.startsWith(home + "/")) {
+    return "~" + p.slice(home.length);
+  }
+  return p;
+}
 function truncate(text, max) {
-  if (text.length <= max) {
+  if (max <= 0) {
+    return "";
+  }
+  if (text.length <= max && !NON_ASCII.test(text)) {
+    return text;
+  }
+  const visible = stringWidth(text);
+  if (visible <= max) {
     return text;
   }
   if (max <= 1) {
-    return text.slice(0, max);
+    return takeByWidth(text, max);
+  }
+  return takeByWidth(text, max - 1) + "\u2026";
+}
+function takeByWidth(text, budget) {
+  if (budget <= 0) {
+    return "";
+  }
+  let out = "";
+  let used = 0;
+  for (const { segment } of SEGMENTER.segment(text)) {
+    const w = stringWidth(segment);
+    if (used + w > budget) {
+      break;
+    }
+    out += segment;
+    used += w;
   }
-  return text.slice(0, max - 1) + "\u2026";
+  return out;
 }
 function firstLine2(text) {
   const idx = text.indexOf("\n");
@@ -2930,11 +3341,6 @@ function formatTokens(n) {
   }
   return `${n}`;
 }
-function formatCost(amount, currency) {
-  const sign = currency === "USD" || currency === void 0 ? "$" : "";
-  const decimals = amount >= 1 ? 2 : 4;
-  return `${sign}${amount.toFixed(decimals)}${currency && currency !== "USD" ? ` ${currency}` : ""}`;
-}
 function mapKeyName(name) {
   switch (name) {
     case "ENTER":
@@ -2997,10 +3403,11 @@ function mapKeyName(name) {
       return null;
   }
 }
-var HEADER_ROWS, BANNER_ROWS, SEPARATOR_ROWS, MAX_PROMPT_ROWS, MAX_QUEUED_ROWS, MAX_PERMISSION_ROWS, MAX_COMPLETION_ROWS, CONFIRM_PROMPT_ROWS, DEFAULT_CONTENT_REPAINT_THROTTLE_MS, DEFAULT_MAX_SCROLLBACK_LINES, Screen, shortId;
+var HEADER_ROWS, BANNER_ROWS, SEPARATOR_ROWS, MAX_PROMPT_ROWS, MAX_QUEUED_ROWS, MAX_PERMISSION_ROWS, MAX_COMPLETION_ROWS, CONFIRM_PROMPT_ROWS, DEFAULT_CONTENT_REPAINT_THROTTLE_MS, DEFAULT_MAX_SCROLLBACK_LINES, Screen, NON_ASCII, SEGMENTER, shortId;
 var init_screen = __esm({
   "src/tui/screen.ts"() {
     "use strict";
+    init_agent_display();
     init_session();
     HEADER_ROWS = 2;
     BANNER_ROWS = 1;
@@ -3100,6 +3507,11 @@ var init_screen = __esm({
         }
         this.started = true;
         this.term.fullscreen(true);
+        this.lastFrameRows.clear();
+        this.lastFrameW = 0;
+        this.lastFrameH = 0;
+        this.lastWindowTitle = null;
+        process.stdout.write("\x1B[?7l");
         this.term.grabInput({ mouse: "button" });
         this.term.hideCursor(false);
         this.term.on("key", this.keyHandler);
@@ -3119,6 +3531,7 @@ var init_screen = __esm({
         this.term.off("resize", this.resizeHandler);
         this.term.grabInput(false);
         this.term.hideCursor(false);
+        process.stdout.write("\x1B[?7h");
         this.term.fullscreen(false);
         this.term("\n");
       }
@@ -3430,6 +3843,22 @@ var init_screen = __esm({
       redraw() {
         this.repaint();
       }
+      // Forced clean-slate repaint. Drops the per-row signature cache, the
+      // window-title cache, the wrap cache, and clears the terminal before
+      // painting. Wired to ^L so the user can recover when something has
+      // corrupted the visible state and the per-row sig check otherwise
+      // short-circuits the re-emit.
+      fullRedraw() {
+        this.lastFrameRows.clear();
+        this.lastFrameW = 0;
+        this.lastFrameH = 0;
+        this.lastWindowTitle = null;
+        this.wrapCache.clear();
+        this.wrapCacheWidth = 0;
+        process.stdout.write("\x1B[?7l");
+        this.term.clear();
+        this.repaint();
+      }
       // While paused, append* methods buffer state but don't repaint. Calls are
       // counter-based so they nest safely. Resume triggers exactly one repaint
       // if any was requested while paused.
@@ -3656,22 +4085,23 @@ var init_screen = __esm({
         const usage = formatUsage(this.header.usage);
         const sid = shortId(this.header.sessionId);
         const title = this.header.title?.trim();
-        const sig = `hdr|${w}|${this.header.agent}|${this.header.cwd}|${sid}|${title ?? ""}|${usage ?? ""}`;
+        const agentCell = formatAgentWithModel(this.header.agent, this.header.model);
+        const cwdDisplay = shortenHomePath(this.header.cwd);
+        const sig = `hdr|${w}|${agentCell}|${cwdDisplay}|${sid}|${title ?? ""}|${usage ?? ""}`;
         this.paintRow(1, sig, () => {
-          const fixed = "hydra \xB7 ".length + this.header.agent.length + " \xB7 ".length + " \xB7 ".length + sid.length + (title ? " \xB7 ".length : 0) + (usage ? usage.length + 3 : 0);
+          const fixed = "hydra \xB7 ".length + agentCell.length + " \xB7 ".length + " \xB7 ".length + sid.length + (title ? " \xB7 ".length : 0) + (usage ? usage.length + 3 : 0);
           const variableRoom = Math.max(8, w - fixed);
           let cwdRoom;
           let titleRoom;
           if (title) {
-            const cwdMin = Math.min(this.header.cwd.length, 12);
-            const titleCap = Math.max(8, variableRoom - cwdMin);
-            titleRoom = Math.min(title.length, titleCap);
-            cwdRoom = Math.max(8, variableRoom - titleRoom);
+            const titleMin = Math.min(title.length, 8);
+            cwdRoom = Math.min(cwdDisplay.length, Math.max(8, variableRoom - titleMin));
+            titleRoom = Math.max(0, variableRoom - cwdRoom);
           } else {
             titleRoom = 0;
             cwdRoom = variableRoom;
           }
-          this.term.bold("hydra")(" \xB7 ").cyan.noFormat(this.header.agent)(" \xB7 ").dim.noFormat(truncate(this.header.cwd, cwdRoom))(" \xB7 ").yellow(sid);
+          this.term.bold("hydra")(" \xB7 ").cyan.noFormat(agentCell)(" \xB7 ").dim.noFormat(truncate(cwdDisplay, cwdRoom))(" \xB7 ").yellow(sid);
           if (title) {
             this.term(" \xB7 ").bold.noFormat(truncate(title, titleRoom));
           }
@@ -4083,6 +4513,8 @@ var init_screen = __esm({
         }
       }
     };
+    NON_ASCII = /[^\x20-\x7e]/;
+    SEGMENTER = new Intl.Segmenter(void 0, { granularity: "grapheme" });
     shortId = stripHydraSessionPrefix;
   }
 });
@@ -4457,6 +4889,10 @@ var init_input = __esm({
 });
 
 // src/tui/render-update.ts
+import stripAnsi from "strip-ansi";
+function sanitizeWireText(text) {
+  return stripAnsi(text).replace(STRIP_CONTROLS, "");
+}
 function mapUpdate(update) {
   if (!update || typeof update !== "object") {
     return null;
@@ -4499,11 +4935,30 @@ function mapUpdate(update) {
   }
 }
 function mapSessionInfo(u) {
-  const title = readString(u, "title");
-  if (title === void 0) {
+  const rawTitle = readString(u, "title");
+  const title = rawTitle !== void 0 ? sanitizeWireText(rawTitle) : void 0;
+  const meta = u._meta;
+  let agentId;
+  if (meta && typeof meta === "object" && !Array.isArray(meta)) {
+    const ns = meta["hydra-acp"];
+    if (ns && typeof ns === "object" && !Array.isArray(ns)) {
+      const candidate = ns.agentId;
+      if (typeof candidate === "string") {
+        agentId = candidate;
+      }
+    }
+  }
+  if (title === void 0 && agentId === void 0) {
     return null;
   }
-  return { kind: "session-info", title };
+  const event = { kind: "session-info" };
+  if (title !== void 0) {
+    event.title = title;
+  }
+  if (agentId !== void 0) {
+    event.agentId = agentId;
+  }
+  return event;
 }
 function mapAvailableCommands(u) {
   const list = u.availableCommands ?? u.commands;
@@ -4519,10 +4974,10 @@ function mapAvailableCommands(u) {
     if (typeof c.name !== "string" || c.name.length === 0) {
       continue;
     }
-    const name = c.name.startsWith("/") ? c.name : `/${c.name}`;
-    const cmd = { name };
+    const rawName = c.name.startsWith("/") ? c.name : `/${c.name}`;
+    const cmd = { name: sanitizeWireText(rawName) };
     if (typeof c.description === "string") {
-      cmd.description = c.description;
+      cmd.description = sanitizeWireText(c.description);
     }
     out.push(cmd);
   }
@@ -4555,7 +5010,7 @@ function mapAgentText(u) {
   return { kind: "agent-text", text };
 }
 function mapAgentThought(u) {
-  const text = typeof u.text === "string" ? u.text : extractContentText(u.content);
+  const text = typeof u.text === "string" ? sanitizeWireText(u.text) : extractContentText(u.content);
   if (text === null) {
     return null;
   }
@@ -4587,7 +5042,8 @@ function mapToolCall(u) {
   if (!toolCallId) {
     return null;
   }
-  const title = readString(u, "title") ?? readString(u, "name") ?? readString(u, "label") ?? "tool call";
+  const rawTitle = readString(u, "title") ?? readString(u, "name") ?? readString(u, "label") ?? "tool call";
+  const title = sanitizeWireText(rawTitle);
   const status = readString(u, "status");
   const rawKind = readString(u, "kind");
   const event = { kind: "tool-call", toolCallId, title };
@@ -4604,7 +5060,8 @@ function mapToolCallUpdate(u) {
   if (!toolCallId) {
     return null;
   }
-  const title = readString(u, "title");
+  const rawTitle = readString(u, "title");
+  const title = rawTitle !== void 0 ? sanitizeWireText(rawTitle) : void 0;
   const status = readString(u, "status");
   const meaningful = title !== void 0 || status === "completed" || status === "failed" || status === "rejected" || status === "cancelled";
   if (!meaningful) {
@@ -4630,7 +5087,7 @@ function mapPlan(u) {
       continue;
     }
     const e = raw;
-    const content = typeof e.content === "string" ? e.content : void 0;
+    const content = typeof e.content === "string" ? sanitizeWireText(e.content) : void 0;
     if (!content) {
       continue;
     }
@@ -4650,14 +5107,14 @@ function mapMode(u) {
   if (!mode) {
     return null;
   }
-  return { kind: "mode-changed", mode };
+  return { kind: "mode-changed", mode: sanitizeWireText(mode) };
 }
 function mapModel(u) {
   const model = readString(u, "currentModel") ?? readString(u, "model");
   if (!model) {
     return null;
   }
-  return { kind: "model-changed", model };
+  return { kind: "model-changed", model: sanitizeWireText(model) };
 }
 function mapTurnComplete(u) {
   const stopReason = readString(u, "stopReason");
@@ -4665,17 +5122,17 @@ function mapTurnComplete(u) {
 }
 function extractContentText(content) {
   if (typeof content === "string") {
-    return content;
+    return sanitizeWireText(content);
   }
   if (!content || typeof content !== "object") {
     return null;
   }
   const c = content;
   if (c.type === "text" && typeof c.text === "string") {
-    return c.text;
+    return sanitizeWireText(c.text);
   }
   if (typeof c.text === "string") {
-    return c.text;
+    return sanitizeWireText(c.text);
   }
   return null;
 }
@@ -4699,9 +5156,11 @@ function readString(u, key) {
   const v = u[key];
   return typeof v === "string" ? v : void 0;
 }
+var STRIP_CONTROLS;
 var init_render_update = __esm({
   "src/tui/render-update.ts"() {
     "use strict";
+    STRIP_CONTROLS = /[\x00-\x08\x0b-\x1f\x7f]/g;
   }
 });
 
@@ -4907,8 +5366,9 @@ function formatToolLine(state) {
     title = `${initial} \xB7 ${latest}`;
   }
   return {
-    prefix: "  ",
-    body: `${toolStatusIcon(state.status)} ${title}`,
+    prefix: `  ${toolStatusIcon(state.status)} `,
+    prefixStyle: toolIconStyle(state.status),
+    body: title,
     bodyStyle: toolStatusStyle(state.status)
   };
 }
@@ -4933,6 +5393,22 @@ function toolStatusIcon(status) {
       return "\u25D0";
   }
 }
+function toolIconStyle(status) {
+  switch (status) {
+    case "completed":
+    case "succeeded":
+    case "ok":
+      return "tool-status-ok";
+    case "failed":
+    case "error":
+    case "rejected":
+      return "tool-status-fail";
+    case "cancelled":
+      return "tool-status-cancelled";
+    default:
+      return "tool-status-running";
+  }
+}
 function formatPlan(event) {
   if (event.entries.length === 0) {
     return [
@@ -5019,12 +5495,18 @@ async function runTuiApp(opts) {
   const config = await ensureConfig();
   await ensureDaemonReachable(config);
   const term = termkit.terminal;
+  const exitHint = {};
   let nextOpts = opts;
   while (nextOpts !== null) {
-    nextOpts = await runSession(term, config, nextOpts);
+    nextOpts = await runSession(term, config, nextOpts, exitHint);
+  }
+  if (exitHint.sessionId) {
+    const short = stripHydraSessionPrefix(exitHint.sessionId);
+    process.stdout.write(`To resume: hydra-acp tui --resume ${short}
+`);
   }
 }
-async function runSession(term, config, opts) {
+async function runSession(term, config, opts, exitHint) {
   const ctx = await resolveSession(term, config, opts);
   if (!ctx) {
     term.grabInput(false);
@@ -5132,10 +5614,10 @@ async function runSession(term, config, opts) {
     if (pendingPermission.toolCallId && toolCallId && pendingPermission.toolCallId !== toolCallId) {
       return;
     }
-    const resolve2 = pendingPermission.resolve;
+    const resolve5 = pendingPermission.resolve;
     pendingPermission = null;
     screen.setPermissionPrompt(null);
-    resolve2(result ?? { outcome: { outcome: "cancelled" } });
+    resolve5(result ?? { outcome: { outcome: "cancelled" } });
   };
   const maybeDismissPermissionByToolUpdate = (update) => {
     if (!pendingPermission?.toolCallId) {
@@ -5168,20 +5650,26 @@ async function runSession(term, config, opts) {
     if (!pendingPermission) {
       return;
     }
-    const { options, resolve: resolve2 } = pendingPermission;
+    const { options, resolve: resolve5 } = pendingPermission;
     pendingPermission = null;
     screen.setPermissionPrompt(null);
     if (optionId === null) {
-      resolve2({ outcome: { outcome: "cancelled" } });
+      resolve5({ outcome: { outcome: "cancelled" } });
       return;
     }
-    resolve2({ outcome: { outcome: "selected", optionId } });
+    resolve5({ outcome: { outcome: "selected", optionId } });
     void options;
   };
   conn.onRequest("session/request_permission", async (params) => {
     const p = params ?? {};
-    const options = Array.isArray(p.options) ? p.options : [];
-    const title = p.toolCall?.title ?? p.toolCall?.name ?? "tool";
+    const rawOptions = Array.isArray(p.options) ? p.options : [];
+    const options = rawOptions.map((o) => ({
+      optionId: o.optionId,
+      name: sanitizeWireText(o.name ?? ""),
+      ...o.kind !== void 0 ? { kind: o.kind } : {}
+    }));
+    const rawTitle = p.toolCall?.title ?? p.toolCall?.name ?? "tool";
+    const title = sanitizeWireText(rawTitle);
     const toolCallId = p.toolCall?.toolCallId;
     if (options.length === 0) {
       screen.appendLines([
@@ -5193,12 +5681,12 @@ async function runSession(term, config, opts) {
       ]);
       return { outcome: { outcome: "cancelled" } };
     }
-    return new Promise((resolve2) => {
+    return new Promise((resolve5) => {
       pendingPermission = {
         title,
         options,
         selectedIndex: 0,
-        resolve: resolve2,
+        resolve: resolve5,
         toolCallId
       };
       refreshPermissionPrompt();
@@ -5236,6 +5724,7 @@ async function runSession(term, config, opts) {
       ...opts.name ? { _meta: { [HYDRA_META_KEY]: { name: opts.name } } } : {}
     });
     resolvedSessionId = created.sessionId;
+    exitHint.sessionId = resolvedSessionId;
     const hydraMeta = extractHydraMeta(created._meta ?? void 0);
     upstreamSessionId = hydraMeta.upstreamSessionId;
     if (hydraMeta.agentId) {
@@ -5262,6 +5751,7 @@ async function runSession(term, config, opts) {
       clientInfo: { name: "hydra-acp-tui", version: "0.1.0" }
     });
     resolvedSessionId = attached.sessionId;
+    exitHint.sessionId = resolvedSessionId;
     const hydraMeta = extractHydraMeta(attached._meta ?? void 0);
     upstreamSessionId = hydraMeta.upstreamSessionId;
     if (hydraMeta.agentId) {
@@ -5449,17 +5939,15 @@ async function runSession(term, config, opts) {
     agent: headerName,
     cwd: resolvedCwd,
     sessionId: resolvedSessionId,
-    title: resolvedTitle
+    title: resolvedTitle,
+    model: initialModel
   });
   if (initialMode) {
     screen.appendLines(formatEvent({ kind: "mode-changed", mode: initialMode }));
   }
-  if (initialModel) {
-    screen.appendLines(formatEvent({ kind: "model-changed", model: initialModel }));
-  }
   let finishSession = null;
-  const sessionDone = new Promise((resolve2) => {
-    finishSession = resolve2;
+  const sessionDone = new Promise((resolve5) => {
+    finishSession = resolve5;
   });
   const cancelRemoteTurn = () => {
     conn.notify("session/cancel", { sessionId: resolvedSessionId }).catch(() => void 0);
@@ -5631,7 +6119,7 @@ async function runSession(term, config, opts) {
         screen.setBanner({});
         return;
       case "redraw":
-        screen.redraw();
+        screen.fullRedraw();
         return;
       case "switch-session":
         void switchSession();
@@ -5957,6 +6445,10 @@ async function runSession(term, config, opts) {
       if (event.title !== void 0) {
         screen.setHeader({ title: event.title });
       }
+      if (event.agentId !== void 0 && event.agentId !== resolvedAgentId) {
+        resolvedAgentId = event.agentId;
+        screen.setHeader({ agent: event.agentId });
+      }
       return;
     }
     if (event.kind === "usage-update") {
@@ -6028,6 +6520,9 @@ async function runSession(term, config, opts) {
       renderToolsBlock();
       return;
     }
+    if (event.kind === "model-changed") {
+      screen.setHeader({ model: event.model });
+    }
     const formatted = formatEvent(event);
     if (formatted.length > 0) {
       screen.appendLines(formatted);
@@ -6077,10 +6572,10 @@ async function runSession(term, config, opts) {
   }
   const resetInFlightUiState = () => {
     if (pendingPermission) {
-      const resolve2 = pendingPermission.resolve;
+      const resolve5 = pendingPermission.resolve;
       pendingPermission = null;
       screen.setPermissionPrompt(null);
-      resolve2({ outcome: { outcome: "cancelled" } });
+      resolve5({ outcome: { outcome: "cancelled" } });
     }
     closeAgentText();
     if (toolsBlockStartedAt !== null) {
@@ -6268,6 +6763,7 @@ var init_app = __esm({
     init_resilient_ws();
     init_config();
     init_daemon_bootstrap();
+    init_session();
     init_paths();
     init_history();
     init_discovery();
@@ -6293,6 +6789,11 @@ var init_tui = __esm({
   }
 });
 
+// src/cli.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname4, resolve as resolve4 } from "path";
+
 // src/cli/parse-args.ts
 function parseArgs(argv) {
   const positional = [];
@@ -6362,8 +6863,7 @@ async function runInit(flags) {
     existing = void 0;
   }
   if (!existing) {
-    const config = defaultConfig();
-    await writeConfig(config);
+    const config = await writeMinimalInitConfig();
     process.stdout.write(
       `Initialized ${paths.config()}
 Auth token: ${config.daemon.authToken}
@@ -6372,11 +6872,14 @@ Auth token: ${config.daemon.authToken}
     return;
   }
   if (flagBool(flags, "rotate-token")) {
-    existing.daemon.authToken = generateAuthToken();
-    await writeConfig(existing);
+    const newToken = generateAuthToken();
+    await updateConfigField((raw) => {
+      const daemon = raw.daemon ??= {};
+      daemon.authToken = newToken;
+    });
     process.stdout.write(
       `Rotated token in ${paths.config()}
-New token: ${existing.daemon.authToken}
+New token: ${newToken}
 `
     );
     return;
@@ -6389,13 +6892,13 @@ New token: ${existing.daemon.authToken}
 // src/cli/commands/daemon.ts
 init_paths();
 init_config();
-import * as fsp4 from "fs/promises";
+import * as fsp5 from "fs/promises";
 import { setTimeout as sleep2 } from "timers/promises";
 
 // src/daemon/server.ts
 init_config();
-import * as fs8 from "fs";
-import * as fsp2 from "fs/promises";
+import * as fs10 from "fs";
+import * as fsp3 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
 import pino from "pino";
@@ -6403,8 +6906,214 @@ import createPinoRoll from "pino-roll";
 
 // src/core/registry.ts
 init_paths();
-import * as fs3 from "fs/promises";
+import * as fs4 from "fs/promises";
 import { z as z2 } from "zod";
+
+// src/core/binary-install.ts
+init_paths();
+import * as fs3 from "fs";
+import * as fsp from "fs/promises";
+import * as path2 from "path";
+import { spawn } from "child_process";
+import { Readable } from "stream";
+function currentPlatformKey() {
+  const osPart = process.platform === "darwin" ? "darwin" : process.platform === "linux" ? "linux" : process.platform === "win32" ? "windows" : void 0;
+  const archPart = process.arch === "arm64" ? "aarch64" : process.arch === "x64" ? "x86_64" : void 0;
+  if (!osPart || !archPart) {
+    return void 0;
+  }
+  return `${osPart}-${archPart}`;
+}
+function pickBinaryTarget(distribution, platformKey = currentPlatformKey()) {
+  if (!platformKey) {
+    return void 0;
+  }
+  return distribution[platformKey];
+}
+var logSink = (msg) => {
+  process.stderr.write(msg + "\n");
+};
+function setBinaryInstallLogger(log) {
+  logSink = log ?? ((msg) => process.stderr.write(msg + "\n"));
+}
+async function ensureBinary(args) {
+  if (!args.target.archive) {
+    throw new Error(
+      `Agent ${args.agentId} has no archive URL for ${currentPlatformKey() ?? "this platform"}`
+    );
+  }
+  if (!args.target.cmd) {
+    throw new Error(`Agent ${args.agentId} has no cmd in its binary target`);
+  }
+  const platformKey = currentPlatformKey();
+  if (!platformKey) {
+    throw new Error(
+      `Agent ${args.agentId}: cannot determine platform key for ${process.platform}/${process.arch}`
+    );
+  }
+  const installDir = paths.agentInstallDir(
+    args.agentId,
+    platformKey,
+    args.version
+  );
+  const cmdPath = path2.resolve(installDir, args.target.cmd);
+  if (await fileExists(cmdPath)) {
+    return cmdPath;
+  }
+  await downloadAndExtract({
+    agentId: args.agentId,
+    archiveUrl: args.target.archive,
+    installDir
+  });
+  if (!await fileExists(cmdPath)) {
+    throw new Error(
+      `Agent ${args.agentId}: extracted archive did not contain ${args.target.cmd} (looked in ${installDir})`
+    );
+  }
+  if (process.platform !== "win32") {
+    await fsp.chmod(cmdPath, 493).catch(() => void 0);
+  }
+  return cmdPath;
+}
+async function downloadAndExtract(args) {
+  await fsp.mkdir(path2.dirname(args.installDir), { recursive: true });
+  const tempDir = await fsp.mkdtemp(`${args.installDir}.partial-`);
+  try {
+    logSink(`hydra-acp: downloading ${args.agentId} from ${args.archiveUrl}`);
+    const archivePath = await downloadTo({
+      url: args.archiveUrl,
+      dir: tempDir,
+      agentId: args.agentId
+    });
+    logSink(`hydra-acp: extracting ${args.agentId}`);
+    await extract(archivePath, tempDir);
+    await fsp.unlink(archivePath).catch(() => void 0);
+    try {
+      await fsp.rename(tempDir, args.installDir);
+    } catch (err) {
+      const e = err;
+      if ((e.code === "EEXIST" || e.code === "ENOTEMPTY") && await fileExists(args.installDir)) {
+        await fsp.rm(tempDir, { recursive: true, force: true }).catch(
+          () => void 0
+        );
+        return;
+      }
+      throw err;
+    }
+    logSink(`hydra-acp: installed ${args.agentId} to ${args.installDir}`);
+  } catch (err) {
+    await fsp.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
+    throw err;
+  }
+}
+async function downloadTo(args) {
+  const filename = inferArchiveName(args.url);
+  const dest = path2.join(args.dir, filename);
+  const response = await fetch(args.url, { redirect: "follow" });
+  if (!response.ok || !response.body) {
+    throw new Error(
+      `Failed to download ${args.url}: HTTP ${response.status} ${response.statusText}`
+    );
+  }
+  const total = Number(response.headers.get("content-length") ?? "0");
+  const out = fs3.createWriteStream(dest);
+  const nodeStream = Readable.fromWeb(response.body);
+  let received = 0;
+  let lastEmit = Date.now();
+  const EMIT_INTERVAL_MS = 2e3;
+  nodeStream.on("data", (chunk) => {
+    received += chunk.length;
+    const now = Date.now();
+    if (now - lastEmit < EMIT_INTERVAL_MS) {
+      return;
+    }
+    lastEmit = now;
+    logSink(formatProgress(args.agentId, received, total));
+  });
+  await new Promise((resolve5, reject) => {
+    nodeStream.on("error", reject);
+    out.on("error", reject);
+    out.on("finish", () => resolve5());
+    nodeStream.pipe(out);
+  });
+  logSink(formatProgress(
+    args.agentId,
+    received,
+    total,
+    /* done */
+    true
+  ));
+  return dest;
+}
+function formatProgress(agentId, received, total, done = false) {
+  const rxMb = (received / 1e6).toFixed(1);
+  if (total > 0) {
+    const totalMb = (total / 1e6).toFixed(1);
+    const pct = Math.min(100, Math.floor(received / total * 100));
+    const tag2 = done ? "downloaded" : "downloading";
+    return `hydra-acp: ${tag2} ${agentId} ${rxMb}/${totalMb} MB (${pct}%)`;
+  }
+  const tag = done ? "downloaded" : "downloading";
+  return `hydra-acp: ${tag} ${agentId} ${rxMb} MB`;
+}
+function inferArchiveName(url) {
+  const u = new URL(url);
+  const base = path2.posix.basename(u.pathname);
+  return base || "archive";
+}
+async function extract(archivePath, dest) {
+  const lower = archivePath.toLowerCase();
+  if (lower.endsWith(".tar.gz") || lower.endsWith(".tgz") || lower.endsWith(".tar")) {
+    await run("tar", ["-xf", archivePath, "-C", dest]);
+    return;
+  }
+  if (lower.endsWith(".zip")) {
+    if (await hasCommand("unzip")) {
+      await run("unzip", ["-q", archivePath, "-d", dest]);
+      return;
+    }
+    await run("tar", ["-xf", archivePath, "-C", dest]);
+    return;
+  }
+  throw new Error(`Unsupported archive format: ${archivePath}`);
+}
+function run(cmd, args) {
+  return new Promise((resolve5, reject) => {
+    const child = spawn(cmd, args, {
+      stdio: ["ignore", "ignore", "inherit"]
+    });
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      if (code === 0) {
+        resolve5();
+        return;
+      }
+      reject(
+        new Error(
+          `${cmd} ${args.join(" ")} exited with ${code !== null ? `code ${code}` : `signal ${signal}`}`
+        )
+      );
+    });
+  });
+}
+async function hasCommand(name) {
+  return new Promise((resolve5) => {
+    const finder = process.platform === "win32" ? "where" : "which";
+    const child = spawn(finder, [name], { stdio: "ignore" });
+    child.on("error", () => resolve5(false));
+    child.on("exit", (code) => resolve5(code === 0));
+  });
+}
+async function fileExists(p) {
+  try {
+    await fsp.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/registry.ts
 var NpxDistribution = z2.object({
   package: z2.string(),
   args: z2.array(z2.string()).optional(),
@@ -6412,7 +7121,9 @@ var NpxDistribution = z2.object({
 });
 var BinaryTarget = z2.object({
   archive: z2.string().url().optional(),
-  cmd: z2.string().optional()
+  cmd: z2.string().optional(),
+  args: z2.array(z2.string()).optional(),
+  env: z2.record(z2.string()).optional()
 });
 var BinaryDistribution = z2.object({
   "darwin-aarch64": BinaryTarget.optional(),
@@ -6501,34 +7212,59 @@ var Registry = class {
     if (!response.ok) {
       throw new Error(`Registry fetch failed: HTTP ${response.status}`);
     }
-    const json = await response.json();
-    const data = RegistryDocument.parse(json);
-    return { fetchedAt: Date.now(), data };
+    const raw = await response.json();
+    const data = RegistryDocument.parse(raw);
+    return { fetchedAt: Date.now(), raw, data };
   }
   async readDiskCache() {
+    let text;
     try {
-      const raw = await fs3.readFile(paths.registryCache(), "utf8");
-      const parsed = JSON.parse(raw);
-      if (typeof parsed.fetchedAt === "number" && parsed.data && Array.isArray(parsed.data.agents)) {
-        return parsed;
-      }
+      text = await fs4.readFile(paths.registryCache(), "utf8");
     } catch (err) {
       const e = err;
-      if (e.code !== "ENOENT") {
-        throw err;
+      if (e.code === "ENOENT") {
+        return void 0;
       }
+      throw err;
+    }
+    try {
+      const parsed = JSON.parse(text);
+      if (typeof parsed.fetchedAt !== "number" || parsed.data === void 0) {
+        return void 0;
+      }
+      const data = RegistryDocument.parse(parsed.data);
+      return { fetchedAt: parsed.fetchedAt, raw: parsed.data, data };
+    } catch {
+      return void 0;
     }
-    return void 0;
   }
+  // Atomic write: dump to a sibling temp path, then rename onto the
+  // target. POSIX rename is atomic within a filesystem, so readers
+  // either see the old file or the fully-written new file — never a
+  // truncated middle. This also makes simultaneous writers safe
+  // without a lock file: the loser of the rename race just gets its
+  // version replaced by the winner's.
   async writeDiskCache(cache) {
-    await fs3.mkdir(paths.home(), { recursive: true });
-    await fs3.writeFile(
-      paths.registryCache(),
-      JSON.stringify(cache, null, 2) + "\n",
-      "utf8"
-    );
+    await fs4.mkdir(paths.home(), { recursive: true });
+    const final = paths.registryCache();
+    const tmp = `${final}.tmp-${process.pid}-${randSuffix()}`;
+    const body = JSON.stringify(
+      { fetchedAt: cache.fetchedAt, data: cache.raw },
+      null,
+      2
+    ) + "\n";
+    try {
+      await fs4.writeFile(tmp, body, "utf8");
+      await fs4.rename(tmp, final);
+    } catch (err) {
+      await fs4.unlink(tmp).catch(() => void 0);
+      throw err;
+    }
   }
 };
+function randSuffix() {
+  return Math.random().toString(36).slice(2, 10);
+}
 function npxPackageBasename(agent) {
   const pkg = agent.distribution.npx?.package;
   if (!pkg) {
@@ -6539,7 +7275,7 @@ function npxPackageBasename(agent) {
   const atIdx = afterSlash.lastIndexOf("@");
   return atIdx <= 0 ? afterSlash : afterSlash.slice(0, atIdx);
 }
-function planSpawn(agent, extraArgs = []) {
+async function planSpawn(agent, extraArgs = []) {
   if (agent.distribution.npx) {
     const npx = agent.distribution.npx;
     const args = ["-y", npx.package, ...npx.args ?? [], ...extraArgs];
@@ -6550,9 +7286,22 @@ function planSpawn(agent, extraArgs = []) {
     };
   }
   if (agent.distribution.binary) {
-    throw new Error(
-      `Agent ${agent.id} uses binary distribution; not yet supported in hydra-acp. PRs welcome.`
-    );
+    const target = pickBinaryTarget(agent.distribution.binary);
+    if (!target) {
+      throw new Error(
+        `Agent ${agent.id} has no binary distribution for ${currentPlatformKey() ?? "this platform"}.`
+      );
+    }
+    const cmdPath = await ensureBinary({
+      agentId: agent.id,
+      version: agent.version ?? "current",
+      target
+    });
+    return {
+      command: cmdPath,
+      args: [...target.args ?? [], ...extraArgs],
+      env: target.env ?? {}
+    };
   }
   if (agent.distribution.uvx) {
     const uvx = agent.distribution.uvx;
@@ -6567,10 +7316,11 @@ function planSpawn(agent, extraArgs = []) {
 }
 
 // src/core/session-manager.ts
-import * as fs6 from "fs/promises";
+import * as fs8 from "fs/promises";
+import { customAlphabet as customAlphabet3 } from "nanoid";
 
 // src/core/agent-instance.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 
 // src/acp/framing.ts
 init_types();
@@ -6626,13 +7376,13 @@ function ndjsonStreamFromStdio(stdout, stdin) {
         throw new Error("stream is closed");
       }
       const line = JSON.stringify(message) + "\n";
-      await new Promise((resolve2, reject) => {
+      await new Promise((resolve5, reject) => {
         stdin.write(line, (err) => {
           if (err) {
             reject(err);
             return;
           }
-          resolve2();
+          resolve5();
         });
       });
     },
@@ -6684,7 +7434,7 @@ var AgentInstance = class _AgentInstance {
       ...opts.plan.env,
       ...opts.extraEnv ?? {}
     };
-    const child = spawn(opts.plan.command, opts.plan.args, {
+    const child = spawn2(opts.plan.command, opts.plan.args, {
       cwd: opts.cwd,
       env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -6711,17 +7461,43 @@ init_session();
 
 // src/core/session-store.ts
 init_paths();
-import * as fs4 from "fs/promises";
-import * as path2 from "path";
+import * as fs5 from "fs/promises";
+import * as path3 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()
 });
+var PersistedUsage = z4.object({
+  used: z4.number().optional(),
+  size: z4.number().optional(),
+  costAmount: z4.number().optional(),
+  costCurrency: z4.string().optional()
+});
 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(),
@@ -6732,6 +7508,7 @@ var SessionRecord = z4.object({
   // replay of a snapshot-shaped notification.
   currentModel: z4.string().optional(),
   currentMode: z4.string().optional(),
+  currentUsage: PersistedUsage.optional(),
   agentCommands: z4.array(PersistedAgentCommand).optional(),
   createdAt: z4.string(),
   updatedAt: z4.string()
@@ -6745,9 +7522,9 @@ function assertSafeId(id) {
 var SessionStore = class {
   async write(record) {
     assertSafeId(record.sessionId);
-    await fs4.mkdir(paths.sessionDir(record.sessionId), { recursive: true });
+    await fs5.mkdir(paths.sessionDir(record.sessionId), { recursive: true });
     const full = { version: 1, ...record };
-    await fs4.writeFile(
+    await fs5.writeFile(
       paths.sessionFile(record.sessionId),
       JSON.stringify(full, null, 2) + "\n",
       { encoding: "utf8", mode: 384 }
@@ -6759,7 +7536,7 @@ var SessionStore = class {
     }
     let raw;
     try {
-      raw = await fs4.readFile(paths.sessionFile(sessionId), "utf8");
+      raw = await fs5.readFile(paths.sessionFile(sessionId), "utf8");
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -6778,7 +7555,7 @@ var SessionStore = class {
       return;
     }
     try {
-      await fs4.unlink(paths.sessionFile(sessionId));
+      await fs5.unlink(paths.sessionFile(sessionId));
     } catch (err) {
       const e = err;
       if (e.code !== "ENOENT") {
@@ -6786,7 +7563,7 @@ var SessionStore = class {
       }
     }
     try {
-      await fs4.rmdir(paths.sessionDir(sessionId));
+      await fs5.rmdir(paths.sessionDir(sessionId));
     } catch (err) {
       const e = err;
       if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
@@ -6794,10 +7571,29 @@ 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 {
-      entries = await fs4.readdir(paths.sessionsDir());
+      entries = await fs5.readdir(paths.sessionsDir());
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -6819,13 +7615,16 @@ 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,
     agentArgs: args.agentArgs,
     currentModel: args.currentModel,
     currentMode: args.currentMode,
+    currentUsage: args.currentUsage,
     agentCommands: args.agentCommands,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
@@ -6834,7 +7633,7 @@ function recordFromMemorySession(args) {
 
 // src/core/history-store.ts
 init_paths();
-import * as fs5 from "fs/promises";
+import * as fs6 from "fs/promises";
 var SESSION_ID_PATTERN2 = /^[A-Za-z0-9_-]+$/;
 var MAX_ENTRIES = 1e3;
 var HistoryStore = class {
@@ -6847,9 +7646,9 @@ var HistoryStore = class {
       return;
     }
     return this.enqueue(sessionId, async () => {
-      await fs5.mkdir(paths.sessionDir(sessionId), { recursive: true });
+      await fs6.mkdir(paths.sessionDir(sessionId), { recursive: true });
       const line = JSON.stringify(entry) + "\n";
-      await fs5.appendFile(paths.historyFile(sessionId), line, {
+      await fs6.appendFile(paths.historyFile(sessionId), line, {
         encoding: "utf8",
         mode: 384
       });
@@ -6860,9 +7659,39 @@ var HistoryStore = class {
       return;
     }
     return this.enqueue(sessionId, async () => {
-      await fs5.mkdir(paths.sessionDir(sessionId), { recursive: true });
+      await fs6.mkdir(paths.sessionDir(sessionId), { recursive: true });
       const body = entries.length === 0 ? "" : entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-      await fs5.writeFile(paths.historyFile(sessionId), body, {
+      await fs6.writeFile(paths.historyFile(sessionId), body, {
+        encoding: "utf8",
+        mode: 384
+      });
+    });
+  }
+  // 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 fs6.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 fs6.writeFile(paths.historyFile(sessionId), trimmed.join("\n") + "\n", {
         encoding: "utf8",
         mode: 384
       });
@@ -6878,7 +7707,7 @@ var HistoryStore = class {
     }
     let raw;
     try {
-      raw = await fs5.readFile(paths.historyFile(sessionId), "utf8");
+      raw = await fs6.readFile(paths.historyFile(sessionId), "utf8");
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -6924,7 +7753,7 @@ var HistoryStore = class {
     }
     return this.enqueue(sessionId, async () => {
       try {
-        await fs5.unlink(paths.historyFile(sessionId));
+        await fs6.unlink(paths.historyFile(sessionId));
       } catch (err) {
         const e = err;
         if (e.code !== "ENOENT") {
@@ -6932,7 +7761,7 @@ var HistoryStore = class {
         }
       }
       try {
-        await fs5.rmdir(paths.sessionDir(sessionId));
+        await fs6.rmdir(paths.sessionDir(sessionId));
       } catch (err) {
         const e = err;
         if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
@@ -6957,7 +7786,10 @@ var HistoryStore = class {
 
 // src/core/session-manager.ts
 init_paths();
+init_history();
 init_types();
+var HYDRA_ID_ALPHABET3 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var generateRawSessionId = customAlphabet3(HYDRA_ID_ALPHABET3, 16);
 var SessionManager = class {
   constructor(registry, spawner, store, options = {}) {
     this.registry = registry;
@@ -6965,6 +7797,7 @@ var SessionManager = class {
     this.store = store ?? new SessionStore();
     this.histories = new HistoryStore();
     this.idleTimeoutMs = options.idleTimeoutMs ?? 0;
+    this.defaultModels = options.defaultModels ?? {};
   }
   registry;
   sessions = /* @__PURE__ */ new Map();
@@ -6973,6 +7806,7 @@ var SessionManager = class {
   store;
   histories;
   idleTimeoutMs;
+  defaultModels;
   // 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.
@@ -6994,7 +7828,8 @@ var SessionManager = class {
       agentArgs: params.agentArgs,
       idleTimeoutMs: this.idleTimeoutMs,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
-      historyStore: this.histories
+      historyStore: this.histories,
+      currentModel: fresh.initialModel
     });
     await this.attachManagerHooks(session);
     return session;
@@ -7036,7 +7871,10 @@ var SessionManager = class {
       err.code = JsonRpcErrorCodes.AgentNotInstalled;
       throw err;
     }
-    const plan = planSpawn(agentDef, params.agentArgs ?? []);
+    if (params.upstreamSessionId === "") {
+      return this.doResurrectFromImport(params);
+    }
+    const plan = await planSpawn(agentDef, params.agentArgs ?? []);
     const agent = this.spawner({
       agentId: params.agentId,
       cwd: params.cwd,
@@ -7049,11 +7887,14 @@ var SessionManager = class {
     });
     let loadResult;
     try {
-      loadResult = await agent.connection.request("session/load", {
-        sessionId: params.upstreamSessionId,
-        cwd: params.cwd,
-        mcpServers: []
-      });
+      loadResult = await agent.connection.request(
+        "session/load",
+        {
+          sessionId: params.upstreamSessionId,
+          cwd: params.cwd,
+          mcpServers: []
+        }
+      );
     } catch (err) {
       await agent.kill().catch(() => void 0);
       throw new Error(
@@ -7072,17 +7913,65 @@ var SessionManager = class {
       idleTimeoutMs: this.idleTimeoutMs,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       historyStore: this.histories,
-      seedHistory: params.seedHistory,
-      currentModel: params.currentModel,
+      // Prefer what we previously stored from a current_model_update; if
+      // we never captured one (e.g. old opencode sessions on disk before
+      // this fix), fall back to the model the agent ships in its
+      // session/load response body.
+      currentModel: params.currentModel ?? extractInitialModel(loadResult ?? {}),
+      currentMode: params.currentMode,
+      currentUsage: params.currentUsage,
+      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,
+      // Prefer the stored value (set by a previous current_model_update);
+      // fall back to whatever the agent ships in its session/new response.
+      currentModel: params.currentModel ?? fresh.initialModel,
       currentMode: params.currentMode,
+      currentUsage: params.currentUsage,
       agentCommands: params.agentCommands,
-      firstPromptSeeded: true
+      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
-  // → session/new. Shared by create() and the /hydra switch path so both
+  // → session/new. Shared by create() and the /hydra agent path so both
   // go through the same env / capabilities / error-handling.
   async bootstrapAgent(params) {
     const agentDef = await this.registry.getAgent(params.agentId);
@@ -7093,7 +7982,7 @@ var SessionManager = class {
       err.code = JsonRpcErrorCodes.AgentNotInstalled;
       throw err;
     }
-    const plan = planSpawn(agentDef, params.agentArgs ?? []);
+    const plan = await planSpawn(agentDef, params.agentArgs ?? []);
     const agent = this.spawner({
       agentId: params.agentId,
       cwd: params.cwd,
@@ -7105,14 +7994,36 @@ var SessionManager = class {
         clientCapabilities: {},
         clientInfo: { name: "hydra", version: "0.1.0" }
       });
-      const newResult = await agent.connection.request("session/new", {
-        cwd: params.cwd,
-        mcpServers: params.mcpServers ?? []
-      });
+      const newResult = await agent.connection.request(
+        "session/new",
+        {
+          cwd: params.cwd,
+          mcpServers: params.mcpServers ?? []
+        }
+      );
+      const sessionIdRaw = newResult.sessionId;
+      if (typeof sessionIdRaw !== "string") {
+        throw new Error(
+          `agent ${params.agentId} returned a non-string sessionId from session/new`
+        );
+      }
+      let initialModel = extractInitialModel(newResult);
+      const desired = this.defaultModels[params.agentId];
+      if (desired && desired !== initialModel) {
+        try {
+          await agent.connection.request("session/set_model", {
+            sessionId: sessionIdRaw,
+            modelId: desired
+          });
+          initialModel = desired;
+        } catch {
+        }
+      }
       return {
         agent,
-        upstreamSessionId: newResult.sessionId,
-        agentMeta: newResult._meta
+        upstreamSessionId: sessionIdRaw,
+        agentMeta: newResult._meta,
+        initialModel
       };
     } catch (err) {
       await agent.kill().catch(() => void 0);
@@ -7123,7 +8034,7 @@ var SessionManager = class {
   // bookkeeping. Called from both create() and resurrect() so the same
   // session record + lifecycle handlers are wired regardless of origin.
   // Returns once the initial disk record is written — callers should
-  // await so a subsequent /hydra switch's persistAgentChange (which
+  // await so a subsequent /hydra agent's persistAgentChange (which
   // does read-then-write) finds the file in place.
   async attachManagerHooks(session) {
     session.onClose(({ deleteRecord }) => {
@@ -7151,6 +8062,11 @@ var SessionManager = class {
         () => void 0
       );
     });
+    session.onUsageChange((usage) => {
+      void this.persistSnapshot(session.sessionId, {
+        currentUsage: usageSnapshotToPersisted(usage)
+      }).catch(() => void 0);
+    });
     session.onAgentCommandsChange((commands) => {
       void this.persistSnapshot(session.sessionId, {
         agentCommands: commands.map((c) => ({
@@ -7160,28 +8076,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) {
@@ -7194,20 +8102,42 @@ 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
+      currentUsage: persistedUsageToSnapshot(record.currentUsage),
+      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);
   }
@@ -7254,6 +8184,8 @@ var SessionManager = class {
         cwd: session.cwd,
         title: session.title,
         agentId: session.agentId,
+        currentModel: session.currentModel,
+        currentUsage: session.currentUsage,
         updatedAt: used,
         attachedClients: session.attachedCount,
         status: "live"
@@ -7274,6 +8206,8 @@ var SessionManager = class {
         cwd: r.cwd,
         title: r.title,
         agentId: r.agentId,
+        currentModel: r.currentModel,
+        currentUsage: r.currentUsage,
         updatedAt: used,
         attachedClients: 0,
         status: "cold"
@@ -7282,6 +8216,112 @@ 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,
+        currentUsage: args.bundle.session.currentUsage,
+        agentCommands: args.bundle.session.agentCommands,
+        createdAt: args.preservedCreatedAt ?? now,
+        updatedAt: now
+      });
+    });
+  }
   async deleteRecord(sessionId) {
     const record = await this.store.read(sessionId);
     if (!record) {
@@ -7311,7 +8351,7 @@ var SessionManager = class {
       });
     });
   }
-  // Persist an agent swap from /hydra switch. The on-disk record's
+  // Persist an agent swap from /hydra agent. The on-disk record's
   // agentId + upstreamSessionId both rotate so a daemon restart (and
   // later resurrect) brings the session back up on the agent the user
   // most recently switched to, not the one it was originally created on.
@@ -7343,6 +8383,7 @@ var SessionManager = class {
         ...record,
         ...update.currentModel !== void 0 ? { currentModel: update.currentModel } : {},
         ...update.currentMode !== void 0 ? { currentMode: update.currentMode } : {},
+        ...update.currentUsage !== void 0 ? { currentUsage: update.currentUsage } : {},
         ...update.agentCommands !== void 0 ? { agentCommands: update.agentCommands } : {},
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
@@ -7367,10 +8408,124 @@ 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,
+    currentUsage: usageSnapshotToPersisted(session.currentUsage) ?? existing?.currentUsage,
+    agentCommands,
+    createdAt: existing?.createdAt ?? new Date(session.createdAt).toISOString()
+  });
+}
+function usageSnapshotToPersisted(usage) {
+  if (!usage) {
+    return void 0;
+  }
+  const out = {};
+  if (usage.used !== void 0) {
+    out.used = usage.used;
+  }
+  if (usage.size !== void 0) {
+    out.size = usage.size;
+  }
+  if (usage.costAmount !== void 0) {
+    out.costAmount = usage.costAmount;
+  }
+  if (usage.costCurrency !== void 0) {
+    out.costCurrency = usage.costCurrency;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function persistedUsageToSnapshot(usage) {
+  return usage ? { ...usage } : void 0;
+}
+function extractInitialModel(result) {
+  const direct = asString(result.currentModelId) ?? asString(result.currentModel) ?? asString(result.modelId) ?? asString(result.model);
+  if (direct) {
+    return direct;
+  }
+  const models = result.models;
+  if (models && typeof models === "object" && !Array.isArray(models)) {
+    const m = asString(models.currentModelId) ?? asString(models.currentModel);
+    if (m) {
+      return m;
+    }
+  }
+  const meta = result._meta;
+  if (meta && typeof meta === "object" && !Array.isArray(meta)) {
+    for (const [key, value] of Object.entries(
+      meta
+    )) {
+      if (key === "hydra-acp") {
+        continue;
+      }
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        const m = asString(value.modelId) ?? asString(value.model) ?? asString(value.currentModelId);
+        if (m) {
+          return m;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function asString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+async function loadPromptHistorySafely(sessionId) {
+  try {
+    const raw = await fs8.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));
+    const st = await fs8.stat(paths.historyFile(sessionId));
     return new Date(st.mtimeMs).toISOString();
   } catch {
     return void 0;
@@ -7379,10 +8534,10 @@ async function historyMtimeIso(sessionId) {
 
 // src/core/extensions.ts
 init_paths();
-import { spawn as spawn2 } from "child_process";
-import * as fs7 from "fs";
-import * as fsp from "fs/promises";
-import * as path3 from "path";
+import { spawn as spawn3 } from "child_process";
+import * as fs9 from "fs";
+import * as fsp2 from "fs/promises";
+import * as path5 from "path";
 var RESTART_BASE_MS = 1e3;
 var RESTART_CAP_MS = 6e4;
 var STOP_GRACE_MS = 3e3;
@@ -7403,7 +8558,7 @@ var ExtensionManager = class {
     if (!this.context) {
       throw new Error("ExtensionManager: setContext must be called before start");
     }
-    await fsp.mkdir(paths.extensionsDir(), { recursive: true });
+    await fsp2.mkdir(paths.extensionsDir(), { recursive: true });
     await this.reapOrphans();
     for (const entry of this.entries.values()) {
       if (!entry.config.enabled) {
@@ -7429,9 +8584,9 @@ var ExtensionManager = class {
       } catch {
       }
       tasks.push(
-        new Promise((resolve2) => {
+        new Promise((resolve5) => {
           if (child.exitCode !== null || child.signalCode !== null) {
-            resolve2();
+            resolve5();
             return;
           }
           const timer = setTimeout(() => {
@@ -7439,11 +8594,11 @@ var ExtensionManager = class {
               child.kill("SIGKILL");
             } catch {
             }
-            resolve2();
+            resolve5();
           }, STOP_GRACE_MS);
           child.on("exit", () => {
             clearTimeout(timer);
-            resolve2();
+            resolve5();
           });
         })
       );
@@ -7551,8 +8706,8 @@ var ExtensionManager = class {
     if (child.exitCode !== null || child.signalCode !== null) {
       return;
     }
-    const exited = new Promise((resolve2) => {
-      entry.exitWaiters.push(resolve2);
+    const exited = new Promise((resolve5) => {
+      entry.exitWaiters.push(resolve5);
     });
     try {
       child.kill("SIGTERM");
@@ -7612,7 +8767,7 @@ var ExtensionManager = class {
   async reapOrphans() {
     let entries;
     try {
-      entries = await fsp.readdir(paths.extensionsDir());
+      entries = await fsp2.readdir(paths.extensionsDir());
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -7624,10 +8779,10 @@ var ExtensionManager = class {
       if (!entry.endsWith(".pid")) {
         continue;
       }
-      const pidPath = path3.join(paths.extensionsDir(), entry);
+      const pidPath = path5.join(paths.extensionsDir(), entry);
       let pid;
       try {
-        const raw = await fsp.readFile(pidPath, "utf8");
+        const raw = await fsp2.readFile(pidPath, "utf8");
         const parsed = Number.parseInt(raw.trim(), 10);
         if (Number.isInteger(parsed) && parsed > 0) {
           pid = parsed;
@@ -7650,7 +8805,7 @@ var ExtensionManager = class {
           }
         }
       }
-      await fsp.unlink(pidPath).catch(() => void 0);
+      await fsp2.unlink(pidPath).catch(() => void 0);
     }
   }
   spawn(entry, attempt) {
@@ -7663,7 +8818,7 @@ var ExtensionManager = class {
     }
     const ext = entry.config;
     const command = ext.command.length > 0 ? ext.command : [ext.name];
-    const logStream = fs7.createWriteStream(paths.extensionLogFile(ext.name), {
+    const logStream = fs9.createWriteStream(paths.extensionLogFile(ext.name), {
       flags: "a"
     });
     logStream.write(
@@ -7691,7 +8846,7 @@ var ExtensionManager = class {
     const args = [...baseArgs, ...ext.args];
     let child;
     try {
-      child = spawn2(cmd, args, {
+      child = spawn3(cmd, args, {
         env,
         stdio: ["ignore", "pipe", "pipe"],
         detached: false
@@ -7713,7 +8868,7 @@ var ExtensionManager = class {
     }
     if (typeof child.pid === "number") {
       try {
-        fs7.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
+        fs9.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
 `, {
           encoding: "utf8",
           mode: 384
@@ -7738,7 +8893,7 @@ var ExtensionManager = class {
     });
     child.on("exit", (code, signal) => {
       try {
-        fs7.unlinkSync(paths.extensionPidFile(ext.name));
+        fs9.unlinkSync(paths.extensionPidFile(ext.name));
       } catch {
       }
       logStream.write(
@@ -7749,8 +8904,8 @@ var ExtensionManager = class {
       entry.pid = void 0;
       entry.lastExitCode = typeof code === "number" ? code : void 0;
       const waiters = entry.exitWaiters.splice(0);
-      for (const resolve2 of waiters) {
-        resolve2();
+      for (const resolve5 of waiters) {
+        resolve5();
       }
       if (this.stopping || entry.manuallyStopped) {
         try {
@@ -7851,6 +9006,78 @@ function constantTimeEqual(a, b) {
 
 // src/daemon/routes/sessions.ts
 init_config();
+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(),
+  currentUsage: PersistedUsage.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.currentUsage !== void 0 ? { currentUsage: params.record.currentUsage } : {},
+      ...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
+init_types();
+var HYDRA_VERSION = "0.1.0";
 function registerSessionRoutes(app, manager, defaults) {
   app.get("/v1/sessions", async (request) => {
     const query = request.query;
@@ -7908,6 +9135,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;
@@ -7916,16 +9198,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) {
@@ -7937,9 +9225,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;
@@ -8114,7 +9416,7 @@ init_connection();
 init_ws_stream();
 init_types();
 import { nanoid as nanoid2 } from "nanoid";
-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) => {
@@ -8160,7 +9462,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
@@ -8179,14 +9481,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`
@@ -8202,13 +9512,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);
@@ -8304,7 +9614,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
@@ -8370,7 +9680,7 @@ function buildResponseMeta(session) {
 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
@@ -8409,14 +9719,14 @@ 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 ? {
-    key: await fsp2.readFile(config.daemon.tls.key),
-    cert: await fsp2.readFile(config.daemon.tls.cert)
+    key: await fsp3.readFile(config.daemon.tls.key),
+    cert: await fsp3.readFile(config.daemon.tls.cert)
   } : void 0;
-  await fsp2.mkdir(paths.home(), { recursive: true });
+  await fsp3.mkdir(paths.home(), { recursive: true });
   const { stream: logStream, fileStream } = await buildLogStream(
     config.daemon.logLevel
   );
@@ -8428,6 +9738,9 @@ async function startDaemon(config) {
     https: httpsOptions ?? null
   });
   await app.register(websocketPlugin);
+  setBinaryInstallLogger((msg) => {
+    app.log.info(msg);
+  });
   const auth = bearerAuth({ config });
   app.addHook("onRequest", async (request, reply) => {
     if (request.routeOptions.config?.skipAuth) {
@@ -8440,10 +9753,11 @@ async function startDaemon(config) {
   });
   const registry = new Registry(config);
   const manager = new SessionManager(registry, void 0, void 0, {
-    idleTimeoutMs: config.daemon.sessionIdleTimeoutSeconds * 1e3
+    idleTimeoutMs: config.daemon.sessionIdleTimeoutSeconds * 1e3,
+    defaultModels: config.defaultModels
   });
   const extensions = new ExtensionManager(extensionList(config));
-  registerHealthRoutes(app, HYDRA_VERSION2);
+  registerHealthRoutes(app, HYDRA_VERSION3);
   registerSessionRoutes(app, manager, {
     agentId: config.defaultAgent,
     cwd: config.defaultCwd
@@ -8462,8 +9776,8 @@ async function startDaemon(config) {
   await app.listen({ host: config.daemon.host, port: config.daemon.port });
   const address = app.server.address();
   const boundPort = address && typeof address === "object" ? address.port : config.daemon.port;
-  await fsp2.mkdir(paths.home(), { recursive: true });
-  await fsp2.writeFile(
+  await fsp3.mkdir(paths.home(), { recursive: true });
+  await fsp3.writeFile(
     paths.pidFile(),
     JSON.stringify({
       pid: process.pid,
@@ -8487,9 +9801,11 @@ async function startDaemon(config) {
   const shutdown = async () => {
     await extensions.stop();
     await manager.closeAll();
+    await manager.flushMetaWrites();
+    setBinaryInstallLogger(null);
     await app.close();
     try {
-      fs8.unlinkSync(paths.pidFile());
+      fs10.unlinkSync(paths.pidFile());
     } catch {
     }
     try {
@@ -8528,13 +9844,13 @@ function ensureLoopbackOrTls(config) {
 init_daemon_bootstrap();
 
 // src/cli/commands/log-tail.ts
-import * as fs9 from "fs";
-import * as fsp3 from "fs/promises";
+import * as fs11 from "fs";
+import * as fsp4 from "fs/promises";
 async function runLogTail(logPath, argv, notFoundMessage) {
   const opts = parseLogTailFlags(argv);
   let stat3;
   try {
-    stat3 = await fsp3.stat(logPath);
+    stat3 = await fsp4.stat(logPath);
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
@@ -8552,7 +9868,7 @@ async function runLogTail(logPath, argv, notFoundMessage) {
   process.stdout.write(`-- following ${logPath} --
 `);
   let pending = false;
-  const watcher = fs9.watch(logPath, () => {
+  const watcher = fs11.watch(logPath, () => {
     if (pending) {
       return;
     }
@@ -8560,14 +9876,14 @@ async function runLogTail(logPath, argv, notFoundMessage) {
     setImmediate(async () => {
       pending = false;
       try {
-        const s = await fsp3.stat(logPath);
+        const s = await fsp4.stat(logPath);
         if (s.size <= position) {
           if (s.size < position) {
             position = s.size;
           }
           return;
         }
-        const fd = await fsp3.open(logPath, "r");
+        const fd = await fsp4.open(logPath, "r");
         try {
           const buf = Buffer.alloc(s.size - position);
           await fd.read(buf, 0, buf.length, position);
@@ -8580,10 +9896,10 @@ async function runLogTail(logPath, argv, notFoundMessage) {
       }
     });
   });
-  await new Promise((resolve2) => {
+  await new Promise((resolve5) => {
     const finish = () => {
       watcher.close();
-      resolve2();
+      resolve5();
     };
     process.once("SIGINT", finish);
     process.once("SIGTERM", finish);
@@ -8594,7 +9910,7 @@ async function printTail(logPath, fileSize, lines) {
     return fileSize;
   }
   const CHUNK = 64 * 1024;
-  const fd = await fsp3.open(logPath, "r");
+  const fd = await fsp4.open(logPath, "r");
   try {
     let position = fileSize;
     let collected = "";
@@ -8651,20 +9967,37 @@ function parseLogTailFlags(argv) {
 }
 
 // src/cli/commands/daemon.ts
-async function runDaemonStart() {
+async function runDaemonStart(flags = {}) {
   const config = await ensureConfig();
-  const handle = await startDaemon(config);
-  process.stdout.write(
-    `hydra-acp daemon listening on ${config.daemon.host}:${config.daemon.port}
+  if (await pingHealth(config)) {
+    const info2 = await readPidFile();
+    process.stdout.write(
+      `Daemon already running${info2 ? ` (pid ${info2.pid})` : ""}. Run \`hydra-acp daemon restart\` to restart it.
+`
+    );
+    return;
+  }
+  if (flagBool(flags, "foreground")) {
+    const handle = await startDaemon(config);
+    process.stdout.write(
+      `hydra-acp daemon listening on ${config.daemon.host}:${config.daemon.port}
 `
+    );
+    const shutdown = async () => {
+      process.stdout.write("Shutting down...\n");
+      await handle.shutdown();
+      process.exit(0);
+    };
+    process.on("SIGINT", () => void shutdown());
+    process.on("SIGTERM", () => void shutdown());
+    return;
+  }
+  spawnDaemonDetached();
+  await waitForDaemonReady(config);
+  const info = await readPidFile();
+  process.stdout.write(
+    `Daemon started on ${config.daemon.host}:${config.daemon.port}` + (info ? ` pid=${info.pid}` : "") + "\n"
   );
-  const shutdown = async () => {
-    process.stdout.write("Shutting down...\n");
-    await handle.shutdown();
-    process.exit(0);
-  };
-  process.on("SIGINT", () => void shutdown());
-  process.on("SIGTERM", () => void shutdown());
 }
 async function runDaemonStop() {
   const info = await readPidFile();
@@ -8746,7 +10079,7 @@ async function runDaemonStatus() {
 }
 async function readPidFile() {
   try {
-    const raw = await fsp4.readFile(paths.pidFile(), "utf8");
+    const raw = await fsp5.readFile(paths.pidFile(), "utf8");
     return JSON.parse(raw);
   } catch (err) {
     const e = err;
@@ -8771,7 +10104,7 @@ init_sessions();
 // src/cli/commands/extensions.ts
 init_config();
 init_paths();
-import * as fsp5 from "fs/promises";
+import * as fsp6 from "fs/promises";
 init_sessions();
 async function runExtensionsList() {
   const config = await loadConfig();
@@ -8912,11 +10245,7 @@ async function runExtensionsAdd(name, argv) {
       `Daemon refused to register ${name} (HTTP ${r.status}${detail}). Restart the daemon to apply.
 `
     );
-  } catch (err) {
-    process.stderr.write(
-      `Daemon not reachable (${err.message}). Config saved; the new extension will start on next daemon launch.
-`
-    );
+  } catch {
   }
 }
 async function runExtensionsRemove(name) {
@@ -8971,11 +10300,11 @@ async function runExtensionsRemove(name) {
   }
 }
 async function readRawConfig() {
-  const raw = await fsp5.readFile(paths.config(), "utf8");
+  const raw = await fsp6.readFile(paths.config(), "utf8");
   return JSON.parse(raw);
 }
 async function writeRawConfig(raw) {
-  await fsp5.writeFile(
+  await fsp6.writeFile(
     paths.config(),
     JSON.stringify(raw, null, 2) + "\n",
     { encoding: "utf8", mode: 384 }
@@ -9655,14 +10984,16 @@ async function main() {
       process.exit(2);
       return;
     }
-    const sessionId2 = resolveOption(flags2, "session-id");
+    const launchResume = flags2.resume;
+    const sessionId2 = typeof launchResume === "string" ? launchResume : resolveOption(flags2, "session-id");
     const name2 = resolveOption(flags2, "name");
     await runShim({ sessionId: sessionId2, agentId, agentArgs, name: name2 });
     return;
   }
   const { positional, flags } = parseArgs(argv);
   if (flags.version === true || positional[0] === "--version") {
-    process.stdout.write("hydra-acp 0.1.0\n");
+    process.stdout.write(`hydra-acp ${readVersion()}
+`);
     return;
   }
   if (flags.help === true) {
@@ -9670,7 +11001,8 @@ async function main() {
     return;
   }
   const subcommand = positional[0];
-  const sessionId = resolveOption(flags, "session-id");
+  const resumeFlag = flags.resume;
+  const sessionId = typeof resumeFlag === "string" ? resumeFlag : resolveOption(flags, "session-id");
   const name = resolveOption(flags, "name");
   const agentIdFromFlag = resolveOption(flags, "agent-id");
   if (!subcommand) {
@@ -9697,7 +11029,7 @@ async function main() {
       const tail = argv.slice(daemonIdx + 1);
       const sub = tail[0];
       if (sub === "start" || sub === void 0) {
-        await runDaemonStart();
+        await runDaemonStart(flags);
         return;
       }
       if (sub === "stop") {
@@ -9735,6 +11067,17 @@ async function main() {
         await runSessionsRm(positional[2]);
         return;
       }
+      if (sub === "export") {
+        const out = resolveOption(flags, "out");
+        await runSessionsExport(positional[2], out);
+        return;
+      }
+      if (sub === "import") {
+        await runSessionsImport(positional[2], {
+          replace: flags.replace === true
+        });
+        return;
+      }
       process.stderr.write(`Unknown sessions subcommand: ${sub}
 `);
       process.exit(2);
@@ -9828,6 +11171,17 @@ async function dispatchTui(flags, base) {
   }
   await runTui(tuiOpts);
 }
+function readVersion() {
+  try {
+    const here = dirname4(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(
+      readFileSync(resolve4(here, "../package.json"), "utf8")
+    );
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
 function printHelp() {
   process.stdout.write(
     [
@@ -9841,13 +11195,18 @@ function printHelp() {
       "                                     Shim mode, force daemon to spawn <agent-id>",
       "                                     from the registry. Args after <agent-id>",
       "                                     are forwarded to the agent's command.",
-      "  hydra-acp --session-id <id>        Attach to an existing session (TUI when in a terminal, shim otherwise)",
+      "  hydra-acp --resume <id>            Attach to an existing session (TUI when in a terminal, shim otherwise)",
       "  hydra-acp init [--rotate-token]    Initialize ~/.hydra-acp/config.json",
-      "  hydra-acp daemon start|stop|restart|status",
+      "  hydra-acp daemon start [--foreground]   Start daemon (detached by default; --foreground to attach)",
+      "  hydra-acp daemon stop|restart|status",
       "  hydra-acp daemon logs [-f] [-n N]  Tail or follow the daemon log",
       "  hydra-acp sessions [list] [--all]  List sessions (live + 20 most-recent cold; --all for everything)",
       "  hydra-acp sessions kill <id>       Demote a live session to cold (keeps the on-disk record)",
       "  hydra-acp sessions rm <id>         Remove a session entirely (live or cold)",
+      "  hydra-acp sessions export <id> [--out <file>|.]",
+      "                                     Write a session bundle to <file>, to a default-named file when --out=., or to stdout",
+      "  hydra-acp sessions import <file>|- [--replace]",
+      "                                     Import a bundle from <file> or stdin (-); --replace overwrites a lineage match (kills it if live)",
       "  hydra-acp extensions list                   List configured extensions and live state",
       "  hydra-acp extensions add <name> [opts]      Add an extension to config",
       "  hydra-acp extensions remove <name>          Remove an extension from config",
@@ -9855,15 +11214,16 @@ function printHelp() {
       "  hydra-acp extensions logs <name> [-f] [-n N]Tail or follow an extension's log",
       "  hydra-acp agents [list]                     List agents in the cached registry",
       "  hydra-acp agents refresh                    Force a registry re-fetch",
-      "  hydra-acp tui flags: [--session-id <id>] [--resume] [--new] [--agent-id <id>] [--cwd <path>] [--name <label>]",
-      "                                     Smart default: picks an existing live session if any exist in cwd, else creates a new one",
+      "  hydra-acp tui flags: [--resume [<id>]] [--new] [--agent-id <id>] [--cwd <path>] [--name <label>]",
+      "                                     --resume <id> attaches to a specific session; bare --resume picks the most-recent",
+      "                                     in cwd. Smart default (no flags): picks if any live sessions exist, else new.",
       "  hydra-acp --version                Print version",
       "  hydra-acp --help                   Show this help",
       "",
       "Config knob flags accept env-var equivalents (flag wins):",
-      "  --agent-id    HYDRA_ACP_AGENT_ID",
-      "  --session-id  HYDRA_ACP_SESSION_ID",
-      "  --name        HYDRA_ACP_NAME",
+      "  --agent-id              HYDRA_ACP_AGENT_ID",
+      "  --resume / --session-id HYDRA_ACP_SESSION_ID",
+      "  --name                  HYDRA_ACP_NAME",
       ""
     ].join("\n")
   );