@hydra-acp/cli 0.1.4 → 0.1.6

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/daemon/server.ts
-import * as fs8 from "fs";
-import * as fsp2 from "fs/promises";
+import * as fs9 from "fs";
+import * as fsp3 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
 import pino from "pino";
@@ -35,7 +35,11 @@ var paths = {
   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
@@ -95,6 +99,14 @@ var HydraConfig = z.object({
   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.
@@ -193,8 +205,213 @@ function expandHome(p) {
 }
 
 // src/core/registry.ts
-import * as fs2 from "fs/promises";
+import * as fs3 from "fs/promises";
 import { z as z2 } from "zod";
+
+// src/core/binary-install.ts
+import * as fs2 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 = fs2.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((resolve3, reject) => {
+    nodeStream.on("error", reject);
+    out.on("error", reject);
+    out.on("finish", () => resolve3());
+    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((resolve3, reject) => {
+    const child = spawn(cmd, args, {
+      stdio: ["ignore", "ignore", "inherit"]
+    });
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      if (code === 0) {
+        resolve3();
+        return;
+      }
+      reject(
+        new Error(
+          `${cmd} ${args.join(" ")} exited with ${code !== null ? `code ${code}` : `signal ${signal}`}`
+        )
+      );
+    });
+  });
+}
+async function hasCommand(name) {
+  return new Promise((resolve3) => {
+    const finder = process.platform === "win32" ? "where" : "which";
+    const child = spawn(finder, [name], { stdio: "ignore" });
+    child.on("error", () => resolve3(false));
+    child.on("exit", (code) => resolve3(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(),
@@ -202,7 +419,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(),
@@ -291,34 +510,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 fs2.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 fs3.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 fs2.mkdir(paths.home(), { recursive: true });
-    await fs2.writeFile(
-      paths.registryCache(),
-      JSON.stringify(cache, null, 2) + "\n",
-      "utf8"
-    );
+    await fs3.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 fs3.writeFile(tmp, body, "utf8");
+      await fs3.rename(tmp, final);
+    } catch (err) {
+      await fs3.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) {
@@ -329,7 +573,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];
@@ -340,9 +584,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;
@@ -357,11 +614,11 @@ function planSpawn(agent, extraArgs = []) {
 }
 
 // src/core/session-manager.ts
-import * as fs6 from "fs/promises";
+import * as fs7 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/types.ts
 import { z as z3 } from "zod";
@@ -439,6 +696,9 @@ function extractHydraMeta(meta) {
       out.resume = parsed.data;
     }
   }
+  if (typeof obj.model === "string") {
+    out.model = obj.model;
+  }
   if (typeof obj.currentModel === "string") {
     out.currentModel = obj.currentModel;
   }
@@ -481,12 +741,24 @@ var SessionListParams = z3.object({
   cursor: z3.string().optional(),
   limit: z3.number().int().positive().max(200).optional()
 });
+var SessionListUsage = z3.object({
+  used: z3.number().optional(),
+  size: z3.number().optional(),
+  costAmount: z3.number().optional(),
+  costCurrency: z3.string().optional()
+});
 var 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"),
@@ -568,13 +840,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((resolve3, reject) => {
         stdin.write(line, (err) => {
           if (err) {
             reject(err);
             return;
           }
-          resolve2();
+          resolve3();
         });
       });
     },
@@ -633,9 +905,9 @@ var JsonRpcConnection = class {
     }
     const id = nanoid();
     const message = { jsonrpc: "2.0", id, method, params };
-    const response = new Promise((resolve2, reject) => {
+    const response = new Promise((resolve3, reject) => {
       this.pending.set(id, {
-        resolve: (result) => resolve2(result),
+        resolve: (result) => resolve3(result),
         reject
       });
       this.stream.send(message).catch((err) => {
@@ -773,7 +1045,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"]
@@ -806,8 +1078,8 @@ var HYDRA_COMMANDS = [
     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"
   }
@@ -829,7 +1101,7 @@ var COMPACT_EVERY = 200;
 var 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.
@@ -844,6 +1116,7 @@ var Session = class {
   // stale-prone for snapshot-shaped events).
   currentModel;
   currentMode;
+  currentUsage;
   updatedAt;
   createdAt;
   clients = /* @__PURE__ */ new Map();
@@ -905,6 +1178,7 @@ var Session = class {
   agentCommandsHandlers = [];
   modelHandlers = [];
   modeHandlers = [];
+  usageHandlers = [];
   constructor(init) {
     this.sessionId = init.sessionId ?? `${HYDRA_SESSION_PREFIX}${generateHydraId()}`;
     this.cwd = init.cwd;
@@ -916,6 +1190,7 @@ var Session = class {
     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];
     }
@@ -945,7 +1220,7 @@ var Session = class {
     });
   }
   // 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
@@ -969,6 +1244,10 @@ var Session = class {
         this.recordAndBroadcast("session/update", params);
         return;
       }
+      if (this.maybeApplyAgentUsage(params)) {
+        this.recordAndBroadcast("session/update", params);
+        return;
+      }
       this.maybeApplyAgentSessionInfo(params);
       this.recordAndBroadcast("session/update", params);
     });
@@ -1286,6 +1565,49 @@ var Session = class {
     }
     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
@@ -1316,6 +1638,9 @@ var Session = class {
   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.
@@ -1378,8 +1703,8 @@ var Session = class {
     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}`
@@ -1415,7 +1740,7 @@ var Session = class {
   }
   // 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) {
@@ -1437,10 +1762,10 @@ var Session = class {
   // 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
       );
     }
@@ -1574,7 +1899,7 @@ var Session = class {
   // on the first wake-up of a session whose meta.json has an empty
   // upstreamSessionId (the import marker). Wrapped in enqueuePrompt so
   // any user prompts arriving mid-seed queue behind it (mirrors the
-  // /hydra switch path so the agent isn't asked to respond to a user
+  // /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.
@@ -1598,7 +1923,7 @@ var Session = class {
   // ones read it and relabel) and (b) drop a visible banner into the
   // transcript so users see the switch rather than just suddenly getting
   // answers from a different agent. Both updates carry synthetic=true
-  // so a future /hydra switch's transcript builder filters them out.
+  // so a future /hydra agent's transcript builder filters them out.
   broadcastAgentSwitch(oldAgentId, newAgentId) {
     this.recordAndBroadcast("session/update", {
       sessionId: this.sessionId,
@@ -1745,7 +2070,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       );
     }
     const clientParams = this.rewriteForClient(params);
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       let settled = false;
       const outbound = [];
       const entry = { addClient: sendTo };
@@ -1780,7 +2105,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
                 result
               }).catch(() => void 0);
             }
-            resolve2(result);
+            resolve3(result);
           });
         }).catch((err) => {
           settle(() => reject(err));
@@ -1792,16 +2117,16 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
     });
   }
   async enqueuePrompt(task) {
-    return new Promise((resolve2, reject) => {
-      const run = async () => {
+    return new Promise((resolve3, reject) => {
+      const run2 = async () => {
         try {
           const result = await task();
-          resolve2(result);
+          resolve3(result);
         } catch (err) {
           reject(err);
         }
       };
-      this.promptQueue.push(run);
+      this.promptQueue.push(run2);
       void this.drainQueue();
     });
   }
@@ -1830,7 +2155,8 @@ var STATE_UPDATE_KINDS = /* @__PURE__ */ new Set([
   "session_info_update",
   "current_model_update",
   "current_mode_update",
-  "available_commands_update"
+  "available_commands_update",
+  "usage_update"
 ]);
 function isStateUpdate(method, params) {
   if (method !== "session/update") {
@@ -1915,8 +2241,8 @@ function firstLine(text, max) {
 }
 
 // src/core/session-store.ts
-import * as fs3 from "fs/promises";
-import * as path2 from "path";
+import * as fs4 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";
@@ -1929,6 +2255,12 @@ 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(),
@@ -1956,6 +2288,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()
@@ -1969,9 +2302,9 @@ function assertSafeId(id) {
 var SessionStore = class {
   async write(record) {
     assertSafeId(record.sessionId);
-    await fs3.mkdir(paths.sessionDir(record.sessionId), { recursive: true });
+    await fs4.mkdir(paths.sessionDir(record.sessionId), { recursive: true });
     const full = { version: 1, ...record };
-    await fs3.writeFile(
+    await fs4.writeFile(
       paths.sessionFile(record.sessionId),
       JSON.stringify(full, null, 2) + "\n",
       { encoding: "utf8", mode: 384 }
@@ -1983,7 +2316,7 @@ var SessionStore = class {
     }
     let raw;
     try {
-      raw = await fs3.readFile(paths.sessionFile(sessionId), "utf8");
+      raw = await fs4.readFile(paths.sessionFile(sessionId), "utf8");
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -2002,7 +2335,7 @@ var SessionStore = class {
       return;
     }
     try {
-      await fs3.unlink(paths.sessionFile(sessionId));
+      await fs4.unlink(paths.sessionFile(sessionId));
     } catch (err) {
       const e = err;
       if (e.code !== "ENOENT") {
@@ -2010,7 +2343,7 @@ var SessionStore = class {
       }
     }
     try {
-      await fs3.rmdir(paths.sessionDir(sessionId));
+      await fs4.rmdir(paths.sessionDir(sessionId));
     } catch (err) {
       const e = err;
       if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
@@ -2040,7 +2373,7 @@ var SessionStore = class {
   async list() {
     let entries;
     try {
-      entries = await fs3.readdir(paths.sessionsDir());
+      entries = await fs4.readdir(paths.sessionsDir());
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -2071,6 +2404,7 @@ function recordFromMemorySession(args) {
     agentArgs: args.agentArgs,
     currentModel: args.currentModel,
     currentMode: args.currentMode,
+    currentUsage: args.currentUsage,
     agentCommands: args.agentCommands,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
@@ -2078,7 +2412,7 @@ function recordFromMemorySession(args) {
 }
 
 // src/core/history-store.ts
-import * as fs4 from "fs/promises";
+import * as fs5 from "fs/promises";
 var SESSION_ID_PATTERN2 = /^[A-Za-z0-9_-]+$/;
 var MAX_ENTRIES = 1e3;
 var HistoryStore = class {
@@ -2091,9 +2425,9 @@ var HistoryStore = class {
       return;
     }
     return this.enqueue(sessionId, async () => {
-      await fs4.mkdir(paths.sessionDir(sessionId), { recursive: true });
+      await fs5.mkdir(paths.sessionDir(sessionId), { recursive: true });
       const line = JSON.stringify(entry) + "\n";
-      await fs4.appendFile(paths.historyFile(sessionId), line, {
+      await fs5.appendFile(paths.historyFile(sessionId), line, {
         encoding: "utf8",
         mode: 384
       });
@@ -2104,9 +2438,9 @@ var HistoryStore = class {
       return;
     }
     return this.enqueue(sessionId, async () => {
-      await fs4.mkdir(paths.sessionDir(sessionId), { recursive: true });
+      await fs5.mkdir(paths.sessionDir(sessionId), { recursive: true });
       const body = entries.length === 0 ? "" : entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-      await fs4.writeFile(paths.historyFile(sessionId), body, {
+      await fs5.writeFile(paths.historyFile(sessionId), body, {
         encoding: "utf8",
         mode: 384
       });
@@ -2123,7 +2457,7 @@ var HistoryStore = class {
     return this.enqueue(sessionId, async () => {
       let raw;
       try {
-        raw = await fs4.readFile(paths.historyFile(sessionId), "utf8");
+        raw = await fs5.readFile(paths.historyFile(sessionId), "utf8");
       } catch (err) {
         const e = err;
         if (e.code === "ENOENT") {
@@ -2136,7 +2470,7 @@ var HistoryStore = class {
         return;
       }
       const trimmed = lines.slice(-maxEntries);
-      await fs4.writeFile(paths.historyFile(sessionId), trimmed.join("\n") + "\n", {
+      await fs5.writeFile(paths.historyFile(sessionId), trimmed.join("\n") + "\n", {
         encoding: "utf8",
         mode: 384
       });
@@ -2152,7 +2486,7 @@ var HistoryStore = class {
     }
     let raw;
     try {
-      raw = await fs4.readFile(paths.historyFile(sessionId), "utf8");
+      raw = await fs5.readFile(paths.historyFile(sessionId), "utf8");
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -2198,7 +2532,7 @@ var HistoryStore = class {
     }
     return this.enqueue(sessionId, async () => {
       try {
-        await fs4.unlink(paths.historyFile(sessionId));
+        await fs5.unlink(paths.historyFile(sessionId));
       } catch (err) {
         const e = err;
         if (e.code !== "ENOENT") {
@@ -2206,7 +2540,7 @@ var HistoryStore = 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") {
@@ -2230,12 +2564,12 @@ var HistoryStore = class {
 };
 
 // src/tui/history.ts
-import { promises as fs5 } from "fs";
-import * as path3 from "path";
+import { promises as fs6 } from "fs";
+import * as path4 from "path";
 async function saveHistory(file, history) {
-  await fs5.mkdir(path3.dirname(file), { recursive: true });
+  await fs6.mkdir(path4.dirname(file), { recursive: true });
   const lines = history.map((entry) => JSON.stringify(entry));
-  await fs5.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
+  await fs6.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
 }
 
 // src/core/session-manager.ts
@@ -2248,6 +2582,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();
@@ -2256,6 +2591,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.
@@ -2265,7 +2601,8 @@ var SessionManager = class {
       agentId: params.agentId,
       cwd: params.cwd,
       agentArgs: params.agentArgs,
-      mcpServers: params.mcpServers
+      mcpServers: params.mcpServers,
+      model: params.model
     });
     const session = new Session({
       cwd: params.cwd,
@@ -2277,7 +2614,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;
@@ -2322,7 +2660,7 @@ var SessionManager = class {
     if (params.upstreamSessionId === "") {
       return this.doResurrectFromImport(params);
     }
-    const plan = planSpawn(agentDef, params.agentArgs ?? []);
+    const plan = await planSpawn(agentDef, params.agentArgs ?? []);
     const agent = this.spawner({
       agentId: params.agentId,
       cwd: params.cwd,
@@ -2335,11 +2673,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(
@@ -2358,8 +2699,13 @@ var SessionManager = class {
       idleTimeoutMs: this.idleTimeoutMs,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       historyStore: this.histories,
-      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
@@ -2397,8 +2743,11 @@ var SessionManager = class {
       idleTimeoutMs: this.idleTimeoutMs,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       historyStore: this.histories,
-      currentModel: params.currentModel,
+      // 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: !!params.title,
       createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0
@@ -2408,7 +2757,7 @@ var SessionManager = class {
     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);
@@ -2419,7 +2768,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,
@@ -2431,14 +2780,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 = params.model ?? 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);
@@ -2449,7 +2820,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 }) => {
@@ -2477,6 +2848,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) => ({
@@ -2525,6 +2901,7 @@ var SessionManager = class {
       agentArgs: record.agentArgs,
       currentModel: record.currentModel,
       currentMode: record.currentMode,
+      currentUsage: persistedUsageToSnapshot(record.currentUsage),
       agentCommands: record.agentCommands,
       createdAt: record.createdAt
     };
@@ -2593,6 +2970,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"
@@ -2613,6 +2992,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"
@@ -2720,6 +3101,7 @@ var SessionManager = class {
         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
@@ -2755,7 +3137,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.
@@ -2787,6 +3169,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()
       });
@@ -2841,13 +3224,73 @@ function mergeForPersistence(session, existing) {
     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 fs6.readFile(paths.tuiHistoryFile(sessionId), "utf8");
+    const raw = await fs7.readFile(paths.tuiHistoryFile(sessionId), "utf8");
     const out = [];
     for (const line of raw.split("\n")) {
       if (line.length === 0) {
@@ -2868,7 +3311,7 @@ async function loadPromptHistorySafely(sessionId) {
 }
 async function historyMtimeIso(sessionId) {
   try {
-    const st = await fs6.stat(paths.historyFile(sessionId));
+    const st = await fs7.stat(paths.historyFile(sessionId));
     return new Date(st.mtimeMs).toISOString();
   } catch {
     return void 0;
@@ -2876,10 +3319,10 @@ async function historyMtimeIso(sessionId) {
 }
 
 // src/core/extensions.ts
-import { spawn as spawn2 } from "child_process";
-import * as fs7 from "fs";
-import * as fsp from "fs/promises";
-import * as path4 from "path";
+import { spawn as spawn3 } from "child_process";
+import * as fs8 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;
@@ -2900,7 +3343,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) {
@@ -2926,9 +3369,9 @@ var ExtensionManager = class {
       } catch {
       }
       tasks.push(
-        new Promise((resolve2) => {
+        new Promise((resolve3) => {
           if (child.exitCode !== null || child.signalCode !== null) {
-            resolve2();
+            resolve3();
             return;
           }
           const timer = setTimeout(() => {
@@ -2936,11 +3379,11 @@ var ExtensionManager = class {
               child.kill("SIGKILL");
             } catch {
             }
-            resolve2();
+            resolve3();
           }, STOP_GRACE_MS);
           child.on("exit", () => {
             clearTimeout(timer);
-            resolve2();
+            resolve3();
           });
         })
       );
@@ -3048,8 +3491,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((resolve3) => {
+      entry.exitWaiters.push(resolve3);
     });
     try {
       child.kill("SIGTERM");
@@ -3109,7 +3552,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") {
@@ -3121,10 +3564,10 @@ var ExtensionManager = class {
       if (!entry.endsWith(".pid")) {
         continue;
       }
-      const pidPath = path4.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;
@@ -3147,7 +3590,7 @@ var ExtensionManager = class {
           }
         }
       }
-      await fsp.unlink(pidPath).catch(() => void 0);
+      await fsp2.unlink(pidPath).catch(() => void 0);
     }
   }
   spawn(entry, attempt) {
@@ -3160,7 +3603,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 = fs8.createWriteStream(paths.extensionLogFile(ext.name), {
       flags: "a"
     });
     logStream.write(
@@ -3188,7 +3631,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
@@ -3210,7 +3653,7 @@ var ExtensionManager = class {
     }
     if (typeof child.pid === "number") {
       try {
-        fs7.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
+        fs8.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
 `, {
           encoding: "utf8",
           mode: 384
@@ -3235,7 +3678,7 @@ var ExtensionManager = class {
     });
     child.on("exit", (code, signal) => {
       try {
-        fs7.unlinkSync(paths.extensionPidFile(ext.name));
+        fs8.unlinkSync(paths.extensionPidFile(ext.name));
       } catch {
       }
       logStream.write(
@@ -3246,8 +3689,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 resolve3 of waiters) {
+        resolve3();
       }
       if (this.stopping || entry.manuallyStopped) {
         try {
@@ -3365,6 +3808,7 @@ var BundleSession = z5.object({
   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()
@@ -3396,6 +3840,7 @@ function encodeBundle(params) {
       ...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
@@ -3794,13 +4239,13 @@ function wsToMessageStream(ws) {
         throw new Error("ws is closed");
       }
       const text = JSON.stringify(message);
-      await new Promise((resolve2, reject) => {
+      await new Promise((resolve3, reject) => {
         ws.send(text, (err) => {
           if (err) {
             reject(err);
             return;
           }
-          resolve2();
+          resolve3();
         });
       });
     },
@@ -3864,7 +4309,8 @@ function registerAcpWsEndpoint(app, deps) {
         agentId: params.agentId ?? deps.defaultAgent,
         mcpServers: params.mcpServers,
         title: hydraMeta.name,
-        agentArgs: hydraMeta.agentArgs
+        agentArgs: hydraMeta.agentArgs,
+        model: hydraMeta.model
       });
       const client = bindClientToSession(connection, session, state);
       await session.attach(client, "full");
@@ -4128,10 +4574,10 @@ 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
   );
@@ -4143,6 +4589,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) {
@@ -4155,7 +4604,8 @@ 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_VERSION3);
@@ -4177,8 +4627,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,
@@ -4203,9 +4653,10 @@ async function startDaemon(config) {
     await extensions.stop();
     await manager.closeAll();
     await manager.flushMetaWrites();
+    setBinaryInstallLogger(null);
     await app.close();
     try {
-      fs8.unlinkSync(paths.pidFile());
+      fs9.unlinkSync(paths.pidFile());
     } catch {
     }
     try {