@hydra-acp/cli 0.1.48 → 0.1.50

package/dist/index.js

@@ -1304,6 +1304,9 @@ function extractHydraMeta(meta) {
   if (typeof obj.promptUpdating === "boolean") {
     out.promptUpdating = obj.promptUpdating;
   }
+  if (typeof obj.mcpStdin === "boolean") {
+    out.mcpStdin = obj.mcpStdin;
+  }
   if (typeof obj.promptAmending === "boolean") {
     out.promptAmending = obj.promptAmending;
   }
@@ -1419,6 +1422,10 @@ var SessionListEntry = z3.object({
   importedFromUpstreamSessionId: z3.string().optional(),
   // Set when this session was spawned as a child by a transformer.
   parentSessionId: z3.string().optional(),
+  // clientInfo from the process that issued session/new. Lets list views
+  // hide cat-style ancillary sessions by default while letting an
+  // override flag surface them.
+  originatingClient: z3.object({ name: z3.string(), version: z3.string().optional() }).optional(),
   updatedAt: z3.string(),
   attachedClients: z3.number().int().nonnegative(),
   status: z3.enum(["live", "cold"]).default("live"),
@@ -1757,7 +1764,10 @@ var JsonRpcConnection = class _JsonRpcConnection {
   // every entry would be re-appended to history.jsonl, doubling the log
   // each time the session was woken up.
   drainBuffered(method) {
+    const buf = this.bufferedNotifications.get(method);
+    const count = buf?.length ?? 0;
     this.bufferedNotifications.delete(method);
+    return count;
   }
   onClose(handler) {
     this.closeHandlers.push(handler);
@@ -2018,14 +2028,30 @@ import { customAlphabet } from "nanoid";
 
 // src/core/stream-buffer.ts
 import * as fsp3 from "fs/promises";
-var DEFAULT_CAPACITY_BYTES = 16 * 1024 * 1024;
+var DEFAULT_CAPACITY_BYTES = 64 * 1024 * 1024;
+var INITIAL_CAPACITY_BYTES = 1 * 1024 * 1024;
 var STREAM_READ_MAX_BYTES = 64 * 1024;
 var STREAM_WAIT_MAX_MS = 6e4;
+var STREAM_GREP_DEFAULT_MATCHES = 100;
+var STREAM_GREP_MAX_MATCHES = 1e3;
+var STREAM_GREP_DEFAULT_BYTES = 64 * 1024;
+var STREAM_GREP_MAX_BYTES = 256 * 1024;
+var STREAM_GREP_MAX_CONTEXT = 20;
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 var SessionStreamBuffer = class {
   storage;
-  capacityBytes;
+  // The configured cap. Eviction begins once writeCursor exceeds this.
+  maxCapacityBytes;
+  // The size of the currently-allocated `storage`. Starts at
+  // INITIAL_CAPACITY_BYTES (clamped to maxCapacityBytes) and doubles on
+  // demand. Once it reaches maxCapacityBytes the ring behaves like a
+  // fixed-size buffer; before then, writeCursor < currentCapacityBytes
+  // always, so no wrap-around math is in play.
+  currentCapacityBytes;
   // Absolute monotonic byte offset of the next byte to be written. Also
-  // the count of bytes ever appended. `writeCursor - capacityBytes`
+  // the count of bytes ever appended. `writeCursor - currentCapacityBytes`
   // (clamped at 0) is the oldest still-resident byte's cursor.
   writeCursor = 0;
   closed = false;
@@ -2040,24 +2066,33 @@ var SessionStreamBuffer = class {
   // calls don't interleave their writes.
   fileWriteChain = Promise.resolve();
   constructor(opts = {}) {
-    this.capacityBytes = opts.capacityBytes ?? DEFAULT_CAPACITY_BYTES;
-    if (this.capacityBytes <= 0) {
+    this.maxCapacityBytes = opts.capacityBytes ?? DEFAULT_CAPACITY_BYTES;
+    if (this.maxCapacityBytes <= 0) {
       throw new Error("capacityBytes must be > 0");
     }
-    this.storage = Buffer.alloc(this.capacityBytes);
+    this.currentCapacityBytes = Math.min(
+      INITIAL_CAPACITY_BYTES,
+      this.maxCapacityBytes
+    );
+    this.storage = Buffer.alloc(this.currentCapacityBytes);
     this.filePath = opts.filePath;
     this.fileCapBytes = opts.fileCapBytes ?? Number.POSITIVE_INFINITY;
     this.onFileCapReached = opts.onFileCapReached;
     this.logWriteError = opts.logWriteError;
   }
   get capacity() {
-    return this.capacityBytes;
+    return this.maxCapacityBytes;
+  }
+  // Currently-allocated storage size (for observability / tests). May be
+  // anywhere between INITIAL_CAPACITY_BYTES and capacity.
+  get allocatedBytes() {
+    return this.currentCapacityBytes;
   }
   get writeCursorPos() {
     return this.writeCursor;
   }
   get oldestAvailable() {
-    return Math.max(0, this.writeCursor - this.capacityBytes);
+    return Math.max(0, this.writeCursor - this.currentCapacityBytes);
   }
   get isClosed() {
     return this.closed;
@@ -2202,6 +2237,136 @@ var SessionStreamBuffer = class {
       this.waiters.push(waiter);
     });
   }
+  // Scan the resident region line-by-line, returning lines that match
+  // `pattern`. Server-side filtering so the agent doesn't have to pull
+  // and decode 64 KiB base64 windows just to grep a multi-MB log.
+  //
+  // Lines are split on `\n` (LF). A trailing partial line (no LF) is
+  // skipped when the buffer is still open — its bytes might be the
+  // start of a longer line that's still being written — but is treated
+  // as a final full line once the buffer is closed.
+  //
+  // Caps: max 1000 matches and 256 KiB of output bytes per call. The
+  // agent should re-call with `cursor = nextCursor` to resume when
+  // `truncated:true`.
+  grep(opts) {
+    const oldest = this.oldestAvailable;
+    const requested = opts.cursor;
+    let start = requested ?? oldest;
+    let gap = 0;
+    if (requested !== void 0 && requested < oldest) {
+      gap = oldest - requested;
+      start = oldest;
+    }
+    if (start > this.writeCursor) {
+      start = this.writeCursor;
+    }
+    const slice = this.sliceFromRing(start, this.writeCursor - start);
+    const useRegex = opts.regex ?? true;
+    const flags = opts.caseInsensitive === true ? "i" : "";
+    const re = useRegex ? new RegExp(opts.pattern, flags) : new RegExp(escapeRegex(opts.pattern), flags);
+    const invert = opts.invert ?? false;
+    const maxMatches = Math.max(
+      1,
+      Math.min(
+        opts.maxMatches ?? STREAM_GREP_DEFAULT_MATCHES,
+        STREAM_GREP_MAX_MATCHES
+      )
+    );
+    const maxBytes = Math.max(
+      1,
+      Math.min(opts.maxBytes ?? STREAM_GREP_DEFAULT_BYTES, STREAM_GREP_MAX_BYTES)
+    );
+    const contextBefore = Math.max(
+      0,
+      Math.min(opts.contextBefore ?? 0, STREAM_GREP_MAX_CONTEXT)
+    );
+    const contextAfter = Math.max(
+      0,
+      Math.min(opts.contextAfter ?? 0, STREAM_GREP_MAX_CONTEXT)
+    );
+    const matches = [];
+    const beforeRing = [];
+    const pendingAfter = [];
+    let bytesUsed = 0;
+    let truncated = false;
+    let lineStartByte = 0;
+    let resumeFromLineStart = 0;
+    const processLine = (lineCursor, lineText) => {
+      for (const pa of pendingAfter) {
+        if (pa.remaining > 0) {
+          if (pa.match.after === void 0) {
+            pa.match.after = [];
+          }
+          pa.match.after.push({ cursor: lineCursor, line: lineText });
+          pa.remaining--;
+          bytesUsed += lineText.length;
+        }
+      }
+      while (pendingAfter.length > 0 && pendingAfter[0].remaining === 0) {
+        pendingAfter.shift();
+      }
+      const matched = re.test(lineText) !== invert;
+      if (matched && matches.length < maxMatches) {
+        const m = { cursor: lineCursor, line: lineText };
+        if (contextBefore > 0 && beforeRing.length > 0) {
+          m.before = beforeRing.slice();
+          for (const b of m.before) {
+            bytesUsed += b.line.length;
+          }
+        }
+        bytesUsed += lineText.length;
+        matches.push(m);
+        if (contextAfter > 0) {
+          pendingAfter.push({ match: m, remaining: contextAfter });
+        }
+      }
+      if (contextBefore > 0) {
+        beforeRing.push({ cursor: lineCursor, line: lineText });
+        while (beforeRing.length > contextBefore) {
+          beforeRing.shift();
+        }
+      }
+      const hitMaxMatches = matches.length >= maxMatches && pendingAfter.length === 0;
+      const hitMaxBytes = bytesUsed >= maxBytes;
+      return hitMaxMatches || hitMaxBytes;
+    };
+    for (let i = 0; i < slice.length; i++) {
+      if (slice[i] !== 10) {
+        continue;
+      }
+      const lineText = slice.subarray(lineStartByte, i).toString("utf8");
+      const lineCursor = start + lineStartByte;
+      lineStartByte = i + 1;
+      resumeFromLineStart = lineStartByte;
+      if (processLine(lineCursor, lineText)) {
+        truncated = true;
+        break;
+      }
+    }
+    if (!truncated && lineStartByte < slice.length && this.closed) {
+      const lineText = slice.subarray(lineStartByte).toString("utf8");
+      const lineCursor = start + lineStartByte;
+      if (processLine(lineCursor, lineText)) {
+        truncated = true;
+      }
+      resumeFromLineStart = slice.length;
+    }
+    const nextCursor = Math.min(start + resumeFromLineStart, this.writeCursor);
+    const result = {
+      matches,
+      truncated,
+      nextCursor,
+      scannedBytes: resumeFromLineStart
+    };
+    if (gap > 0) {
+      result.gap = gap;
+    }
+    if (this.closed && nextCursor >= this.writeCursor) {
+      result.eof = true;
+    }
+    return result;
+  }
   wakeWaiters(outcome) {
     if (this.waiters.length === 0) {
       return;
@@ -2212,15 +2377,42 @@ var SessionStreamBuffer = class {
       w.resolve(outcome);
     }
   }
+  // Grow `storage` if needed to fit `additionalBytes` more bytes without
+  // wrapping. Caps at maxCapacityBytes; once we're at the cap, callers
+  // fall back to ring-wrap behavior. Doubles each grow so we amortize.
+  // Only called before we've ever wrapped (writeCursor < currentCapacity
+  // always holds while we're growing), so the existing bytes live at
+  // storage[0..writeCursor] and we can just copy them flat.
+  growIfNeeded(additionalBytes) {
+    if (this.currentCapacityBytes >= this.maxCapacityBytes) {
+      return;
+    }
+    const needed = this.writeCursor + additionalBytes;
+    if (needed <= this.currentCapacityBytes) {
+      return;
+    }
+    let next = this.currentCapacityBytes;
+    while (next < needed && next < this.maxCapacityBytes) {
+      next = Math.min(this.maxCapacityBytes, next * 2);
+    }
+    if (next === this.currentCapacityBytes) {
+      return;
+    }
+    const newStorage = Buffer.alloc(next);
+    this.storage.copy(newStorage, 0, 0, this.writeCursor);
+    this.storage = newStorage;
+    this.currentCapacityBytes = next;
+  }
   writeRing(chunk) {
     const len = chunk.length;
-    if (len >= this.capacityBytes) {
-      const tailStart = len - this.capacityBytes;
+    this.growIfNeeded(len);
+    if (len >= this.currentCapacityBytes) {
+      const tailStart = len - this.currentCapacityBytes;
       chunk.copy(this.storage, 0, tailStart, len);
       return;
     }
-    const offset = this.writeCursor % this.capacityBytes;
-    const tailRoom = this.capacityBytes - offset;
+    const offset = this.writeCursor % this.currentCapacityBytes;
+    const tailRoom = this.currentCapacityBytes - offset;
     if (len <= tailRoom) {
       chunk.copy(this.storage, offset, 0, len);
     } else {
@@ -2233,8 +2425,8 @@ var SessionStreamBuffer = class {
       return Buffer.alloc(0);
     }
     const out = Buffer.alloc(length);
-    const offset = fromCursor % this.capacityBytes;
-    const tailLen = Math.min(length, this.capacityBytes - offset);
+    const offset = fromCursor % this.currentCapacityBytes;
+    const tailLen = Math.min(length, this.currentCapacityBytes - offset);
     this.storage.copy(out, 0, offset, offset + tailLen);
     if (tailLen < length) {
       this.storage.copy(out, tailLen, 0, length - tailLen);
@@ -2376,6 +2568,7 @@ var Session = class {
   agentCapabilities;
   agentArgs;
   parentSessionId;
+  originatingClient;
   title;
   // Snapshot state delivered to attaching clients via the attach
   // response _meta rather than via history replay (which would be
@@ -2453,6 +2646,8 @@ var Session = class {
   listSessions;
   logger;
   transformChain;
+  extensionCommands;
+  extensionCommandsUnsub;
   // Outstanding "processing" claims: token → claim waiting for respondsTo discharge.
   pendingClaims = /* @__PURE__ */ new Map();
   agentChangeHandlers = [];
@@ -2528,6 +2723,7 @@ var Session = class {
     this.agentCapabilities = init.agentCapabilities;
     this.agentArgs = init.agentArgs;
     this.parentSessionId = init.parentSessionId;
+    this.originatingClient = init.originatingClient;
     this.title = init.title;
     this.currentModel = init.currentModel;
     this.currentMode = init.currentMode;
@@ -2548,6 +2744,14 @@ var Session = class {
     this.listSessions = init.listSessions;
     this.logger = init.logger;
     this.transformChain = init.transformChain ?? [];
+    this.extensionCommands = init.extensionCommands;
+    if (this.extensionCommands) {
+      this.extensionCommandsUnsub = this.extensionCommands.onChange(() => {
+        if (!this.closed) {
+          this.broadcastMergedCommands();
+        }
+      });
+    }
     if (init.firstPromptSeeded) {
       this.firstPromptSeeded = true;
     }
@@ -2562,18 +2766,11 @@ var Session = class {
     this.notifyChain("session.opened", {});
   }
   broadcastMergedCommands() {
-    const merged = [
-      ...hydraCommandsAsAdvertised(),
-      { name: "model <model-id>", description: "Switch model; omit arg to list available models" },
-      { name: "sessions", description: "List all sessions" },
-      { name: "help", description: "Show available commands" },
-      ...this.agentAdvertisedCommands
-    ];
     this.recordAndBroadcast("session/update", {
       sessionId: this.upstreamSessionId,
       update: {
         sessionUpdate: "available_commands_update",
-        availableCommands: merged
+        availableCommands: this.mergedAvailableCommands()
       }
     });
   }
@@ -3736,6 +3933,9 @@ var Session = class {
     if (!trimmed || trimmed === this.currentModel) {
       return true;
     }
+    this.logger?.info(
+      `live current_model_update: sessionId=${this.sessionId} ${JSON.stringify(this.currentModel)} \u2192 ${JSON.stringify(trimmed)}`
+    );
     this.currentModel = trimmed;
     for (const handler of this.modelHandlers) {
       try {
@@ -3781,6 +3981,9 @@ var Session = class {
       if (typeof cv === "string") {
         const trimmed = cv.trim();
         if (trimmed && trimmed !== this.currentModel) {
+          this.logger?.info(
+            `live config_option_update(model): sessionId=${this.sessionId} ${JSON.stringify(this.currentModel)} \u2192 ${JSON.stringify(trimmed)}`
+          );
           this.currentModel = trimmed;
           for (const handler of this.modelHandlers) {
             try {
@@ -3949,6 +4152,9 @@ var Session = class {
     this.broadcastAvailableModes();
   }
   setAgentAdvertisedModels(models) {
+    this.logger?.info(
+      `setAgentAdvertisedModels: sessionId=${this.sessionId} currentModel=${JSON.stringify(this.currentModel)} newList=[${models.map((m) => m.modelId).join(",")}]`
+    );
     if (sameAdvertisedModels(this.agentAdvertisedModels, models)) {
       this.broadcastAvailableModels();
       return;
@@ -3980,6 +4186,38 @@ var Session = class {
   onModeChange(handler) {
     this.modeHandlers.push(handler);
   }
+  // Apply a model change initiated by a client request (session/set_model)
+  // when the agent doesn't emit a current_model_update notification, or
+  // emits a non-spec shape (e.g. config_option_update). Fires modelHandlers
+  // (persistence) and broadcasts a synthetic current_model_update so all
+  // attached clients — including the originator — repaint immediately.
+  applyModelChange(modelId) {
+    const trimmed = modelId.trim();
+    if (!trimmed || trimmed === this.currentModel) {
+      return;
+    }
+    this.logger?.info(
+      `applyModelChange: sessionId=${this.sessionId} ${JSON.stringify(this.currentModel)} \u2192 ${JSON.stringify(trimmed)}`
+    );
+    this.currentModel = trimmed;
+    for (const handler of this.modelHandlers) {
+      try {
+        handler(trimmed);
+      } catch {
+      }
+    }
+    const update = {
+      sessionUpdate: "current_model_update",
+      currentModel: trimmed
+    };
+    if (this.agentAdvertisedModels.length > 0) {
+      update.availableModels = [...this.agentAdvertisedModels];
+    }
+    this.recordAndBroadcast("session/update", {
+      sessionId: this.upstreamSessionId,
+      update
+    });
+  }
   // Apply a mode change initiated by a client request (session/set_mode)
   // when the agent doesn't emit a current_mode_update notification on its
   // own. Fires modeHandlers so the persistence hook and any other listeners
@@ -4003,11 +4241,31 @@ var Session = class {
   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.
+  // Returns a freshly merged command list (hydra ∪ extension ∪ agent) for
+  // callers that need a snapshot — notably acp-ws.ts's buildResponseMeta
+  // when assembling the attach response. Order: built-in hydra verbs,
+  // top-level daemon verbs (/model, /sessions, /help), extension-registered
+  // entries, then whatever the agent advertised.
   mergedAvailableCommands() {
-    return [...hydraCommandsAsAdvertised(), ...this.agentAdvertisedCommands];
+    const out = [
+      ...hydraCommandsAsAdvertised(),
+      { name: "model <model-id>", description: "Switch model; omit arg to list available models" },
+      { name: "sessions", description: "List all sessions" },
+      { name: "help", description: "Show available commands" }
+    ];
+    if (this.extensionCommands) {
+      for (const { name, command } of this.extensionCommands.list()) {
+        const head = `hydra ${name} ${command.verb}`;
+        const display = command.argsHint ? `${head} ${command.argsHint}` : head;
+        const entry = { name: display };
+        if (command.description) {
+          entry.description = command.description;
+        }
+        out.push(entry);
+      }
+    }
+    out.push(...this.agentAdvertisedCommands);
+    return out;
   }
   // The agent's own advertised commands (not merged with hydra verbs).
   // Used by SessionManager to persist into meta.json so cold resurrect
@@ -4059,39 +4317,118 @@ var Session = class {
   // caller's promise resolves like a normal turn. To add a verb: append
   // an entry to HYDRA_COMMANDS (drives validation + client advertising)
   // and a dispatch case in the switch below.
+  //
+  // Extensions/transformers can also bind verbs via the
+  // ExtensionCommandRegistry: "/hydra <process-name> <verb> [args]" routes
+  // to that process's WS connection. Built-in hydra verbs win on name
+  // collision so an extension can never shadow them.
   async handleSlashCommand(text) {
     const rest = text.slice("/hydra".length).trim();
     const match = rest.match(/^(\S+)(?:\s+([\s\S]*))?$/);
-    const verb = match?.[1] ?? "";
-    const arg = (match?.[2] ?? "").trim();
-    if (verb === "") {
+    const first = match?.[1] ?? "";
+    const remainder = (match?.[2] ?? "").trim();
+    if (first === "") {
       return { stopReason: "end_turn" };
     }
-    if (!HYDRA_COMMANDS.some((c) => c.verb === verb)) {
-      const known = HYDRA_COMMANDS.map((c) => c.verb).join(", ");
-      const err = new Error(
-        `unknown /hydra verb: ${verb} (known: ${known})`
-      );
-      err.code = JsonRpcErrorCodes.InvalidParams;
-      throw err;
+    if (HYDRA_COMMANDS.some((c) => c.verb === first)) {
+      switch (first) {
+        case "title":
+          return this.runTitleCommand(remainder);
+        case "agent":
+          return this.runAgentCommand(remainder);
+        case "kill":
+          return this.runKillCommand();
+        case "restart":
+          return this.runRestartCommand();
+        default: {
+          const err2 = new Error(
+            `no dispatcher for /hydra verb ${first}`
+          );
+          err2.code = JsonRpcErrorCodes.InternalError;
+          throw err2;
+        }
+      }
     }
-    switch (verb) {
-      case "title":
-        return this.runTitleCommand(arg);
-      case "agent":
-        return this.runAgentCommand(arg);
-      case "kill":
-        return this.runKillCommand();
-      case "restart":
-        return this.runRestartCommand();
-      default: {
-        const err = new Error(
-          `no dispatcher for /hydra verb ${verb}`
-        );
-        err.code = JsonRpcErrorCodes.InternalError;
-        throw err;
+    if (this.extensionCommands?.has(first)) {
+      return this.runExtensionCommand(first, remainder);
+    }
+    const known = HYDRA_COMMANDS.map((c) => c.verb);
+    if (this.extensionCommands) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const { name } of this.extensionCommands.list()) {
+        if (!seen.has(name)) {
+          known.push(name);
+          seen.add(name);
+        }
       }
     }
+    const err = new Error(
+      `unknown /hydra verb: ${first} (known: ${known.join(", ")})`
+    );
+    err.code = JsonRpcErrorCodes.InvalidParams;
+    throw err;
+  }
+  // "/hydra <name> <verb> [args]" — name matches a registered extension
+  // or transformer. We split the remainder into verb + args, validate the
+  // verb against what the process advertised, and forward as a
+  // hydra-acp/extension_command request on the process's WS connection.
+  // The reply's text (if any) is broadcast as a synthetic
+  // agent_message_chunk so it appears in the conversation alongside the
+  // user's invocation.
+  runExtensionCommand(name, remainder) {
+    return this.enqueuePrompt(async () => {
+      const entry = this.extensionCommands?.get(name);
+      if (!entry) {
+        return this.emitExtensionReply(
+          `extension "${name}" is no longer connected`
+        );
+      }
+      const m = remainder.match(/^(\S+)(?:\s+([\s\S]*))?$/);
+      const verb = m?.[1] ?? "";
+      const args = (m?.[2] ?? "").trim();
+      if (verb === "") {
+        const verbs = entry.commands.map((c) => c.verb).join(", ");
+        return this.emitExtensionReply(
+          `/hydra ${name} requires a verb (known: ${verbs || "(none)"})`
+        );
+      }
+      if (!entry.commands.some((c) => c.verb === verb)) {
+        const verbs = entry.commands.map((c) => c.verb).join(", ");
+        return this.emitExtensionReply(
+          `unknown verb "${verb}" for ${name} (known: ${verbs || "(none)"})`
+        );
+      }
+      let reply;
+      try {
+        reply = await entry.connection.request("hydra-acp/extension_command", {
+          sessionId: this.sessionId,
+          verb,
+          args
+        });
+      } catch (err) {
+        return this.emitExtensionReply(
+          `${name} ${verb}: ${err.message}`
+        );
+      }
+      const text = reply && typeof reply === "object" && typeof reply.text === "string" ? reply.text : "";
+      if (text.length > 0) {
+        return this.emitExtensionReply(text);
+      }
+      return { stopReason: "end_turn" };
+    });
+  }
+  emitExtensionReply(text) {
+    this.recordAndBroadcast("session/update", {
+      sessionId: this.upstreamSessionId,
+      update: {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: `
+${text}
+` },
+        _meta: { "hydra-acp": { synthetic: true } }
+      }
+    });
+    return { stopReason: "end_turn" };
   }
   async handleSessionsCommand() {
     let text;
@@ -4154,11 +4491,15 @@ ${text}
       if (models.length === 0) {
         body = current ? `Current model: ${current}` : "_(no models advertised yet)_";
       } else {
+        const inList = current ? models.some((m) => m.modelId === current) : true;
         const lines = models.map((m) => {
           const marker = m.modelId === current ? " \u25C0" : "";
           const desc = m.name && m.name !== m.modelId ? `  ${m.name}` : "";
           return `${m.modelId}${marker}${desc}`;
         });
+        if (!inList && current) {
+          lines.unshift(`${current} \u25C0`);
+        }
         body = lines.join("\n");
       }
       this.recordAndBroadcast("session/update", {
@@ -4570,6 +4911,43 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
     }
     return out;
   }
+  streamTail(bytes) {
+    const buf = this.requireStreamBuffer();
+    const r = buf.tail(bytes);
+    return {
+      bytes: r.bytes.toString("base64"),
+      startCursor: r.startCursor,
+      endCursor: r.endCursor,
+      truncated: r.truncated
+    };
+  }
+  streamHead(bytes) {
+    const buf = this.requireStreamBuffer();
+    const r = buf.head(bytes);
+    return {
+      bytes: r.bytes.toString("base64"),
+      startCursor: r.startCursor,
+      endCursor: r.endCursor,
+      truncated: r.truncated
+    };
+  }
+  async streamWaitFor(cursor, timeoutMs) {
+    const buf = this.requireStreamBuffer();
+    return buf.waitForData(cursor, timeoutMs);
+  }
+  streamGrep(opts) {
+    const buf = this.requireStreamBuffer();
+    return buf.grep(opts);
+  }
+  streamInfo() {
+    const buf = this.requireStreamBuffer();
+    return {
+      writeCursor: buf.writeCursorPos,
+      oldestAvailable: buf.oldestAvailable,
+      capacity: buf.capacity,
+      closed: buf.isClosed
+    };
+  }
   requireStreamBuffer() {
     if (this.streamBuffer === void 0) {
       const err = new Error(
@@ -4586,6 +4964,10 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
     }
     this.closed = true;
     this.cancelIdleTimer();
+    if (this.extensionCommandsUnsub) {
+      this.extensionCommandsUnsub();
+      this.extensionCommandsUnsub = void 0;
+    }
     if (this.currentEntry?.kind === "user") {
       this.broadcastTurnComplete(
         this.currentEntry.clientId,
@@ -5325,6 +5707,10 @@ var PersistedUsage = z4.object({
   costCurrency: z4.string().optional(),
   cumulativeCost: z4.number().optional()
 });
+var PersistedOriginatingClient = z4.object({
+  name: z4.string(),
+  version: z4.string().optional()
+});
 var SessionRecord = z4.object({
   version: z4.literal(1),
   sessionId: z4.string(),
@@ -5375,6 +5761,10 @@ var SessionRecord = z4.object({
   // Set when this session was spawned as a child by a transformer via
   // hydra-acp/spawn_child_session. Points to the spawning session's id.
   parentSessionId: z4.string().optional(),
+  // clientInfo from the process that issued session/new. Picker and
+  // `sessions list` use this to hide cat-style ancillary sessions by
+  // default; carried in meta.json so cold sessions filter the same way.
+  originatingClient: PersistedOriginatingClient.optional(),
   createdAt: z4.string(),
   updatedAt: z4.string()
 });
@@ -5497,6 +5887,7 @@ function recordFromMemorySession(args) {
     agentModels: args.agentModels,
     pendingHistorySync: args.pendingHistorySync,
     parentSessionId: args.parentSessionId,
+    originatingClient: args.originatingClient,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
   };
@@ -5711,6 +6102,7 @@ var SessionManager = class {
     this.defaultTransformers = options.defaultTransformers ?? [];
     this.logger = options.logger;
     this.npmRegistry = options.npmRegistry;
+    this.extensionCommands = options.extensionCommands;
   }
   registry;
   sessions = /* @__PURE__ */ new Map();
@@ -5729,6 +6121,7 @@ var SessionManager = class {
   metaWriteQueues = /* @__PURE__ */ new Map();
   logger;
   npmRegistry;
+  extensionCommands;
   async create(params) {
     const fresh = await this.bootstrapAgent({
       agentId: params.agentId,
@@ -5782,7 +6175,9 @@ var SessionManager = class {
       agentModes: fresh.initialModes,
       agentModels: fresh.initialModels,
       transformChain: params.transformChain,
-      parentSessionId: params.parentSessionId
+      parentSessionId: params.parentSessionId,
+      originatingClient: params.originatingClient,
+      extensionCommands: this.extensionCommands
     });
     await this.attachManagerHooks(session);
     return session;
@@ -5853,12 +6248,14 @@ var SessionManager = class {
     }
     let loadResult;
     try {
+      const loadMeta = buildSessionLoadMeta(params.agentId, params.currentModel);
       loadResult = await agent.connection.request(
         "session/load",
         {
           sessionId: params.upstreamSessionId,
           cwd: params.cwd,
-          mcpServers: []
+          mcpServers: [],
+          ...loadMeta && { _meta: loadMeta }
         }
       );
     } catch (err) {
@@ -5874,7 +6271,10 @@ var SessionManager = class {
         () => void 0
       );
     } else {
-      agent.connection.drainBuffered("session/update");
+      const drain1Count = agent.connection.drainBuffered("session/update");
+      this.logger?.info(
+        `resurrect: drain1 dropped ${drain1Count} buffered session/update(s) for sessionId=${params.hydraSessionId}`
+      );
     }
     const agentReportedMode = extractInitialCurrentMode(loadResult ?? {});
     const advertisedModes = params.agentModes ?? nonEmptyOrUndefined(extractInitialModes(loadResult ?? {}));
@@ -5892,6 +6292,30 @@ var SessionManager = class {
     this.logger?.info(
       `resurrect: effectiveMode=${JSON.stringify(effectiveMode)} for sessionId=${params.hydraSessionId}`
     );
+    const agentReportedModel = extractInitialModel(loadResult ?? {});
+    const advertisedModels = nonEmptyOrUndefined(extractInitialModels(loadResult ?? {})) ?? params.agentModels;
+    this.logger?.info(
+      `resurrect: sessionId=${params.hydraSessionId} persistedModel=${JSON.stringify(params.currentModel)} agentReportedModel=${JSON.stringify(agentReportedModel)} advertisedModels=${JSON.stringify(advertisedModels?.map((m) => m.modelId))}`
+    );
+    if (params.pendingHistorySync !== true) {
+      const drain2Count = agent.connection.drainBuffered("session/update");
+      this.logger?.info(
+        `resurrect: drain2 (post-mode-restore) dropped ${drain2Count} buffered session/update(s) for sessionId=${params.hydraSessionId}`
+      );
+    }
+    const effectiveModel = await restoreCurrentModel({
+      agent,
+      upstreamSessionId: params.upstreamSessionId,
+      persistedModel: params.currentModel,
+      agentReportedModel,
+      logger: this.logger
+    });
+    if (params.pendingHistorySync !== true) {
+      const drain3Count = agent.connection.drainBuffered("session/update");
+      this.logger?.info(
+        `resurrect: drain3 (post-model-restore) dropped ${drain3Count} buffered session/update(s) for sessionId=${params.hydraSessionId}`
+      );
+    }
     const session = new Session({
       sessionId: params.hydraSessionId,
       cwd: params.cwd,
@@ -5908,11 +6332,7 @@ var SessionManager = class {
       listSessions: () => this.list(),
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
-      // 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 ?? {}),
+      currentModel: effectiveModel,
       currentMode: effectiveMode,
       currentUsage: params.currentUsage,
       agentCommands: params.agentCommands,
@@ -5921,13 +6341,15 @@ var SessionManager = class {
       // snapshot — the proxy's available models can change between daemon
       // restarts (quota resets, rollouts), so meta.json is intentionally
       // treated as a cold fallback here, not the authoritative source.
-      agentModels: nonEmptyOrUndefined(extractInitialModels(loadResult ?? {})) ?? params.agentModels,
+      agentModels: advertisedModels,
       // Only gate the first-prompt title heuristic when we actually have
       // a title to preserve. A title-less session (lost to a write race
       // or never seeded) should re-derive from the next prompt rather
       // than stay stuck.
       firstPromptSeeded: !!params.title,
-      createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0
+      createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0,
+      originatingClient: params.originatingClient,
+      extensionCommands: this.extensionCommands
     });
     await this.attachManagerHooks(session);
     return session;
@@ -5946,7 +6368,11 @@ var SessionManager = class {
       cwd,
       agentArgs: params.agentArgs,
       mcpServers: [],
-      onInstallProgress: params.onInstallProgress
+      onInstallProgress: params.onInstallProgress,
+      // Pass the persisted model so bootstrapAgent calls session/set_model
+      // during session/new — the only context where the agent reliably
+      // honours the switch.
+      model: params.currentModel
     });
     const advertisedModes = params.agentModes ?? fresh.initialModes;
     const effectiveMode = await restoreCurrentMode({
@@ -5957,6 +6383,15 @@ var SessionManager = class {
       advertisedModes,
       logger: this.logger
     });
+    const advertisedModels = params.agentModels ?? fresh.initialModels;
+    const effectiveModel = await restoreCurrentModel({
+      agent: fresh.agent,
+      upstreamSessionId: fresh.upstreamSessionId,
+      persistedModel: params.currentModel,
+      agentReportedModel: fresh.initialModel,
+      logger: this.logger
+    });
+    fresh.agent.connection.drainBuffered("session/update");
     const session = new Session({
       sessionId: params.hydraSessionId,
       cwd,
@@ -5973,16 +6408,16 @@ var SessionManager = class {
       listSessions: () => this.list(),
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
-      // 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,
+      currentModel: effectiveModel,
       currentMode: effectiveMode,
       currentUsage: params.currentUsage,
       agentCommands: params.agentCommands,
       agentModes: advertisedModes,
-      agentModels: params.agentModels ?? fresh.initialModels,
+      agentModels: advertisedModels,
       firstPromptSeeded: !!params.title,
-      createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0
+      createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0,
+      originatingClient: params.originatingClient,
+      extensionCommands: this.extensionCommands
     });
     await this.attachManagerHooks(session);
     void session.seedFromImport().catch(() => void 0);
@@ -6331,7 +6766,8 @@ var SessionManager = class {
       agentModes: record.agentModes,
       agentModels: record.agentModels,
       createdAt: record.createdAt,
-      pendingHistorySync: record.pendingHistorySync
+      pendingHistorySync: record.pendingHistorySync,
+      originatingClient: record.originatingClient
     };
   }
   async clearPendingHistorySync(sessionId) {
@@ -6432,6 +6868,7 @@ var SessionManager = class {
         currentModel: session.currentModel,
         currentUsage: session.currentUsage,
         parentSessionId: session.parentSessionId,
+        originatingClient: session.originatingClient,
         updatedAt: used,
         attachedClients: session.attachedCount,
         status: "live",
@@ -6461,6 +6898,7 @@ var SessionManager = class {
         importedFromMachine: r.importedFromMachine,
         importedFromUpstreamSessionId: r.importedFromUpstreamSessionId,
         parentSessionId: r.parentSessionId,
+        originatingClient: r.originatingClient,
         updatedAt: used,
         attachedClients: 0,
         status: "cold",
@@ -6806,6 +7244,7 @@ function mergeForPersistence(session, existing) {
     agentModes,
     agentModels,
     parentSessionId: session.parentSessionId ?? existing?.parentSessionId,
+    originatingClient: session.originatingClient ?? existing?.originatingClient,
     createdAt: existing?.createdAt ?? new Date(session.createdAt).toISOString()
   });
 }
@@ -6834,6 +7273,13 @@ function usageSnapshotToPersisted(usage) {
 function persistedUsageToSnapshot(usage) {
   return usage ? { ...usage } : void 0;
 }
+function buildSessionLoadMeta(agentId, model) {
+  if (!model)
+    return void 0;
+  if (agentId === "claude-acp")
+    return { claudeCode: { options: { model } } };
+  return void 0;
+}
 function extractInitialModel(result) {
   const direct = asString(result.currentModelId) ?? asString(result.currentModel) ?? asString(result.modelId) ?? asString(result.model);
   if (direct) {
@@ -7013,6 +7459,33 @@ async function restoreCurrentMode(opts) {
     return agentReportedMode;
   }
 }
+async function restoreCurrentModel(opts) {
+  const { agent, upstreamSessionId, persistedModel, agentReportedModel, logger } = opts;
+  if (!persistedModel) {
+    return agentReportedModel;
+  }
+  if (persistedModel === agentReportedModel) {
+    return persistedModel;
+  }
+  try {
+    logger?.info(
+      `resurrect: pushing persisted modelId=${JSON.stringify(persistedModel)} to agent (agentReported=${JSON.stringify(agentReportedModel)})`
+    );
+    await agent.connection.request("session/set_model", {
+      sessionId: upstreamSessionId,
+      modelId: persistedModel
+    });
+    logger?.info(
+      `resurrect: session/set_model accepted, effectiveModel=${JSON.stringify(persistedModel)}`
+    );
+    return persistedModel;
+  } catch (err) {
+    logger?.warn(
+      `resurrect: session/set_model rejected by agent for modelId=${JSON.stringify(persistedModel)} (${err.message}); session will use ${JSON.stringify(agentReportedModel)}`
+    );
+    return agentReportedModel;
+  }
+}
 function parseModesList(list) {
   if (!Array.isArray(list)) {
     return [];
@@ -7966,6 +8439,55 @@ function withCode3(err, code) {
   return err;
 }
 
+// src/core/extension-commands.ts
+var ExtensionCommandRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  changeHandlers = [];
+  register(name, connection, commands) {
+    this.entries.set(name, { connection, commands: [...commands] });
+    this.fireChanged();
+  }
+  clear(name) {
+    if (this.entries.delete(name)) {
+      this.fireChanged();
+    }
+  }
+  get(name) {
+    return this.entries.get(name);
+  }
+  has(name) {
+    return this.entries.has(name);
+  }
+  // Snapshot of every (name, command) pair. Order is stable per-name
+  // (insertion order of the map and the original commands list).
+  list() {
+    const out = [];
+    for (const [name, entry] of this.entries) {
+      for (const command of entry.commands) {
+        out.push({ name, command });
+      }
+    }
+    return out;
+  }
+  onChange(handler) {
+    this.changeHandlers.push(handler);
+    return () => {
+      const i = this.changeHandlers.indexOf(handler);
+      if (i >= 0) {
+        this.changeHandlers.splice(i, 1);
+      }
+    };
+  }
+  fireChanged() {
+    for (const h of this.changeHandlers) {
+      try {
+        h();
+      } catch {
+      }
+    }
+  }
+};
+
 // src/core/agent-prune.ts
 import * as fsp7 from "fs/promises";
 import * as path9 from "path";
@@ -9131,6 +9653,376 @@ function isLoopbackHost(host) {
   return host === "127.0.0.1" || host === "::1" || host === "localhost" || host === "[::1]";
 }
 
+// src/core/history-search.ts
+function parseQuery(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    return { operator: "OR", terms: [] };
+  }
+  const tokenRe = /\w+:"[^"]*"|"[^"]*"|\S+/g;
+  const tokens = [];
+  let m;
+  while ((m = tokenRe.exec(trimmed)) !== null) {
+    tokens.push(m[0]);
+  }
+  let operator = "OR";
+  let sawAnd = false;
+  let sawOr = false;
+  const termTokens = [];
+  for (const tok of tokens) {
+    const upper = tok.toUpperCase();
+    if (upper === "AND") {
+      sawAnd = true;
+    } else if (upper === "OR") {
+      sawOr = true;
+    } else {
+      termTokens.push(tok);
+    }
+  }
+  if (sawAnd) {
+    operator = "AND";
+  } else if (sawOr) {
+    operator = "OR";
+  }
+  const terms = termTokens.map((tok) => parseTermToken(tok)).filter((t) => t.term.length > 0);
+  return { operator, terms };
+}
+function parseTermToken(tok) {
+  const pq = /^(\w+):"([^"]*)"$/.exec(tok);
+  if (pq) {
+    return { scope: prefixToScope(pq[1]), term: pq[2] };
+  }
+  const q = /^"([^"]*)"$/.exec(tok);
+  if (q) {
+    return { scope: "all", term: q[1] };
+  }
+  const pb = /^(prompt|response|tool):([\s\S]*)$/i.exec(tok);
+  if (pb) {
+    return { scope: prefixToScope(pb[1]), term: pb[2].trim() };
+  }
+  return { scope: "all", term: tok.trim() };
+}
+function prefixToScope(prefix) {
+  switch (prefix.toLowerCase()) {
+    case "prompt":
+      return "user";
+    case "response":
+      return "agent";
+    case "tool":
+      return "tool";
+    default:
+      return "all";
+  }
+}
+function scopeMatchesKind(scope, kind) {
+  if (scope === "all") {
+    return true;
+  }
+  if (scope === "user") {
+    return kind === "user";
+  }
+  if (scope === "agent") {
+    return kind === "agent" || kind === "thought";
+  }
+  return kind === "tool" || kind === "tool-input";
+}
+var DEFAULT_MAX_SNIPPETS_PER_SESSION = 5;
+var DEFAULT_MAX_SESSIONS = 200;
+var SNIPPET_SIDE = 30;
+async function searchHistories(manager, query, opts = {}) {
+  const parsed = parseQuery(query);
+  if (parsed.terms.length === 0) {
+    return { query, truncated: false, results: [] };
+  }
+  const maxPerSession = opts.maxSnippetsPerSession ?? DEFAULT_MAX_SNIPPETS_PER_SESSION;
+  const maxSessions = opts.maxSessions ?? DEFAULT_MAX_SESSIONS;
+  const allow = opts.sessionIds ? new Set(opts.sessionIds) : null;
+  const all = await manager.list();
+  const candidates = allow ? all.filter((s) => allow.has(s.sessionId)) : all;
+  const results = [];
+  let truncated = false;
+  for (const candidate of candidates) {
+    if (results.length >= maxSessions) {
+      truncated = true;
+      break;
+    }
+    const entries = await manager.loadHistory(candidate.sessionId).catch(
+      () => []
+    );
+    const found = scanSessionEntries(entries, parsed, maxPerSession);
+    if (found.snippets.length === 0) {
+      continue;
+    }
+    const hit = {
+      sessionId: candidate.sessionId,
+      cwd: candidate.cwd,
+      status: candidate.status,
+      updatedAt: candidate.updatedAt,
+      totalMatches: found.totalMatches,
+      snippets: found.snippets
+    };
+    if (candidate.title !== void 0) {
+      hit.title = candidate.title;
+    }
+    results.push(hit);
+  }
+  return { query, truncated, results };
+}
+function scanSessionEntries(entries, query, maxSnippets) {
+  if (query.terms.length === 0) {
+    return { totalMatches: 0, snippets: [] };
+  }
+  let totalMatches = 0;
+  const snippets = [];
+  for (const { scope, term } of query.terms) {
+    const result = scanForTerm(entries, term, scope, maxSnippets - snippets.length);
+    if (query.operator === "AND" && result.totalMatches === 0) {
+      return { totalMatches: 0, snippets: [] };
+    }
+    totalMatches += result.totalMatches;
+    snippets.push(...result.snippets);
+  }
+  return { totalMatches, snippets };
+}
+function scanForTerm(entries, term, scope, snippetBudget) {
+  const needle = term.toLowerCase();
+  let totalMatches = 0;
+  const snippets = [];
+  for (const entry of entries) {
+    const fragments = extractSearchableFragments(entry).filter(
+      (f) => scopeMatchesKind(scope, f.kind)
+    );
+    for (const frag of fragments) {
+      const hay = frag.text.toLowerCase();
+      let idx = hay.indexOf(needle);
+      if (idx === -1) {
+        continue;
+      }
+      let occurrences = 0;
+      while (idx !== -1) {
+        occurrences++;
+        idx = hay.indexOf(needle, idx + needle.length);
+      }
+      totalMatches += occurrences;
+      if (snippets.length < snippetBudget) {
+        const first = hay.indexOf(needle);
+        const snippet = {
+          kind: frag.kind,
+          text: buildSnippet(frag.text, first, needle.length),
+          recordedAt: entry.recordedAt
+        };
+        if (frag.toolName !== void 0) {
+          snippet.toolName = frag.toolName;
+        }
+        snippets.push(snippet);
+      }
+    }
+  }
+  return { totalMatches, snippets };
+}
+function extractSearchableFragments(entry) {
+  if (entry.method !== "session/update") {
+    return [];
+  }
+  const params = entry.params;
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    return [];
+  }
+  const update = params.update;
+  if (!update || typeof update !== "object" || Array.isArray(update)) {
+    return [];
+  }
+  const u = update;
+  const tag = typeof u.sessionUpdate === "string" ? u.sessionUpdate : u.kind;
+  if (typeof tag !== "string") {
+    return [];
+  }
+  switch (tag) {
+    case "agent_message_chunk": {
+      const text = readContentText(u.content);
+      return text ? [{ kind: "agent", text }] : [];
+    }
+    case "agent_thought":
+    case "agent_thought_chunk": {
+      const text = typeof u.text === "string" ? sanitizeWireText(u.text) : readContentText(u.content);
+      return text ? [{ kind: "thought", text }] : [];
+    }
+    case "user_message_chunk": {
+      if (isCompatPromptReceived(u)) {
+        return [];
+      }
+      const text = readContentText(u.content);
+      return text ? [{ kind: "user", text }] : [];
+    }
+    case "prompt_received": {
+      const text = readPromptText(u.prompt);
+      return text ? [{ kind: "user", text }] : [];
+    }
+    case "tool_call":
+    case "tool_call_update": {
+      return extractToolFragments(u);
+    }
+    default:
+      return [];
+  }
+}
+function extractToolFragments(u) {
+  const toolName = readString2(u, "name");
+  const title = readString2(u, "title");
+  const out = [];
+  if (title !== void 0) {
+    const sanitized = sanitizeSingleLine(title);
+    if (sanitized.length > 0) {
+      const frag = { kind: "tool", text: sanitized };
+      if (toolName !== void 0) {
+        frag.toolName = toolName;
+      }
+      out.push(frag);
+    }
+  }
+  if (toolName !== void 0 && toolName !== title) {
+    const sanitized = sanitizeSingleLine(toolName);
+    if (sanitized.length > 0) {
+      out.push({ kind: "tool", toolName, text: sanitized });
+    }
+  }
+  const rawInput = u.rawInput;
+  if (rawInput && typeof rawInput === "object") {
+    const serialized = safeStringify(rawInput);
+    if (serialized.length > 0) {
+      const frag = {
+        kind: "tool-input",
+        text: sanitizeSingleLine(serialized)
+      };
+      if (toolName !== void 0) {
+        frag.toolName = toolName;
+      }
+      out.push(frag);
+    }
+  }
+  const locations = u.locations;
+  if (Array.isArray(locations) && locations.length > 0) {
+    const serialized = safeStringify(locations);
+    if (serialized.length > 0) {
+      const frag = {
+        kind: "tool-input",
+        text: sanitizeSingleLine(serialized)
+      };
+      if (toolName !== void 0) {
+        frag.toolName = toolName;
+      }
+      out.push(frag);
+    }
+  }
+  const errorText = extractToolErrorText(u);
+  if (errorText !== null) {
+    const frag = { kind: "tool", text: errorText };
+    if (toolName !== void 0) {
+      frag.toolName = toolName;
+    }
+    out.push(frag);
+  }
+  return out;
+}
+function extractToolErrorText(u) {
+  const content = u.content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (!block || typeof block !== "object") {
+        continue;
+      }
+      const b = block;
+      const inner = b.content;
+      if (!inner || typeof inner !== "object") {
+        continue;
+      }
+      const i = inner;
+      if (i.type === "text" && typeof i.text === "string") {
+        const s = sanitizeSingleLine(i.text);
+        if (s.length > 0) {
+          return s;
+        }
+      }
+    }
+  }
+  const rawOutput = u.rawOutput;
+  if (rawOutput && typeof rawOutput === "object") {
+    const err = rawOutput.error;
+    if (typeof err === "string") {
+      const s = sanitizeSingleLine(err);
+      if (s.length > 0) {
+        return s;
+      }
+    }
+  }
+  return null;
+}
+function isCompatPromptReceived(u) {
+  const meta = u._meta;
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+    return false;
+  }
+  const hydra = meta["hydra-acp"];
+  if (!hydra || typeof hydra !== "object" || Array.isArray(hydra)) {
+    return false;
+  }
+  return hydra.compatFor === "prompt_received";
+}
+function readContentText(content) {
+  if (typeof content === "string") {
+    return sanitizeWireText(content);
+  }
+  if (!content || typeof content !== "object" || Array.isArray(content)) {
+    return "";
+  }
+  const c = content;
+  if (typeof c.text === "string") {
+    return sanitizeWireText(c.text);
+  }
+  return "";
+}
+function readPromptText(prompt) {
+  if (!Array.isArray(prompt)) {
+    return "";
+  }
+  const parts = [];
+  for (const block of prompt) {
+    const text = readContentText(block);
+    if (text.length > 0) {
+      parts.push(text);
+    }
+  }
+  return parts.join("");
+}
+function readString2(u, key) {
+  const v = u[key];
+  return typeof v === "string" ? v : void 0;
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+function buildSnippet(text, matchIdx, matchLen) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  if (flat.length === 0) {
+    return "";
+  }
+  const flatLower = flat.toLowerCase();
+  const needleSlice = text.slice(matchIdx, matchIdx + matchLen).toLowerCase().replace(/\s+/g, " ").trim();
+  let pos = needleSlice.length > 0 ? flatLower.indexOf(needleSlice) : 0;
+  if (pos === -1) {
+    pos = 0;
+  }
+  const start = Math.max(0, pos - SNIPPET_SIDE);
+  const end = Math.min(flat.length, pos + needleSlice.length + SNIPPET_SIDE);
+  const head = start > 0 ? "\u2026" : "";
+  const tail = end < flat.length ? "\u2026" : "";
+  return `${head}${flat.slice(start, end)}${tail}`;
+}
+
 // src/daemon/routes/sessions.ts
 function resolveHydraHost(defaults) {
   if (defaults.publicHost && defaults.publicHost.length > 0) {
@@ -9147,6 +10039,17 @@ function registerSessionRoutes(app, manager, defaults) {
     const sessions = await manager.list({ cwd: query?.cwd });
     return { sessions };
   });
+  app.get("/v1/sessions/search", async (request, reply) => {
+    const query = request.query;
+    const q = query?.q ?? "";
+    if (q.trim().length === 0) {
+      reply.code(400).send({ error: "q is required" });
+      return reply;
+    }
+    const ids = query?.sessionIds ? query.sessionIds.split(",").filter((s) => s.length > 0) : void 0;
+    const out = await searchHistories(manager, q, { sessionIds: ids });
+    return out;
+  });
   app.post("/v1/sessions", async (request, reply) => {
     const body = request.body ?? {};
     const cwd = expandHome(body.cwd ?? defaults.cwd);
@@ -9931,6 +10834,7 @@ function wsToMessageStream(ws) {
 // src/daemon/acp-ws.ts
 import * as os4 from "os";
 import * as path12 from "path";
+import { randomBytes as randomBytes3 } from "crypto";
 function registerAcpWsEndpoint(app, deps) {
   app.get("/acp", { websocket: true }, async (socket, request) => {
     const token = tokenFromUpgradeRequest({
@@ -9968,6 +10872,12 @@ function registerAcpWsEndpoint(app, deps) {
     };
     connection.onRequest("initialize", async (raw) => {
       const params = InitializeParams.parse(raw ?? {});
+      if (params.clientInfo?.name) {
+        state.clientInfo = {
+          name: params.clientInfo.name,
+          ...params.clientInfo.version !== void 0 ? { version: params.clientInfo.version } : {}
+        };
+      }
       const version = params.clientInfo?.version;
       if (version && processIdentity) {
         if (processIdentity.kind === "extension") {
@@ -9978,6 +10888,34 @@ function registerAcpWsEndpoint(app, deps) {
       }
       return buildInitializeResult();
     });
+    if (processIdentity && deps.extensionCommands) {
+      const registry = deps.extensionCommands;
+      connection.onRequest("hydra-acp/register_commands", async (raw) => {
+        const params = raw ?? {};
+        const commands = Array.isArray(params.commands) ? params.commands.map((c) => {
+          if (!c || typeof c !== "object") {
+            return void 0;
+          }
+          const obj = c;
+          if (typeof obj.verb !== "string" || obj.verb.length === 0) {
+            return void 0;
+          }
+          const spec = { verb: obj.verb };
+          if (typeof obj.argsHint === "string") {
+            spec.argsHint = obj.argsHint;
+          }
+          if (typeof obj.description === "string") {
+            spec.description = obj.description;
+          }
+          return spec;
+        }).filter((s) => s !== void 0) : [];
+        registry.register(processIdentity.name, connection, commands);
+        return { ok: true, registered: commands.length };
+      });
+      connection.onClose(() => {
+        registry.clear(processIdentity.name);
+      });
+    }
     if (processIdentity?.kind === "transformer") {
       connection.onRequest("transformer/initialize", async (raw) => {
         const params = raw ?? {};
@@ -10119,16 +11057,50 @@ function registerAcpWsEndpoint(app, deps) {
       );
       const transformerNames = Array.isArray(hydraMeta.transformers) && hydraMeta.transformers.every((t) => typeof t === "string") ? hydraMeta.transformers : deps.manager.defaultTransformers ?? [];
       const transformChain = deps.transformers?.resolveChain(transformerNames) ?? [];
-      const session = await deps.manager.create({
-        cwd: params.cwd,
-        agentId: params.agentId ?? deps.defaultAgent,
-        mcpServers: params.mcpServers,
-        title: hydraMeta.name,
-        agentArgs: hydraMeta.agentArgs,
-        model: hydraMeta.model,
-        onInstallProgress: makeInstallProgressForwarder(connection),
-        transformChain
-      });
+      let stdinToken;
+      let stdinReservation;
+      let augmentedMcpServers = params.mcpServers;
+      if (hydraMeta.mcpStdin === true && deps.stdinMcpRegistry !== void 0 && deps.getDaemonOrigin !== void 0) {
+        stdinToken = randomBytes3(32).toString("hex");
+        stdinReservation = deps.stdinMcpRegistry.reserve(stdinToken);
+        const url = `${deps.getDaemonOrigin()}/mcp/stdin`;
+        const descriptor = {
+          name: "hydra_stdin",
+          type: "http",
+          url,
+          headers: [
+            { name: "Authorization", value: `Bearer ${stdinToken}` }
+          ]
+        };
+        augmentedMcpServers = [...params.mcpServers ?? [], descriptor];
+      }
+      let session;
+      try {
+        session = await deps.manager.create({
+          cwd: params.cwd,
+          agentId: params.agentId ?? deps.defaultAgent,
+          mcpServers: augmentedMcpServers,
+          title: hydraMeta.name,
+          agentArgs: hydraMeta.agentArgs,
+          model: hydraMeta.model,
+          onInstallProgress: makeInstallProgressForwarder(connection),
+          transformChain,
+          originatingClient: state.clientInfo
+        });
+      } catch (err) {
+        if (stdinReservation !== void 0) {
+          stdinReservation.abandon(err instanceof Error ? err : void 0);
+        }
+        throw err;
+      }
+      if (stdinToken !== void 0 && stdinReservation !== void 0 && deps.stdinMcpRegistry !== void 0) {
+        const token2 = stdinToken;
+        const registry = deps.stdinMcpRegistry;
+        stdinReservation.complete(session);
+        session.onClose(() => {
+          void registry.unbind(token2);
+        });
+      }
       const client = bindClientToSession(connection, session, state);
       const { entries: replay } = await session.attach(client, "full");
       state.attached.set(session.sessionId, {
@@ -10525,7 +11497,10 @@ function registerAcpWsEndpoint(app, deps) {
         return null;
       }
       app.log.info(decision.logMessage);
-      return decision.session.forwardRequest("session/set_model", rawParams);
+      const { modelId } = rawParams;
+      const result = await decision.session.forwardRequest("session/set_model", rawParams);
+      decision.session.applyModelChange(modelId);
+      return result;
     });
     connection.onRequest("session/set_mode", async (rawParams) => {
       const params = rawParams;
@@ -10846,6 +11821,336 @@ function bindClientToSession(connection, session, state, clientInfo, callerClien
   };
 }
 
+// src/daemon/mcp/stdin-registry.ts
+var StdinMcpRegistry = class {
+  byToken = /* @__PURE__ */ new Map();
+  // Reserve a token slot before the session exists. Used by acp-ws when
+  // we need to inject the bearer into the agent's mcpServers BEFORE
+  // manager.create() returns — claude-acp connects to /mcp/stdin during
+  // session/new initialization (eagerly), so the route handler must be
+  // able to find the token by the time the agent's first request lands.
+  reserve(token) {
+    if (this.byToken.has(token)) {
+      throw new Error(`stdin MCP token already bound`);
+    }
+    let resolveSession;
+    let rejectSession;
+    const sessionReady = new Promise((resolve3, reject) => {
+      resolveSession = resolve3;
+      rejectSession = reject;
+    });
+    sessionReady.catch(() => void 0);
+    const entry = { session: void 0, sessionReady };
+    this.byToken.set(token, entry);
+    return {
+      complete: (session) => {
+        entry.session = session;
+        resolveSession(session);
+      },
+      abandon: (reason) => {
+        this.byToken.delete(token);
+        rejectSession(reason ?? new Error("stdin MCP reservation abandoned"));
+      }
+    };
+  }
+  // Convenience for callers that already have the session in hand (and
+  // for tests). Equivalent to reserve() + complete() back-to-back.
+  bind(token, session) {
+    const { complete } = this.reserve(token);
+    complete(session);
+  }
+  lookup(token) {
+    return this.byToken.get(token);
+  }
+  attachTransport(token, server, transport) {
+    const ep = this.byToken.get(token);
+    if (!ep) {
+      return;
+    }
+    ep.server = server;
+    ep.transport = transport;
+  }
+  async unbind(token) {
+    const ep = this.byToken.get(token);
+    if (!ep) {
+      return;
+    }
+    this.byToken.delete(token);
+    if (ep.transport) {
+      try {
+        await ep.transport.close();
+      } catch {
+      }
+    }
+    if (ep.server) {
+      try {
+        await ep.server.close();
+      } catch {
+      }
+    }
+  }
+  size() {
+    return this.byToken.size;
+  }
+};
+
+// src/daemon/mcp/stdin-server.ts
+import { randomUUID } from "crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { z as z7 } from "zod";
+var BEARER_PREFIX2 = "Bearer ";
+function extractBearer(req) {
+  const header = req.headers.authorization;
+  if (typeof header !== "string") {
+    return void 0;
+  }
+  if (!header.startsWith(BEARER_PREFIX2)) {
+    return void 0;
+  }
+  const token = header.slice(BEARER_PREFIX2.length).trim();
+  return token.length > 0 ? token : void 0;
+}
+function buildMcpServer(session) {
+  const server = new McpServer(
+    { name: "hydra-stdin", version: "1.0.0" },
+    {
+      instructions: "Piped input from `hydra cat --stream` is exposed here as a byte stream. Use `tail_stdin` for the latest N bytes (good for finding the end of a log), `head_stdin` for the first N bytes (good for headers/preamble), `read_stdin` for windowed reads against an absolute byte cursor, `wait_for_more` to block until new bytes arrive past a cursor, and `stdin_info` for the current cursors/capacity/closed status. Byte payloads come back base64-encoded."
+    }
+  );
+  server.registerTool(
+    "tail_stdin",
+    {
+      description: "Return the most recent `bytes` bytes of piped stdin (capped server-side, default 64 KiB max). `truncated:true` means older bytes existed but have been evicted from the ring.",
+      inputSchema: {
+        bytes: z7.number().int().min(1).describe("How many trailing bytes to return.")
+      }
+    },
+    async ({ bytes }) => {
+      const r = session.streamTail(bytes);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(r)
+          }
+        ],
+        structuredContent: r
+      };
+    }
+  );
+  server.registerTool(
+    "head_stdin",
+    {
+      description: "Return the first `bytes` bytes of piped stdin (capped server-side, default 64 KiB max). `truncated:true` means the head has already been evicted from the ring and the returned bytes start at the oldest still-resident cursor.",
+      inputSchema: {
+        bytes: z7.number().int().min(1).describe("How many leading bytes to return.")
+      }
+    },
+    async ({ bytes }) => {
+      const r = session.streamHead(bytes);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(r)
+          }
+        ],
+        structuredContent: r
+      };
+    }
+  );
+  server.registerTool(
+    "read_stdin",
+    {
+      description: "Read up to `max_bytes` bytes starting at absolute byte `cursor`. Returns `{bytes, nextCursor, gap?, eof?}` \u2014 `gap` is the number of bytes silently skipped because the ring had evicted them; `eof:true` means the producer closed and there is nothing left to read.",
+      inputSchema: {
+        cursor: z7.number().int().min(0).describe(
+          "Absolute byte offset to start reading from. Use 0 to read from the very beginning (may produce a gap if old bytes have been evicted)."
+        ),
+        max_bytes: z7.number().int().min(1).optional().describe(
+          "Optional cap on how many bytes to return. Server caps at 64 KiB regardless."
+        ),
+        wait_ms: z7.number().int().min(0).optional().describe(
+          "If no bytes are available, block up to this many ms for more (capped server-side at 60_000)."
+        )
+      }
+    },
+    async ({ cursor, max_bytes, wait_ms }) => {
+      const r = await session.streamRead(cursor, max_bytes, wait_ms);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(r)
+          }
+        ],
+        structuredContent: r
+      };
+    }
+  );
+  server.registerTool(
+    "wait_for_more",
+    {
+      description: "Block until bytes are available past `cursor`, the stream closes, or `timeout_ms` elapses. Returns one of {data, eof, timeout} plus the current `writeCursor`. Use this when you've consumed everything up to a cursor and want to wait for more without busy-polling.",
+      inputSchema: {
+        cursor: z7.number().int().min(0).describe("The cursor you've already consumed up to."),
+        timeout_ms: z7.number().int().min(0).describe("Maximum ms to block (server caps at 60_000).")
+      }
+    },
+    async ({ cursor, timeout_ms }) => {
+      const outcome = await session.streamWaitFor(cursor, timeout_ms);
+      const info = session.streamInfo();
+      const payload = { outcome, writeCursor: info.writeCursor, closed: info.closed };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(payload)
+          }
+        ],
+        structuredContent: payload
+      };
+    }
+  );
+  server.registerTool(
+    "grep_stdin",
+    {
+      description: "Scan piped stdin line-by-line and return lines matching `pattern`. Prefer this over `read_stdin` when the question is 'find lines that mention X' \u2014 it filters server-side so you don't pull and decode 64 KiB base64 windows. Returns `{matches: [{cursor, line, before?, after?}], truncated, nextCursor, gap?, scannedBytes, eof?}`. Lines come back as decoded UTF-8 strings (not base64). When `truncated:true`, re-call with `cursor: nextCursor` to resume.",
+      inputSchema: {
+        pattern: z7.string().min(1).describe(
+          "Search pattern. Treated as a JavaScript regular expression by default (set `regex:false` for a literal substring match)."
+        ),
+        regex: z7.boolean().optional().describe("Default true. Pass false to treat `pattern` as a literal substring."),
+        case_insensitive: z7.boolean().optional().describe("Default false. Pass true for case-insensitive matching."),
+        invert: z7.boolean().optional().describe("Default false. Pass true to return lines that do NOT match the pattern."),
+        max_matches: z7.number().int().min(1).optional().describe("Default 100. Capped server-side at 1000."),
+        max_bytes: z7.number().int().min(1).optional().describe("Default 64 KiB output. Capped server-side at 256 KiB."),
+        context_before: z7.number().int().min(0).optional().describe("Default 0. Number of lines before each match to include (capped at 20)."),
+        context_after: z7.number().int().min(0).optional().describe("Default 0. Number of lines after each match to include (capped at 20)."),
+        cursor: z7.number().int().min(0).optional().describe(
+          "Optional absolute byte offset to start scanning from. Omit to scan from the oldest still-resident byte. Pass the `nextCursor` from a previous truncated call to resume."
+        )
+      }
+    },
+    async (args) => {
+      const opts = { pattern: args.pattern };
+      if (args.regex !== void 0) {
+        opts.regex = args.regex;
+      }
+      if (args.case_insensitive !== void 0) {
+        opts.caseInsensitive = args.case_insensitive;
+      }
+      if (args.invert !== void 0) {
+        opts.invert = args.invert;
+      }
+      if (args.max_matches !== void 0) {
+        opts.maxMatches = args.max_matches;
+      }
+      if (args.max_bytes !== void 0) {
+        opts.maxBytes = args.max_bytes;
+      }
+      if (args.context_before !== void 0) {
+        opts.contextBefore = args.context_before;
+      }
+      if (args.context_after !== void 0) {
+        opts.contextAfter = args.context_after;
+      }
+      if (args.cursor !== void 0) {
+        opts.cursor = args.cursor;
+      }
+      const r = session.streamGrep(opts);
+      const payload = r;
+      return {
+        content: [{ type: "text", text: JSON.stringify(r) }],
+        structuredContent: payload
+      };
+    }
+  );
+  server.registerTool(
+    "stdin_info",
+    {
+      description: "Report cursor / capacity / closed state of the stdin ring. Cheap; safe to call repeatedly.",
+      inputSchema: {}
+    },
+    async () => {
+      const r = session.streamInfo();
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(r)
+          }
+        ],
+        structuredContent: r
+      };
+    }
+  );
+  return server;
+}
+async function ensureTransport(token, session, registry) {
+  const existing = registry.lookup(token);
+  if (existing?.transport !== void 0) {
+    return existing.transport;
+  }
+  const server = buildMcpServer(session);
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: () => randomUUID()
+  });
+  await server.connect(transport);
+  registry.attachTransport(token, server, transport);
+  return transport;
+}
+var SESSION_READY_TIMEOUT_MS = 1e4;
+async function handle(req, reply, registry) {
+  const token = extractBearer(req);
+  if (token === void 0) {
+    reply.code(401).send({ error: "missing bearer token" });
+    return;
+  }
+  const ep = registry.lookup(token);
+  if (ep === void 0) {
+    reply.code(404).send({ error: "unknown stdin token" });
+    return;
+  }
+  let session;
+  if (ep.session !== void 0) {
+    session = ep.session;
+  } else {
+    let timer;
+    const timeout = new Promise((resolve3) => {
+      timer = setTimeout(() => resolve3(void 0), SESSION_READY_TIMEOUT_MS);
+    });
+    const resolved = await Promise.race([
+      ep.sessionReady.catch(() => void 0),
+      timeout
+    ]);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+    if (resolved === void 0) {
+      reply.code(503).send({ error: "session not ready" });
+      return;
+    }
+    session = resolved;
+  }
+  const transport = await ensureTransport(token, session, registry);
+  reply.hijack();
+  await transport.handleRequest(req.raw, reply.raw, req.body);
+}
+function registerStdinMcpRoutes(app, registry) {
+  const opts = { config: { skipAuth: true } };
+  app.post("/mcp/stdin", opts, async (req, reply) => {
+    await handle(req, reply, registry);
+  });
+  app.get("/mcp/stdin", opts, async (req, reply) => {
+    await handle(req, reply, registry);
+  });
+  app.delete("/mcp/stdin", opts, async (req, reply) => {
+    await handle(req, reply, registry);
+  });
+}
+
 // src/daemon/server.ts
 async function startDaemon(config, serviceToken) {
   ensureLoopbackOrTls(config);
@@ -10916,13 +12221,15 @@ async function startDaemon(config, serviceToken) {
     stderrTailBytes: config.daemon.agentStderrTailBytes,
     logger: agentLogger
   });
+  const extensionCommands = new ExtensionCommandRegistry();
   const manager = new SessionManager(registry, spawner, void 0, {
     idleTimeoutMs: config.daemon.sessionIdleTimeoutSeconds * 1e3,
     defaultModels: config.defaultModels,
     defaultTransformers: config.defaultTransformers,
     sessionHistoryMaxEntries: config.daemon.sessionHistoryMaxEntries,
     logger: agentLogger,
-    npmRegistry: config.npmRegistry
+    npmRegistry: config.npmRegistry,
+    extensionCommands
   });
   const extensions = new ExtensionManager(extensionList(config), void 0, {
     tokenRegistry: processRegistry
@@ -10949,6 +12256,19 @@ async function startDaemon(config, serviceToken) {
     store: sessionTokenStore,
     rateLimiter: authRateLimiter
   });
+  const stdinMcpRegistry = new StdinMcpRegistry();
+  registerStdinMcpRoutes(app, stdinMcpRegistry);
+  let daemonOriginCached;
+  const getDaemonOrigin = () => {
+    if (daemonOriginCached !== void 0) {
+      return daemonOriginCached;
+    }
+    const addr = app.server.address();
+    const port = addr && typeof addr === "object" ? addr.port : config.daemon.port;
+    const scheme2 = config.daemon.tls ? "https" : "http";
+    daemonOriginCached = `${scheme2}://${config.daemon.host}:${port}`;
+    return daemonOriginCached;
+  };
   registerAcpWsEndpoint(app, {
     validator,
     manager,
@@ -10956,7 +12276,10 @@ async function startDaemon(config, serviceToken) {
     processRegistry,
     onExtensionVersion: (name, version) => extensions.reportVersion(name, version),
     onTransformerVersion: (name, version) => transformers.reportVersion(name, version),
-    transformers
+    transformers,
+    extensionCommands,
+    stdinMcpRegistry,
+    getDaemonOrigin
   });
   await app.listen({ host: config.daemon.host, port: config.daemon.port });
   const address = app.server.address();