@hydra-acp/cli 0.1.48 → 0.1.49

package/dist/index.js

@@ -1757,7 +1757,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);
@@ -2453,6 +2456,8 @@ var Session = class {
   listSessions;
   logger;
   transformChain;
+  extensionCommands;
+  extensionCommandsUnsub;
   // Outstanding "processing" claims: token → claim waiting for respondsTo discharge.
   pendingClaims = /* @__PURE__ */ new Map();
   agentChangeHandlers = [];
@@ -2548,6 +2553,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 +2575,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 +3742,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 +3790,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 +3961,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 +3995,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 +4050,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 +4126,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 +4300,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", {
@@ -4586,6 +4736,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,
@@ -5711,6 +5865,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 +5884,7 @@ var SessionManager = class {
   metaWriteQueues = /* @__PURE__ */ new Map();
   logger;
   npmRegistry;
+  extensionCommands;
   async create(params) {
     const fresh = await this.bootstrapAgent({
       agentId: params.agentId,
@@ -5782,7 +5938,8 @@ var SessionManager = class {
       agentModes: fresh.initialModes,
       agentModels: fresh.initialModels,
       transformChain: params.transformChain,
-      parentSessionId: params.parentSessionId
+      parentSessionId: params.parentSessionId,
+      extensionCommands: this.extensionCommands
     });
     await this.attachManagerHooks(session);
     return session;
@@ -5853,12 +6010,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 +6033,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 +6054,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 +6094,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 +6103,14 @@ 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,
+      extensionCommands: this.extensionCommands
     });
     await this.attachManagerHooks(session);
     return session;
@@ -5946,7 +6129,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 +6144,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 +6169,15 @@ 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,
+      extensionCommands: this.extensionCommands
     });
     await this.attachManagerHooks(session);
     void session.seedFromImport().catch(() => void 0);
@@ -6834,6 +7029,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 +7215,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 +8195,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 +9409,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 +9795,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);
@@ -9978,6 +10637,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 ?? {};
@@ -10525,7 +11212,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;
@@ -10916,13 +11606,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
@@ -10956,7 +11648,8 @@ async function startDaemon(config, serviceToken) {
     processRegistry,
     onExtensionVersion: (name, version) => extensions.reportVersion(name, version),
     onTransformerVersion: (name, version) => transformers.reportVersion(name, version),
-    transformers
+    transformers,
+    extensionCommands
   });
   await app.listen({ host: config.daemon.host, port: config.daemon.port });
   const address = app.server.address();