@hydra-acp/cli 0.1.62 → 0.1.63

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/daemon/server.ts
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 import * as fsp7 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
@@ -26,6 +26,19 @@ import { z } from "zod";
 import * as path from "path";
 import * as os from "os";
 var ROOT_ENV = "HYDRA_ACP_HOME";
+function shortenHomePath(p) {
+  const home = os.homedir();
+  if (!home) {
+    return p;
+  }
+  if (p === home) {
+    return "~";
+  }
+  if (p.startsWith(home + "/")) {
+    return "~" + p.slice(home.length);
+  }
+  return p;
+}
 function hydraHome() {
   const override = process.env[ROOT_ENV];
   if (override && override.length > 0) {
@@ -82,6 +95,12 @@ var paths = {
   sessionDir: (id) => path.join(hydraHome(), "sessions", id),
   sessionFile: (id) => path.join(hydraHome(), "sessions", id, "meta.json"),
   historyFile: (id) => path.join(hydraHome(), "sessions", id, "history.jsonl"),
+  // Content-addressed store for heavy tool payload (diff bodies, stdout)
+  // externalized out of history.jsonl. One file per unique blob, named by
+  // its sha256, so repeated identical content (e.g. an agent re-emitting
+  // the same full-file diff on every status tick) dedupes to one file.
+  toolsDir: (id) => path.join(hydraHome(), "sessions", id, "tools"),
+  toolBlobFile: (id, hash) => path.join(hydraHome(), "sessions", id, "tools", hash),
   // Persisted prompt queue for a session. ndjson, one record per
   // entry. Survives daemon restarts so queued prompts get a chance to
   // run rather than being silently lost. Entries are removed BEFORE
@@ -350,6 +369,29 @@ var TuiConfig = z.object({
   // suppress them — the TUI hotkey ^T toggles this at runtime without
   // persisting back to config.
   showThoughts: z.boolean().default(true),
+  // How the terminal renders East-Asian "Ambiguous" width glyphs (em-dash
+  // —, smart quotes “ ”, ellipsis …, middle-dot ·). Most modern terminals
+  // draw them 1 col wide ("narrow"); CJK-locale / legacy setups draw them 2
+  // cols wide ("wide"). Defaults to "wide": counting ambiguous glyphs as 2
+  // cols never overflows the right margin (the worst case is wrapping a
+  // column early on narrow terminals, which is benign), whereas "narrow"
+  // bleeds past the margin on wide terminals. The thought gutter uses an
+  // ASCII marker, so this no longer affects marker alignment either way.
+  ambiguousWidth: z.enum(["narrow", "wide"]).default("wide"),
+  // How the TUI receives tool payload on attach/replay.
+  //   "references" — the lean path (default): the daemon ships blob refs and
+  //                  the TUI fetches a diff/output body on demand when
+  //                  expanded, cutting replay size on tool-heavy sessions.
+  //                  Collapsed rows never fetch (they show a size hint), and
+  //                  old inline sessions/live turns are unaffected (no refs).
+  //   "inline"     — full content up front (the pre-externalization shape).
+  toolContent: z.enum(["inline", "references"]).default("references"),
+  // Unchanged context lines shown around each change in an expanded Edited
+  // diff. Some agents (e.g. pi) report edits as full-file old/new text via
+  // ACP "diff" content blocks; without hunking a 1-line edit would render
+  // the entire file. This bounds the context so only the changed region (±N
+  // lines) shows, with runs of unchanged lines collapsed to a marker.
+  diffContextLines: z.number().int().min(0).default(3),
   // Cap on entries kept in the cross-session global prompt-history file
   // (~/.hydra-acp/prompt-history). This is the ^P / ^R recall list
   // shared across all sessions; it's append-only on disk, so long-lived
@@ -465,6 +507,12 @@ var HydraConfig = z.object({
   // a literal string ("~", "~/dev", "$HOME/work") so the config file is
   // portable across machines; expanded via expandHome at use time.
   defaultCwd: z.string().default("~"),
+  // Gzip externalized tool-content blobs at rest (tools/<sha256>.gz).
+  // Default true — text diffs/output compress ~3.5x and decompression is
+  // lazy (only on diff expand in references mode). Set false to write plain
+  // blobs instead, as an escape hatch if gzip CPU is ever a problem; reads
+  // transparently handle both, so flipping it only affects new writes.
+  compressToolContent: z.boolean().default(true),
   // Cap on cold sessions shown in CLI `sessions` listing and the TUI
   // picker. Live sessions are always included; cold are sorted by
   // recency and truncated to this count. `--all` overrides in the CLI.
@@ -486,6 +534,9 @@ var HydraConfig = z.object({
     progressIndicator: true,
     defaultEnterAction: "amend",
     showThoughts: true,
+    ambiguousWidth: "wide",
+    toolContent: "references",
+    diffContextLines: 3,
     promptHistoryMaxEntries: 2e3,
     maxToolItems: 5,
     maxPlanItems: 5,
@@ -564,13 +615,113 @@ function expandHome(p) {
   return p;
 }
 
+// src/core/tool-store.ts
+import * as fs4 from "fs/promises";
+import { createHash } from "crypto";
+import { gzip as gzipCb, gunzip as gunzipCb } from "zlib";
+import { promisify } from "util";
+var gzip = promisify(gzipCb);
+var gunzip = promisify(gunzipCb);
+var SESSION_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+var HASH_PATTERN = /^[a-f0-9]{64}$/;
+var compressBlobs = true;
+function setToolBlobCompression(enabled) {
+  compressBlobs = enabled;
+}
+function safe(sessionId, hash) {
+  if (!SESSION_ID_PATTERN.test(sessionId)) {
+    return false;
+  }
+  return hash === void 0 || HASH_PATTERN.test(hash);
+}
+function gzPath(sessionId, hash) {
+  return `${paths.toolBlobFile(sessionId, hash)}.gz`;
+}
+async function putToolBlob(sessionId, text) {
+  if (!safe(sessionId)) {
+    return null;
+  }
+  const hash = createHash("sha256").update(text, "utf8").digest("hex");
+  const gzFile = gzPath(sessionId, hash);
+  const plainFile = paths.toolBlobFile(sessionId, hash);
+  for (const existing of [gzFile, plainFile]) {
+    try {
+      await fs4.access(existing);
+      return hash;
+    } catch {
+    }
+  }
+  await fs4.mkdir(paths.toolsDir(sessionId), { recursive: true });
+  const file = compressBlobs ? gzFile : plainFile;
+  const data = compressBlobs ? await gzip(Buffer.from(text, "utf8")) : Buffer.from(text, "utf8");
+  await fs4.writeFile(file, data, { mode: 384, flag: "wx" }).catch(async (err) => {
+    if (err.code !== "EEXIST") {
+      throw err;
+    }
+  });
+  return hash;
+}
+async function getToolBlob(sessionId, hash) {
+  if (!safe(sessionId, hash)) {
+    return null;
+  }
+  try {
+    const buf = await fs4.readFile(gzPath(sessionId, hash));
+    return (await gunzip(buf)).toString("utf8");
+  } catch {
+  }
+  try {
+    return await fs4.readFile(paths.toolBlobFile(sessionId, hash), "utf8");
+  } catch {
+    return null;
+  }
+}
+async function readToolBlobGz(sessionId, hash) {
+  if (!safe(sessionId, hash)) {
+    return null;
+  }
+  try {
+    return await fs4.readFile(gzPath(sessionId, hash));
+  } catch {
+  }
+  try {
+    const plain = await fs4.readFile(paths.toolBlobFile(sessionId, hash));
+    return await gzip(plain);
+  } catch {
+    return null;
+  }
+}
+async function writeToolBlobGz(sessionId, hash, gzBytes) {
+  if (!safe(sessionId, hash)) {
+    return;
+  }
+  const file = gzPath(sessionId, hash);
+  try {
+    await fs4.access(file);
+    return;
+  } catch {
+  }
+  await fs4.mkdir(paths.toolsDir(sessionId), { recursive: true });
+  await fs4.writeFile(file, gzBytes, { mode: 384, flag: "wx" }).catch((err) => {
+    if (err.code !== "EEXIST") {
+      throw err;
+    }
+  });
+}
+async function deleteToolBlobs(sessionId) {
+  if (!SESSION_ID_PATTERN.test(sessionId)) {
+    return;
+  }
+  await fs4.rm(paths.toolsDir(sessionId), { recursive: true, force: true }).catch(() => void 0);
+}
+
 // src/core/registry.ts
-import * as fs5 from "fs/promises";
+import * as fs6 from "fs/promises";
 import * as path4 from "path";
 import { z as z2 } from "zod";
 
 // src/core/binary-install.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 import * as fsp from "fs/promises";
 import * as path2 from "path";
 import { spawn } from "child_process";
@@ -703,7 +854,7 @@ async function downloadTo(args) {
     );
   }
   const total = Number(response.headers.get("content-length") ?? "0");
-  const out = fs4.createWriteStream(dest);
+  const out = fs5.createWriteStream(dest);
   const nodeStream = Readable.fromWeb(response.body);
   safeEmit(args.onProgress, {
     phase: "download_start",
@@ -1357,7 +1508,7 @@ async function agentInstallState(agent) {
 }
 async function fileExists3(p) {
   try {
-    await fs5.access(p);
+    await fs6.access(p);
     return true;
   } catch {
     return false;
@@ -1440,7 +1591,7 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
 
 // src/core/agent-instance.ts
 import { spawn as spawn3 } from "child_process";
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as path5 from "path";
 
 // src/acp/types.ts
@@ -1559,6 +1710,9 @@ function extractHydraMeta(meta) {
   if (typeof obj.dripSpeed === "number" && obj.dripSpeed > 0) {
     out.dripSpeed = obj.dripSpeed;
   }
+  if (obj.toolContent === "inline" || obj.toolContent === "references") {
+    out.toolContent = obj.toolContent;
+  }
   if (obj.detachStatus === "detached") {
     out.detachStatus = obj.detachStatus;
   }
@@ -2452,8 +2606,8 @@ stderr: ${tail}` : reason;
 function openAgentLog(agentId) {
   try {
     const logPath = paths.agentLogFile(agentId);
-    fs6.mkdirSync(path5.dirname(logPath), { recursive: true });
-    const stream = fs6.createWriteStream(logPath, { flags: "a" });
+    fs7.mkdirSync(path5.dirname(logPath), { recursive: true });
+    const stream = fs7.createWriteStream(logPath, { flags: "a" });
     stream.on("error", () => void 0);
     return stream;
   } catch {
@@ -2462,7 +2616,7 @@ function openAgentLog(agentId) {
 }
 
 // src/core/session-manager.ts
-import * as fs14 from "fs/promises";
+import * as fs15 from "fs/promises";
 import * as os2 from "os";
 import * as path9 from "path";
 import { customAlphabet as customAlphabet3 } from "nanoid";
@@ -2936,6 +3090,30 @@ var HYDRA_COMMANDS = [
 ];
 var VERB_INDEX = new Map(HYDRA_COMMANDS.map((c) => [c.verb, c]));
 
+// src/core/model-resolve.ts
+function trailingSegment(modelId) {
+  const slash = modelId.lastIndexOf("/");
+  const tail = slash === -1 ? modelId : modelId.slice(slash + 1);
+  return tail.toLowerCase();
+}
+function resolveModelId(requested, advertised) {
+  if (advertised.length === 0) {
+    return { kind: "none", requested };
+  }
+  if (advertised.some((m) => m.modelId === requested)) {
+    return { kind: "exact", modelId: requested };
+  }
+  const wantKey = trailingSegment(requested);
+  const candidates = advertised.map((m) => m.modelId).filter((id) => trailingSegment(id) === wantKey);
+  if (candidates.length === 1) {
+    return { kind: "resolved", modelId: candidates[0], requested };
+  }
+  if (candidates.length > 1) {
+    return { kind: "ambiguous", requested, candidates };
+  }
+  return { kind: "unknown", requested };
+}
+
 // src/core/coalesce-replay.ts
 function coalesceReplay(entries) {
   if (entries.length === 0) {
@@ -2943,6 +3121,7 @@ function coalesceReplay(entries) {
   }
   const lastToolUpdateIndex = /* @__PURE__ */ new Map();
   const mergedToolContent = /* @__PURE__ */ new Map();
+  const carriedRawInput = /* @__PURE__ */ new Map();
   for (let i = 0; i < entries.length; i++) {
     const entry = entries[i];
     if (entry === void 0) {
@@ -2957,6 +3136,9 @@ function coalesceReplay(entries) {
       continue;
     }
     lastToolUpdateIndex.set(id, i);
+    if (upd.rawInput && typeof upd.rawInput === "object" && !Array.isArray(upd.rawInput) && Object.keys(upd.rawInput).length > 0) {
+      carriedRawInput.set(id, upd.rawInput);
+    }
     if (Array.isArray(upd.content) && upd.content.length > 0) {
       const buf = mergedToolContent.get(id);
       if (buf) {
@@ -2996,11 +3178,11 @@ function coalesceReplay(entries) {
       if (id !== void 0 && lastToolUpdateIndex.get(id) !== i) {
         continue;
       }
-      if (id !== void 0 && mergedToolContent.has(id)) {
-        out.push(withReplacedContent(entry, mergedToolContent.get(id) ?? []));
-      } else {
-        out.push(entry);
+      let emitted = id !== void 0 && mergedToolContent.has(id) ? withReplacedContent(entry, mergedToolContent.get(id) ?? []) : entry;
+      if (id !== void 0 && carriedRawInput.has(id) && !hasRawInput(emitted)) {
+        emitted = withRawInput(emitted, carriedRawInput.get(id));
       }
+      out.push(emitted);
       continue;
     }
     if (kind === "plan") {
@@ -3071,24 +3253,40 @@ function withReplacedContent(entry, content) {
     }
   };
 }
+function hasRawInput(entry) {
+  const update = readUpdate(entry);
+  const ri = update?.rawInput;
+  return !!ri && typeof ri === "object" && !Array.isArray(ri) && Object.keys(ri).length > 0;
+}
+function withRawInput(entry, rawInput) {
+  const params = entry.params ?? {};
+  const update = params.update ?? {};
+  return {
+    ...entry,
+    params: {
+      ...params,
+      update: { ...update, rawInput }
+    }
+  };
+}
 
 // src/core/queue-store.ts
-import * as fs7 from "fs/promises";
+import * as fs8 from "fs/promises";
 async function rewriteQueue(sessionId, entries) {
   const file = paths.queueFile(sessionId);
   if (entries.length === 0) {
-    await fs7.unlink(file).catch(() => void 0);
+    await fs8.unlink(file).catch(() => void 0);
     return;
   }
-  await fs7.mkdir(paths.sessionDir(sessionId), { recursive: true });
+  await fs8.mkdir(paths.sessionDir(sessionId), { recursive: true });
   const body = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-  await fs7.writeFile(file, body, "utf8");
+  await fs8.writeFile(file, body, "utf8");
 }
 async function loadQueue(sessionId) {
   const file = paths.queueFile(sessionId);
   let text;
   try {
-    text = await fs7.readFile(file, "utf8");
+    text = await fs8.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return [];
@@ -3110,7 +3308,7 @@ async function loadQueue(sessionId) {
 }
 async function deleteQueue(sessionId) {
   const file = paths.queueFile(sessionId);
-  await fs7.unlink(file).catch(() => void 0);
+  await fs8.unlink(file).catch(() => void 0);
 }
 
 // src/core/session.ts
@@ -3626,11 +3824,11 @@ var Session = class _Session {
   // 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() {
+  async getHistorySnapshot(tools = "inline") {
     if (!this.historyStore) {
       return [];
     }
-    return this.historyStore.load(this.sessionId).catch(() => []);
+    return this.historyStore.load(this.sessionId, { tools }).catch(() => []);
   }
   // Subscribe to recordable broadcast entries — fires once per entry
   // that lands in history (so snapshot-shaped session_info/model/mode/
@@ -3680,7 +3878,7 @@ var Session = class _Session {
   }
   async loadReplay(historyPolicy, opts) {
     const maybeCoalesce = (entries) => opts.raw ? entries : coalesceReplay(entries);
-    const raw = await this.getHistorySnapshot();
+    const raw = await this.getHistorySnapshot(opts.toolContent ?? "inline");
     const state = this.buildStateSnapshotReplay();
     if (historyPolicy === "after_message") {
       const cutoff = opts.afterMessageId ? findMessageIdIndex(raw, opts.afterMessageId) : -1;
@@ -5349,6 +5547,27 @@ ${text}
           sessionUpdate: "agent_message_chunk",
           content: { type: "text", text: `
 ${body}
+` },
+          _meta: { "hydra-acp": { synthetic: true } }
+        }
+      });
+      return { stopReason: "end_turn" };
+    }
+    const resolution = resolveModelId(arg, this.agentAdvertisedModels);
+    let modelId = arg;
+    if (resolution.kind === "resolved") {
+      modelId = resolution.modelId;
+    } else if (resolution.kind === "ambiguous" || resolution.kind === "unknown") {
+      const known = this.agentAdvertisedModels.map((m) => m.modelId).join("\n  ");
+      const reason = resolution.kind === "ambiguous" ? `"${arg}" matches multiple models: ${resolution.candidates.join(", ")}` : `"${arg}" is not an available model`;
+      this.recordAndBroadcast("session/update", {
+        sessionId: this.upstreamSessionId,
+        update: {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: `
+${reason}.
+Available models:
+  ${known}
 ` },
           _meta: { "hydra-acp": { synthetic: true } }
         }
@@ -5357,7 +5576,7 @@ ${body}
     }
     await this.forwardRequest("session/set_model", {
       sessionId: this.sessionId,
-      modelId: arg
+      modelId
     });
     return { stopReason: "end_turn" };
   }
@@ -6620,7 +6839,7 @@ function firstLine(text, max) {
 }
 
 // src/core/session-store.ts
-import * as fs8 from "fs/promises";
+import * as fs9 from "fs/promises";
 import * as path6 from "path";
 import { customAlphabet as customAlphabet2 } from "nanoid";
 import { z as z5 } from "zod";
@@ -6827,9 +7046,9 @@ var SessionRecord = z5.object({
   createdAt: z5.string(),
   updatedAt: z5.string()
 });
-var SESSION_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+var SESSION_ID_PATTERN2 = /^[A-Za-z0-9_-]+$/;
 function assertSafeId(id) {
-  if (!SESSION_ID_PATTERN.test(id)) {
+  if (!SESSION_ID_PATTERN2.test(id)) {
     throw new Error(`unsafe session id: ${id}`);
   }
 }
@@ -6842,7 +7061,7 @@ var SessionStore = class {
     });
   }
   async read(sessionId) {
-    if (!SESSION_ID_PATTERN.test(sessionId)) {
+    if (!SESSION_ID_PATTERN2.test(sessionId)) {
       return void 0;
     }
     const parsed = await readJsonSafe(paths.sessionFile(sessionId));
@@ -6856,11 +7075,11 @@ var SessionStore = class {
     }
   }
   async delete(sessionId) {
-    if (!SESSION_ID_PATTERN.test(sessionId)) {
+    if (!SESSION_ID_PATTERN2.test(sessionId)) {
       return;
     }
     try {
-      await fs8.unlink(paths.sessionFile(sessionId));
+      await fs9.unlink(paths.sessionFile(sessionId));
     } catch (err) {
       const e = err;
       if (e.code !== "ENOENT") {
@@ -6868,7 +7087,7 @@ var SessionStore = class {
       }
     }
     try {
-      await fs8.rmdir(paths.sessionDir(sessionId));
+      await fs9.rmdir(paths.sessionDir(sessionId));
     } catch (err) {
       const e = err;
       if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
@@ -6898,7 +7117,7 @@ var SessionStore = class {
   async list() {
     let entries;
     try {
-      entries = await fs8.readdir(paths.sessionsDir());
+      entries = await fs9.readdir(paths.sessionsDir());
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -6949,7 +7168,7 @@ function recordFromMemorySession(args) {
 }
 
 // src/core/tombstone-store.ts
-import * as fs9 from "fs/promises";
+import * as fs10 from "fs/promises";
 import { z as z6 } from "zod";
 var Tombstone = z6.object({
   version: z6.literal(1),
@@ -6978,7 +7197,7 @@ var TombstoneStore = class {
   }
   async has(agentId, upstreamSessionId) {
     try {
-      await fs9.access(paths.tombstoneFile(agentId, upstreamSessionId));
+      await fs10.access(paths.tombstoneFile(agentId, upstreamSessionId));
       return true;
     } catch {
       return false;
@@ -7016,7 +7235,7 @@ var TombstoneStore = class {
   }
   async remove(agentId, upstreamSessionId) {
     try {
-      await fs9.unlink(paths.tombstoneFile(agentId, upstreamSessionId));
+      await fs10.unlink(paths.tombstoneFile(agentId, upstreamSessionId));
     } catch (err) {
       const e = err;
       if (e.code !== "ENOENT") {
@@ -7024,7 +7243,7 @@ var TombstoneStore = class {
       }
     }
     try {
-      await fs9.rmdir(paths.tombstoneAgentDir(agentId));
+      await fs10.rmdir(paths.tombstoneAgentDir(agentId));
     } catch (err) {
       const e = err;
       if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
@@ -7038,7 +7257,7 @@ var TombstoneStore = class {
     }
     let agents;
     try {
-      agents = await fs9.readdir(paths.tombstonesDir());
+      agents = await fs10.readdir(paths.tombstonesDir());
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -7061,7 +7280,7 @@ var TombstoneStore = class {
   async listForAgent(agentId) {
     let files;
     try {
-      files = await fs9.readdir(paths.tombstoneAgentDir(agentId));
+      files = await fs10.readdir(paths.tombstoneAgentDir(agentId));
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -7096,19 +7315,19 @@ function shouldResurrectFromUpstream(tombstone, listingUpdatedAt) {
 }
 
 // src/core/synopsis-coordinator.ts
-import * as fs11 from "fs/promises";
+import * as fs12 from "fs/promises";
 
 // src/core/hydra-version.ts
 import { fileURLToPath } from "url";
 import * as path7 from "path";
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 function resolveVersion() {
   try {
     let dir = path7.dirname(fileURLToPath(import.meta.url));
     for (let i = 0; i < 8; i += 1) {
       const candidate = path7.join(dir, "package.json");
-      if (fs10.existsSync(candidate)) {
-        const pkg = JSON.parse(fs10.readFileSync(candidate, "utf8"));
+      if (fs11.existsSync(candidate)) {
+        const pkg = JSON.parse(fs11.readFileSync(candidate, "utf8"));
         if (typeof pkg.version === "string" && pkg.version.length > 0 && (typeof pkg.name !== "string" || pkg.name.includes("hydra-acp"))) {
           return pkg.version;
         }
@@ -7632,7 +7851,7 @@ var SynopsisCoordinator = class {
       });
       const modelId = this.opts.synopsisModel;
       const synopsisCwd = paths.sessionDir(sessionId);
-      await fs11.mkdir(synopsisCwd, { recursive: true }).catch(() => void 0);
+      await fs12.mkdir(synopsisCwd, { recursive: true }).catch(() => void 0);
       this.opts.logger?.info(
         `synopsis: start sessionId=${sessionId} agentId=${synopsisAgentId} historyLen=${history.length} model=${JSON.stringify(modelId ?? "(default)")} cwd=${synopsisCwd}`
       );
@@ -7735,8 +7954,217 @@ function describeFields(s) {
 }
 
 // src/core/history-store.ts
-import * as fs12 from "fs/promises";
-var SESSION_ID_PATTERN2 = /^[A-Za-z0-9_-]+$/;
+import * as fs13 from "fs/promises";
+
+// src/core/tool-content.ts
+function parseToolContentMode(raw) {
+  return raw === "summary" ? "summary" : "inline";
+}
+var SUMMARY_TEXT_CAP = 256;
+function applyToolContentMode(entries, mode) {
+  if (mode !== "summary") {
+    return entries;
+  }
+  return entries.map(summarizeEntry);
+}
+function summarizeEntry(entry) {
+  if (entry.method !== "session/update") {
+    return entry;
+  }
+  const params = entry.params;
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    return entry;
+  }
+  const p = params;
+  const update = p.update;
+  if (!update || typeof update !== "object" || Array.isArray(update)) {
+    return entry;
+  }
+  const u = update;
+  if (u.sessionUpdate !== "tool_call" && u.sessionUpdate !== "tool_call_update") {
+    return entry;
+  }
+  const newUpdate = { ...u };
+  if (Array.isArray(u.content)) {
+    newUpdate.content = u.content.map(summarizeBlock);
+  }
+  const rawOutput = u.rawOutput;
+  if (rawOutput && typeof rawOutput === "object" && !Array.isArray(rawOutput)) {
+    const ro = rawOutput;
+    const slim = {};
+    if (ro.error !== void 0) {
+      slim.error = clip(ro.error);
+    }
+    if (ro.metadata !== void 0) {
+      slim.metadata = ro.metadata;
+    }
+    newUpdate.rawOutput = slim;
+  }
+  return { ...entry, params: { ...p, update: newUpdate } };
+}
+function isDiffBlock(block) {
+  return !!block && typeof block === "object" && !Array.isArray(block) && block.type === "diff";
+}
+function summarizeBlock(block) {
+  if (isDiffBlock(block)) {
+    const b2 = block;
+    const out2 = {
+      type: "diff",
+      oldText: "",
+      newText: ""
+    };
+    if (typeof b2.path === "string") {
+      out2.path = b2.path;
+    }
+    return out2;
+  }
+  if (!block || typeof block !== "object" || Array.isArray(block)) {
+    return block;
+  }
+  const b = block;
+  const out = { ...b };
+  if (typeof b.text === "string") {
+    out.text = clip(b.text);
+  }
+  if (typeof b.content === "string") {
+    out.content = clip(b.content);
+  } else if (b.content && typeof b.content === "object") {
+    out.content = summarizeBlock(b.content);
+  }
+  return out;
+}
+function clip(value) {
+  if (typeof value === "string" && value.length > SUMMARY_TEXT_CAP) {
+    const elided = value.length - SUMMARY_TEXT_CAP;
+    return `${value.slice(0, SUMMARY_TEXT_CAP)}\u2026[+${elided} chars omitted from summary export]`;
+  }
+  return value;
+}
+var TOOL_BLOB_THRESHOLD = 2048;
+function collectToolBlobHashes(entries) {
+  const out = /* @__PURE__ */ new Set();
+  const walk = (value) => {
+    if (isToolBlobRef(value)) {
+      out.add(value.__hydraBlob);
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        walk(item);
+      }
+      return;
+    }
+    if (value && typeof value === "object") {
+      for (const v of Object.values(value)) {
+        walk(v);
+      }
+    }
+  };
+  for (const entry of entries) {
+    walk(entry.params);
+  }
+  return out;
+}
+function isToolBlobRef(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && typeof value.__hydraBlob === "string";
+}
+function isToolEntry(entry) {
+  if (entry.method !== "session/update") {
+    return false;
+  }
+  const params = entry.params;
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    return false;
+  }
+  const update = params.update;
+  if (!update || typeof update !== "object" || Array.isArray(update)) {
+    return false;
+  }
+  const kind = update.sessionUpdate;
+  return kind === "tool_call" || kind === "tool_call_update";
+}
+async function externalizeToolEntry(entry, put) {
+  if (!isToolEntry(entry)) {
+    return entry;
+  }
+  const p = entry.params;
+  const update = p.update;
+  const newUpdate = await deepExternalize(update, put);
+  return { ...entry, params: { ...p, update: newUpdate } };
+}
+async function deepExternalize(value, put) {
+  if (typeof value === "string") {
+    if (value.length <= TOOL_BLOB_THRESHOLD) {
+      return value;
+    }
+    const hash = await put(value);
+    if (hash === null) {
+      return value;
+    }
+    const ref = { __hydraBlob: hash, bytes: value.length };
+    return ref;
+  }
+  if (Array.isArray(value)) {
+    const out = [];
+    for (const item of value) {
+      out.push(await deepExternalize(item, put));
+    }
+    return out;
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = await deepExternalize(v, put);
+    }
+    return out;
+  }
+  return value;
+}
+async function expandToolRefs(entry, get) {
+  const params = entry.params;
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    return entry;
+  }
+  const expanded = await deepExpand(params, get);
+  if (expanded === params) {
+    return entry;
+  }
+  return { ...entry, params: expanded };
+}
+async function deepExpand(value, get) {
+  if (isToolBlobRef(value)) {
+    const text = await get(value.__hydraBlob);
+    return text ?? "";
+  }
+  if (Array.isArray(value)) {
+    let changed = false;
+    const out = [];
+    for (const item of value) {
+      const next = await deepExpand(item, get);
+      if (next !== item) {
+        changed = true;
+      }
+      out.push(next);
+    }
+    return changed ? out : value;
+  }
+  if (value && typeof value === "object") {
+    let changed = false;
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      const next = await deepExpand(v, get);
+      if (next !== v) {
+        changed = true;
+      }
+      out[k] = next;
+    }
+    return changed ? out : value;
+  }
+  return value;
+}
+
+// src/core/history-store.ts
+var SESSION_ID_PATTERN3 = /^[A-Za-z0-9_-]+$/;
 var DEFAULT_MAX_ENTRIES = 1e3;
 var HistoryStore = class {
   // Serialize writes per session id so appends and rewrites don't
@@ -7748,26 +8176,34 @@ var HistoryStore = class {
     this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
   }
   async append(sessionId, entry) {
-    if (!SESSION_ID_PATTERN2.test(sessionId)) {
+    if (!SESSION_ID_PATTERN3.test(sessionId)) {
       return;
     }
     return this.enqueue(sessionId, async () => {
-      await fs12.mkdir(paths.sessionDir(sessionId), { recursive: true });
-      const line = JSON.stringify(entry) + "\n";
-      await fs12.appendFile(paths.historyFile(sessionId), line, {
+      await fs13.mkdir(paths.sessionDir(sessionId), { recursive: true });
+      const stored = await externalizeToolEntry(
+        entry,
+        (t) => putToolBlob(sessionId, t)
+      );
+      const line = JSON.stringify(stored) + "\n";
+      await fs13.appendFile(paths.historyFile(sessionId), line, {
         encoding: "utf8",
         mode: 384
       });
     });
   }
   async rewrite(sessionId, entries) {
-    if (!SESSION_ID_PATTERN2.test(sessionId)) {
+    if (!SESSION_ID_PATTERN3.test(sessionId)) {
       return;
     }
     return this.enqueue(sessionId, async () => {
-      await fs12.mkdir(paths.sessionDir(sessionId), { recursive: true });
-      const body = entries.length === 0 ? "" : entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-      await fs12.writeFile(paths.historyFile(sessionId), body, {
+      await fs13.mkdir(paths.sessionDir(sessionId), { recursive: true });
+      const stored = [];
+      for (const e of entries) {
+        stored.push(await externalizeToolEntry(e, (t) => putToolBlob(sessionId, t)));
+      }
+      const body = stored.length === 0 ? "" : stored.map((e) => JSON.stringify(e)).join("\n") + "\n";
+      await fs13.writeFile(paths.historyFile(sessionId), body, {
         encoding: "utf8",
         mode: 384
       });
@@ -7778,13 +8214,13 @@ var HistoryStore = class {
   // 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)) {
+    if (!SESSION_ID_PATTERN3.test(sessionId)) {
       return;
     }
     return this.enqueue(sessionId, async () => {
       let raw;
       try {
-        raw = await fs12.readFile(paths.historyFile(sessionId), "utf8");
+        raw = await fs13.readFile(paths.historyFile(sessionId), "utf8");
       } catch (err) {
         const e = err;
         if (e.code === "ENOENT") {
@@ -7797,23 +8233,29 @@ var HistoryStore = class {
         return;
       }
       const trimmed = lines.slice(-maxEntries);
-      await fs12.writeFile(paths.historyFile(sessionId), trimmed.join("\n") + "\n", {
+      await fs13.writeFile(paths.historyFile(sessionId), trimmed.join("\n") + "\n", {
         encoding: "utf8",
         mode: 384
       });
     });
   }
-  async load(sessionId) {
-    if (!SESSION_ID_PATTERN2.test(sessionId)) {
+  // `tools` selects how externalized tool content is materialized:
+  //   "inline" (default) — expand blob refs back to full content, so every
+  //                        consumer sees the original recorded shape.
+  //   "references"       — leave references in place (the lean form) for
+  //                        clients that fetch tool content on demand.
+  async load(sessionId, opts = {}) {
+    if (!SESSION_ID_PATTERN3.test(sessionId)) {
       return [];
     }
+    const expand = (opts.tools ?? "inline") === "inline";
     const pending = this.writeQueues.get(sessionId);
     if (pending) {
       await pending;
     }
     let raw;
     try {
-      raw = await fs12.readFile(paths.historyFile(sessionId), "utf8");
+      raw = await fs13.readFile(paths.historyFile(sessionId), "utf8");
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -7848,10 +8290,25 @@ var HistoryStore = class {
         recordedAt: obj.recordedAt
       });
     }
-    if (out.length > this.maxEntries) {
-      return out.slice(-this.maxEntries);
+    const kept = out.length > this.maxEntries ? out.slice(-this.maxEntries) : out;
+    if (!expand) {
+      return kept;
     }
-    return out;
+    const blobCache = /* @__PURE__ */ new Map();
+    const get = async (hash) => {
+      const cached = blobCache.get(hash);
+      if (cached !== void 0) {
+        return cached;
+      }
+      const value = await getToolBlob(sessionId, hash);
+      blobCache.set(hash, value);
+      return value;
+    };
+    const inlined = [];
+    for (const entry of kept) {
+      inlined.push(await expandToolRefs(entry, get));
+    }
+    return inlined;
   }
   // Wait for every pending append/rewrite/compact across all sessions to
   // settle. Daemon shutdown calls this after closing sessions so the final
@@ -7867,20 +8324,21 @@ var HistoryStore = class {
     await Promise.allSettled(pending);
   }
   async delete(sessionId) {
-    if (!SESSION_ID_PATTERN2.test(sessionId)) {
+    if (!SESSION_ID_PATTERN3.test(sessionId)) {
       return;
     }
     return this.enqueue(sessionId, async () => {
       try {
-        await fs12.unlink(paths.historyFile(sessionId));
+        await fs13.unlink(paths.historyFile(sessionId));
       } catch (err) {
         const e = err;
         if (e.code !== "ENOENT") {
           throw err;
         }
       }
+      await deleteToolBlobs(sessionId);
       try {
-        await fs12.rmdir(paths.sessionDir(sessionId));
+        await fs13.rmdir(paths.sessionDir(sessionId));
       } catch (err) {
         const e = err;
         if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
@@ -7904,12 +8362,12 @@ var HistoryStore = class {
 };
 
 // src/tui/history.ts
-import { promises as fs13 } from "fs";
+import { promises as fs14 } from "fs";
 import * as path8 from "path";
 async function saveHistory(file, history) {
-  await fs13.mkdir(path8.dirname(file), { recursive: true });
+  await fs14.mkdir(path8.dirname(file), { recursive: true });
   const lines = history.map((entry) => JSON.stringify(entry));
-  await fs13.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
+  await fs14.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
 }
 
 // src/core/bundle.ts
@@ -7971,7 +8429,12 @@ var Bundle = z7.object({
   }),
   session: BundleSession,
   history: z7.array(HistoryEntrySchema),
-  promptHistory: z7.array(z7.string()).optional()
+  promptHistory: z7.array(z7.string()).optional(),
+  // Externalized tool-content blobs referenced by the history, present when
+  // the bundle was exported with tools=references. Map of sha256 → base64
+  // of the gzipped content. Restored to the session's tools/ store on
+  // import; the ref-form history hydrates from them.
+  toolBlobs: z7.record(z7.string()).optional()
 });
 function encodeBundle(params) {
   const bundle = {
@@ -8006,6 +8469,9 @@ function encodeBundle(params) {
   if (params.promptHistory !== void 0) {
     bundle.promptHistory = params.promptHistory;
   }
+  if (params.toolBlobs !== void 0 && Object.keys(params.toolBlobs).length > 0) {
+    bundle.toolBlobs = params.toolBlobs;
+  }
   return bundle;
 }
 function decodeBundle(raw) {
@@ -8420,7 +8886,7 @@ var SessionManager = class {
   }
   async dirExists(cwd) {
     try {
-      return (await fs14.stat(cwd)).isDirectory();
+      return (await fs15.stat(cwd)).isDirectory();
     } catch {
       return false;
     }
@@ -8610,6 +9076,25 @@ var SessionManager = class {
     }
     return out;
   }
+  // Issue session/set_model for a seed model (defaultModels / --model) at
+  // bootstrap, logging success or a non-fatal rejection. `where` is the
+  // human-readable provenance string used in log lines. A bad id in config
+  // shouldn't break session creation, so a rejection is swallowed.
+  async applySeedModel(agent, sessionId, modelId, where) {
+    try {
+      await agent.connection.request("session/set_model", {
+        sessionId,
+        modelId
+      });
+      this.logger?.info(`${where}: session/set_model accepted`);
+      return true;
+    } catch (err) {
+      this.logger?.warn(
+        `${where} rejected by agent (${err.message}); session will use the agent's own default`
+      );
+      return false;
+    }
+  }
   // Bootstrap a fresh agent process: registry resolve → spawn → initialize
   // → session/new. Shared by create() and the /hydra agent path so both
   // go through the same env / capabilities / error-handling.
@@ -8658,23 +9143,31 @@ var SessionManager = class {
       const initialModels = extractInitialModels(newResult);
       const desired = params.model ?? this.defaultModels[params.agentId];
       if (desired && desired !== initialModel) {
-        const validates = initialModels.length === 0 || initialModels.some((m) => m.modelId === desired);
-        if (validates) {
-          try {
-            await agent.connection.request("session/set_model", {
-              sessionId: sessionIdRaw,
-              modelId: desired
-            });
+        const resolution = resolveModelId(desired, initialModels);
+        const where = params.model !== void 0 ? `model=${JSON.stringify(desired)}` : `defaultModels[${params.agentId}]=${JSON.stringify(desired)}`;
+        if (resolution.kind === "exact" || resolution.kind === "none") {
+          if (await this.applySeedModel(agent, sessionIdRaw, desired, where)) {
             initialModel = desired;
-          } catch (err) {
-            this.logger?.warn(
-              `defaultModels[${params.agentId}]=${JSON.stringify(desired)} rejected by agent (${err.message}); session will use ${JSON.stringify(initialModel)}`
-            );
           }
+        } else if (resolution.kind === "resolved") {
+          if (resolution.modelId === initialModel) {
+            initialModel = resolution.modelId;
+          } else if (await this.applySeedModel(
+            agent,
+            sessionIdRaw,
+            resolution.modelId,
+            `${where} resolved to ${JSON.stringify(resolution.modelId)}`
+          )) {
+            initialModel = resolution.modelId;
+          }
+        } else if (resolution.kind === "ambiguous") {
+          this.logger?.warn(
+            `${where} is ambiguous (trailing-segment matches [${resolution.candidates.join(", ")}]); skipping session/set_model, session will use ${JSON.stringify(initialModel)}`
+          );
         } else {
           const known = initialModels.map((m) => m.modelId).join(", ");
           this.logger?.warn(
-            `defaultModels[${params.agentId}]=${JSON.stringify(desired)} not in agent's availableModels ([${known}]); skipping session/set_model, session will use ${JSON.stringify(initialModel)}`
+            `${where} not in agent's availableModels ([${known}]); skipping session/set_model, session will use ${JSON.stringify(initialModel)}`
           );
         }
       }
@@ -8807,6 +9300,12 @@ var SessionManager = class {
   async loadHistory(sessionId) {
     return this.histories.load(sessionId);
   }
+  // Read a single externalized tool-content blob by sha256 (the lean
+  // `tools: "references"` fetch-on-expand path). Null if the session id or
+  // hash is malformed, or the blob isn't present.
+  async loadToolBlob(sessionId, hash) {
+    return getToolBlob(sessionId, hash);
+  }
   async loadFromDisk(sessionId) {
     const record = await this.store.read(sessionId);
     if (!record) {
@@ -9044,7 +9543,7 @@ var SessionManager = class {
   // 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) {
+  async exportBundle(sessionId, opts = {}) {
     const record = await this.store.read(sessionId);
     if (!record) {
       return void 0;
@@ -9067,9 +9566,20 @@ var SessionManager = class {
       }).catch(() => void 0);
       withLineage = backfilled;
     }
-    const history = await this.histories.load(sessionId).catch(() => []);
+    const tools = opts.tools ?? "inline";
+    const history = await this.histories.load(sessionId, tools === "references" ? { tools: "references" } : {}).catch(() => []);
     const promptHistory = await loadPromptHistorySafely(sessionId);
-    return { record: withLineage, history, promptHistory };
+    if (tools !== "references") {
+      return { record: withLineage, history, promptHistory };
+    }
+    const toolBlobs = {};
+    for (const hash of collectToolBlobHashes(history)) {
+      const gz = await readToolBlobGz(sessionId, hash);
+      if (gz) {
+        toolBlobs[hash] = gz.toString("base64");
+      }
+    }
+    return { record: withLineage, history, promptHistory, toolBlobs };
   }
   // Create a local session from an imported bundle. Without `replace`,
   // a bundle with a lineageId we already have on disk throws
@@ -9230,9 +9740,18 @@ var SessionManager = class {
       args.sessionId,
       args.bundle.history
     );
+    if (args.bundle.toolBlobs) {
+      for (const [hash, b64] of Object.entries(args.bundle.toolBlobs)) {
+        await writeToolBlobGz(
+          args.sessionId,
+          hash,
+          Buffer.from(b64, "base64")
+        ).catch(() => void 0);
+      }
+    }
     const sourceMtime = new Date(args.bundle.session.updatedAt);
     if (!Number.isNaN(sourceMtime.getTime())) {
-      await fs14.utimes(paths.historyFile(args.sessionId), sourceMtime, sourceMtime).catch(() => void 0);
+      await fs15.utimes(paths.historyFile(args.sessionId), sourceMtime, sourceMtime).catch(() => void 0);
     }
     if (args.bundle.promptHistory && args.bundle.promptHistory.length > 0) {
       await saveHistory(
@@ -9879,7 +10398,7 @@ function findLastTurnComplete(history) {
 }
 async function loadPromptHistorySafely(sessionId) {
   try {
-    const raw = await fs14.readFile(paths.tuiHistoryFile(sessionId), "utf8");
+    const raw = await fs15.readFile(paths.tuiHistoryFile(sessionId), "utf8");
     const out = [];
     for (const line of raw.split("\n")) {
       if (line.length === 0) {
@@ -9900,7 +10419,7 @@ async function loadPromptHistorySafely(sessionId) {
 }
 async function historyStatus(sessionId) {
   try {
-    const st = await fs14.stat(paths.historyFile(sessionId));
+    const st = await fs15.stat(paths.historyFile(sessionId));
     return {
       mtime: new Date(st.mtimeMs).toISOString(),
       hasContent: st.size > 0
@@ -9921,7 +10440,7 @@ function effectiveInteractive(record, hasContent) {
 
 // src/core/child-supervisor.ts
 import { spawn as spawn4 } from "child_process";
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 import * as fsp5 from "fs/promises";
 import * as path10 from "path";
 
@@ -10294,7 +10813,7 @@ var ChildSupervisor = class {
     }
     const cfg = entry.config;
     const command = cfg.command.length > 0 ? cfg.command : [cfg.name];
-    const logStream = fs15.createWriteStream(
+    const logStream = fs16.createWriteStream(
       this.adapter.paths.logFile(cfg.name),
       { flags: "a" }
     );
@@ -10350,7 +10869,7 @@ var ChildSupervisor = class {
     }
     if (typeof child.pid === "number") {
       try {
-        fs15.writeFileSync(
+        fs16.writeFileSync(
           this.adapter.paths.pidFile(cfg.name),
           `${child.pid}
 `,
@@ -10376,7 +10895,7 @@ var ChildSupervisor = class {
     });
     child.on("exit", (code, signal) => {
       try {
-        fs15.unlinkSync(this.adapter.paths.pidFile(cfg.name));
+        fs16.unlinkSync(this.adapter.paths.pidFile(cfg.name));
       } catch {
       }
       logStream.write(
@@ -10716,7 +11235,7 @@ function startAgentSyncScheduler(opts) {
 
 // src/core/session-tokens.ts
 import * as path12 from "path";
-import { createHash, randomBytes as randomBytes2, timingSafeEqual } from "crypto";
+import { createHash as createHash2, randomBytes as randomBytes2, timingSafeEqual } from "crypto";
 var TOKEN_PREFIX = "hydra_session_";
 var DEFAULT_TTL_SEC = 60 * 60 * 24 * 30;
 var ID_LENGTH = 12;
@@ -10726,7 +11245,7 @@ function tokensFilePath() {
   return path12.join(paths.home(), "session-tokens.json");
 }
 function sha256Hex(input) {
-  return createHash("sha256").update(input).digest("hex");
+  return createHash2("sha256").update(input).digest("hex");
 }
 function randomHex(bytes) {
   return randomBytes2(bytes).toString("hex");
@@ -11293,6 +11812,23 @@ function isExitPlanModeTool(name) {
   const normalised = name.toLowerCase().replace(/[_\s-]/g, "");
   return normalised === "exitplanmode";
 }
+function readDiffField(value) {
+  if (typeof value === "string") {
+    return { text: value };
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const v = value;
+    if (typeof v.__hydraBlob === "string") {
+      return {
+        ref: {
+          hash: v.__hydraBlob,
+          bytes: typeof v.bytes === "number" ? v.bytes : 0
+        }
+      };
+    }
+  }
+  return void 0;
+}
 function extractEditDiff(u) {
   const content = u.content;
   if (Array.isArray(content)) {
@@ -11304,16 +11840,18 @@ function extractEditDiff(u) {
       if (b.type !== "diff") {
         continue;
       }
-      const oldText = typeof b.oldText === "string" ? b.oldText : void 0;
-      const newText = typeof b.newText === "string" ? b.newText : void 0;
-      if (oldText === void 0 && newText === void 0) {
+      const oldField = readDiffField(b.oldText);
+      const newField = readDiffField(b.newText);
+      if (oldField === void 0 && newField === void 0) {
         continue;
       }
       const path15 = typeof b.path === "string" ? b.path : void 0;
       return {
         ...path15 !== void 0 ? { path: path15 } : {},
-        oldText: oldText ?? "",
-        newText: newText ?? ""
+        oldText: oldField?.text ?? "",
+        newText: newField?.text ?? "",
+        ...oldField?.ref ? { oldRef: oldField.ref } : {},
+        ...newField?.ref ? { newRef: newField.ref } : {}
       };
     }
   }
@@ -11381,8 +11919,36 @@ function mapToolCall(u) {
   if (diff !== null) {
     event.editDiff = diff;
   }
+  const detail = extractToolDetail(u);
+  if (detail !== void 0) {
+    event.detail = detail;
+  }
   return event;
 }
+var TOOL_DETAIL_MAX = 64;
+function extractToolDetail(u) {
+  const rawInput = u.rawInput;
+  if (!rawInput || typeof rawInput !== "object" || Array.isArray(rawInput)) {
+    return void 0;
+  }
+  const r = rawInput;
+  if (typeof r.command === "string" && r.command.trim().length > 0) {
+    const firstLine2 = sanitizeSingleLine(r.command).trim();
+    const cmd = firstLine2.replace(/^cd\s+\S+\s+&&\s+/, "");
+    return clipHead(cmd, TOOL_DETAIL_MAX);
+  }
+  const path15 = typeof r.file_path === "string" ? r.file_path : typeof r.path === "string" ? r.path : void 0;
+  if (path15 !== void 0 && path15.length > 0) {
+    return clipTail(shortenHomePath(sanitizeSingleLine(path15)), TOOL_DETAIL_MAX);
+  }
+  return void 0;
+}
+function clipHead(s, max) {
+  return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+}
+function clipTail(s, max) {
+  return s.length > max ? `\u2026${s.slice(-(max - 1))}` : s;
+}
 function mapToolCallUpdate(u) {
   const toolCallId = readString(u, "toolCallId") ?? readString(u, "id");
   if (!toolCallId) {
@@ -11392,7 +11958,8 @@ function mapToolCallUpdate(u) {
   const title = rawTitle !== void 0 ? sanitizeSingleLine(rawTitle) : void 0;
   const status = readString(u, "status");
   const diff = extractEditDiff(u);
-  const meaningful = title !== void 0 || diff !== null || status === "completed" || status === "failed" || status === "rejected" || status === "cancelled";
+  const detail = extractToolDetail(u);
+  const meaningful = title !== void 0 || diff !== null || detail !== void 0 || status === "completed" || status === "failed" || status === "rejected" || status === "cancelled";
   if (!meaningful) {
     return null;
   }
@@ -11412,6 +11979,9 @@ function mapToolCallUpdate(u) {
   if (title !== void 0) {
     event.title = title;
   }
+  if (detail !== void 0) {
+    event.detail = detail;
+  }
   if (status !== void 0) {
     event.status = status;
   }
@@ -12345,15 +12915,21 @@ function registerSessionRoutes(app, manager, defaults) {
   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);
+    const toolsRaw = request.query?.tools;
+    const toolMode = toolsRaw === "references" ? "references" : parseToolContentMode(toolsRaw);
+    const exported = await manager.exportBundle(
+      id,
+      toolMode === "references" ? { tools: "references" } : {}
+    );
     if (!exported) {
       reply.code(404).send({ error: "session not found" });
       return;
     }
     const bundle = encodeBundle({
       record: exported.record,
-      history: exported.history,
+      history: toolMode === "summary" ? applyToolContentMode(exported.history, "summary") : exported.history,
       promptHistory: exported.promptHistory.length > 0 ? exported.promptHistory : void 0,
+      ...exported.toolBlobs !== void 0 ? { toolBlobs: exported.toolBlobs } : {},
       hydraVersion: HYDRA_VERSION,
       machine: os3.hostname(),
       hydraHost: resolveHydraHost(defaults)
@@ -12365,6 +12941,17 @@ function registerSessionRoutes(app, manager, defaults) {
     );
     reply.code(200).send(bundle);
   });
+  app.get("/v1/sessions/:id/tools/:hash", async (request, reply) => {
+    const params = request.params;
+    const id = await manager.resolveCanonicalId(params.id) ?? params.id;
+    const blob = await manager.loadToolBlob(id, params.hash);
+    if (blob === null) {
+      reply.code(404).send({ error: "tool blob not found" });
+      return;
+    }
+    reply.header("Content-Type", "text/plain; charset=utf-8");
+    reply.code(200).send(blob);
+  });
   app.get("/v1/sessions/:id/transcript", async (request, reply) => {
     const raw = request.params.id;
     const id = await manager.resolveCanonicalId(raw) ?? raw;
@@ -12849,11 +13436,11 @@ function registerConfigRoutes(app, snapshot) {
 import { z as z8 } from "zod";
 
 // src/core/password.ts
-import * as fs16 from "fs/promises";
+import * as fs17 from "fs/promises";
 import * as path14 from "path";
 import { randomBytes as randomBytes3, scrypt, timingSafeEqual as timingSafeEqual2 } from "crypto";
-import { promisify } from "util";
-var scryptAsync = promisify(scrypt);
+import { promisify as promisify2 } from "util";
+var scryptAsync = promisify2(scrypt);
 function passwordHashPath() {
   return path14.join(paths.home(), "password-hash");
 }
@@ -12861,7 +13448,7 @@ var DEFAULT_N = 1 << 15;
 var MAX_MEM = 128 * 1024 * 1024;
 async function hasPassword() {
   try {
-    const text = await fs16.readFile(passwordHashPath(), "utf8");
+    const text = await fs17.readFile(passwordHashPath(), "utf8");
     return text.trim().length > 0;
   } catch (err) {
     const e = err;
@@ -12877,7 +13464,7 @@ async function verifyPassword(plaintext) {
   }
   let line;
   try {
-    line = (await fs16.readFile(passwordHashPath(), "utf8")).trim();
+    line = (await fs17.readFile(passwordHashPath(), "utf8")).trim();
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
@@ -13371,6 +13958,24 @@ function registerAcpWsEndpoint(app, deps) {
         return { ok: true };
       });
     }
+    connection.onRequest("hydra-acp/session/tool_content", async (raw) => {
+      const params = raw ?? {};
+      if (typeof params.sessionId !== "string" || typeof params.hash !== "string") {
+        throw Object.assign(
+          new Error("hydra-acp/session/tool_content requires sessionId and hash"),
+          { code: JsonRpcErrorCodes.InvalidParams }
+        );
+      }
+      const id = await deps.manager.resolveCanonicalId(params.sessionId) ?? params.sessionId;
+      const content = await deps.manager.loadToolBlob(id, params.hash);
+      if (content === null) {
+        throw Object.assign(
+          new Error("tool content not found"),
+          { code: JsonRpcErrorCodes.SessionNotFound }
+        );
+      }
+      return { content };
+    });
     connection.onRequest("session/new", async (raw) => {
       const params = SessionNewParams.parse(raw);
       const hydraMeta = extractHydraMeta(
@@ -13577,7 +14182,13 @@ function registerAcpWsEndpoint(app, deps) {
       const { entries: replay, appliedPolicy } = await session.attach(
         client,
         params.historyPolicy,
-        { afterMessageId: params.afterMessageId, raw: drip }
+        {
+          afterMessageId: params.afterMessageId,
+          raw: drip,
+          // Lean clients opt into ref-form tool content via _meta; default
+          // stays inline so existing/third-party clients are unaffected.
+          ...hydraAttach.toolContent !== void 0 ? { toolContent: hydraAttach.toolContent } : {}
+        }
       );
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
@@ -13611,8 +14222,13 @@ function registerAcpWsEndpoint(app, deps) {
           }
         })();
       } else {
-        for (const note of replay) {
-          await connection.notify(note.method, note.params);
+        const REPLAY_FLUSH_EVERY = 200;
+        for (let i = 0; i < replay.length; i++) {
+          const note = replay[i];
+          const pending = connection.notify(note.method, note.params).catch(() => void 0);
+          if ((i + 1) % REPLAY_FLUSH_EVERY === 0) {
+            await pending;
+          }
         }
       }
       session.replayPendingPermissions(client);
@@ -13869,8 +14485,11 @@ function registerAcpWsEndpoint(app, deps) {
         return null;
       }
       app.log.info(decision.logMessage);
-      const { modelId } = rawParams;
-      const result = await decision.session.forwardRequest("session/set_model", rawParams);
+      const { modelId } = decision;
+      const result = await decision.session.forwardRequest("session/set_model", {
+        ...rawParams,
+        modelId
+      });
       decision.session.applyModelChange(modelId);
       return result;
     });
@@ -14092,36 +14711,47 @@ function decideSetModel(rawParams, manager) {
     };
   }
   const advertised = session.availableModels();
-  if (advertised.length === 0) {
+  const resolution = resolveModelId(params.modelId, advertised);
+  if (resolution.kind === "none") {
     return {
       kind: "ok",
       session,
+      modelId: params.modelId,
       logMessage: `session/set_model passthrough (no availableModels) sessionId=${params.sessionId} modelId=${JSON.stringify(params.modelId)}`
     };
   }
-  const match = advertised.find((m) => m.modelId === params.modelId);
-  if (!match) {
-    const known = advertised.map((m) => m.modelId).join(", ");
-    if (session.currentModel !== void 0 && session.currentModel.length > 0) {
-      return {
-        kind: "no_op",
-        session,
-        sessionId: params.sessionId,
-        currentModel: session.currentModel,
-        logMessage: `session/set_model no_op (resyncing client) sessionId=${params.sessionId} requested=${JSON.stringify(params.modelId)} actual=${JSON.stringify(session.currentModel)} agentId=${session.agentId} known=[${known}]`
-      };
-    }
+  if (resolution.kind === "exact") {
     return {
-      kind: "error",
-      code: JsonRpcErrorCodes.InvalidParams,
-      message: `model "${params.modelId}" is not in this session's availableModels (agent ${session.agentId}); known models: ${known}`,
-      logMessage: `session/set_model rejected sessionId=${params.sessionId} modelId=${JSON.stringify(params.modelId)} agentId=${session.agentId} known=[${known}] (no current model to fall back to)`
+      kind: "ok",
+      session,
+      modelId: params.modelId,
+      logMessage: `session/set_model accepted sessionId=${params.sessionId} modelId=${JSON.stringify(params.modelId)}`
+    };
+  }
+  if (resolution.kind === "resolved") {
+    return {
+      kind: "ok",
+      session,
+      modelId: resolution.modelId,
+      logMessage: `session/set_model resolved sessionId=${params.sessionId} requested=${JSON.stringify(params.modelId)} \u2192 ${JSON.stringify(resolution.modelId)}`
+    };
+  }
+  const known = advertised.map((m) => m.modelId).join(", ");
+  const detail = resolution.kind === "ambiguous" ? `ambiguous (trailing-segment matches [${resolution.candidates.join(", ")}])` : `not in availableModels`;
+  if (session.currentModel !== void 0 && session.currentModel.length > 0) {
+    return {
+      kind: "no_op",
+      session,
+      sessionId: params.sessionId,
+      currentModel: session.currentModel,
+      logMessage: `session/set_model no_op (resyncing client) sessionId=${params.sessionId} requested=${JSON.stringify(params.modelId)} ${detail} actual=${JSON.stringify(session.currentModel)} agentId=${session.agentId} known=[${known}]`
     };
   }
   return {
-    kind: "ok",
-    session,
-    logMessage: `session/set_model accepted sessionId=${params.sessionId} modelId=${JSON.stringify(params.modelId)}`
+    kind: "error",
+    code: JsonRpcErrorCodes.InvalidParams,
+    message: `model "${params.modelId}" is ${detail === "not in availableModels" ? "not in this session's availableModels" : detail} (agent ${session.agentId}); known models: ${known}`,
+    logMessage: `session/set_model rejected sessionId=${params.sessionId} modelId=${JSON.stringify(params.modelId)} ${detail} agentId=${session.agentId} known=[${known}] (no current model to fall back to)`
   };
 }
 function buildViewerResponseMeta(fromDisk) {
@@ -14921,6 +15551,7 @@ async function startDaemon(config, serviceToken) {
     stderrTailBytes: config.daemon.agentStderrTailBytes,
     logger: agentLogger
   });
+  setToolBlobCompression(config.compressToolContent);
   const extensionCommands = new ExtensionCommandRegistry();
   const manager = new SessionManager(registry, spawner, void 0, {
     idleTimeoutMs: config.daemon.sessionIdleTimeoutSeconds * 1e3,
@@ -15052,7 +15683,7 @@ async function startDaemon(config, serviceToken) {
     setAgentPruneLogger(null);
     await app.close();
     try {
-      fs17.unlinkSync(paths.pidFile());
+      fs18.unlinkSync(paths.pidFile());
     } catch {
     }
     try {