@hydra-acp/cli 0.1.48 → 0.1.50

package/dist/cli.js

@@ -930,6 +930,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;
   }
@@ -1163,6 +1166,10 @@ var init_types = __esm({
       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"),
@@ -1397,7 +1404,10 @@ var init_connection = __esm({
       // 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);
@@ -1544,18 +1554,34 @@ var init_connection = __esm({
 
 // src/core/stream-buffer.ts
 import * as fsp3 from "fs/promises";
-var DEFAULT_CAPACITY_BYTES, STREAM_READ_MAX_BYTES, STREAM_WAIT_MAX_MS, SessionStreamBuffer;
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var DEFAULT_CAPACITY_BYTES, INITIAL_CAPACITY_BYTES, STREAM_READ_MAX_BYTES, STREAM_WAIT_MAX_MS, STREAM_GREP_DEFAULT_MATCHES, STREAM_GREP_MAX_MATCHES, STREAM_GREP_DEFAULT_BYTES, STREAM_GREP_MAX_BYTES, STREAM_GREP_MAX_CONTEXT, SessionStreamBuffer;
 var init_stream_buffer = __esm({
   "src/core/stream-buffer.ts"() {
     "use strict";
-    DEFAULT_CAPACITY_BYTES = 16 * 1024 * 1024;
+    DEFAULT_CAPACITY_BYTES = 64 * 1024 * 1024;
+    INITIAL_CAPACITY_BYTES = 1 * 1024 * 1024;
     STREAM_READ_MAX_BYTES = 64 * 1024;
     STREAM_WAIT_MAX_MS = 6e4;
+    STREAM_GREP_DEFAULT_MATCHES = 100;
+    STREAM_GREP_MAX_MATCHES = 1e3;
+    STREAM_GREP_DEFAULT_BYTES = 64 * 1024;
+    STREAM_GREP_MAX_BYTES = 256 * 1024;
+    STREAM_GREP_MAX_CONTEXT = 20;
     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;
@@ -1570,24 +1596,33 @@ var init_stream_buffer = __esm({
       // 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;
@@ -1732,6 +1767,136 @@ var init_stream_buffer = __esm({
           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;
@@ -1742,15 +1907,42 @@ var init_stream_buffer = __esm({
           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 {
@@ -1763,8 +1955,8 @@ var init_stream_buffer = __esm({
           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);
@@ -2188,6 +2380,7 @@ var init_session = __esm({
       agentCapabilities;
       agentArgs;
       parentSessionId;
+      originatingClient;
       title;
       // Snapshot state delivered to attaching clients via the attach
       // response _meta rather than via history replay (which would be
@@ -2265,6 +2458,8 @@ var init_session = __esm({
       listSessions;
       logger;
       transformChain;
+      extensionCommands;
+      extensionCommandsUnsub;
       // Outstanding "processing" claims: token → claim waiting for respondsTo discharge.
       pendingClaims = /* @__PURE__ */ new Map();
       agentChangeHandlers = [];
@@ -2340,6 +2535,7 @@ var init_session = __esm({
         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;
@@ -2360,6 +2556,14 @@ var init_session = __esm({
         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;
         }
@@ -2374,18 +2578,11 @@ var init_session = __esm({
         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()
           }
         });
       }
@@ -3548,6 +3745,9 @@ var init_session = __esm({
         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 {
@@ -3593,6 +3793,9 @@ var init_session = __esm({
           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 {
@@ -3761,6 +3964,9 @@ var init_session = __esm({
         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;
@@ -3792,6 +3998,38 @@ var init_session = __esm({
       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
@@ -3815,11 +4053,31 @@ var init_session = __esm({
       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
@@ -3871,39 +4129,118 @@ var init_session = __esm({
       // 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;
@@ -3966,11 +4303,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", {
@@ -4382,6 +4723,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(
@@ -4398,6 +4776,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,
@@ -4968,11 +5350,12 @@ function resolveVersion() {
   }
   return "0.0.0";
 }
-var HYDRA_VERSION;
+var HYDRA_VERSION, HYDRA_CAT_CLIENT_NAME;
 var init_hydra_version = __esm({
   "src/core/hydra-version.ts"() {
     "use strict";
     HYDRA_VERSION = resolveVersion();
+    HYDRA_CAT_CLIENT_NAME = "hydra-acp-cat";
   }
 });
 
@@ -5560,7 +5943,8 @@ async function listSessions(target, opts = {}, fetchImpl = fetch) {
     title: s.title,
     importedFromMachine: s.importedFromMachine,
     importedFromUpstreamSessionId: s.importedFromUpstreamSessionId,
-    busy: s.busy
+    busy: s.busy,
+    originatingClient: s.originatingClient
   }));
 }
 async function killSession(target, id, fetchImpl = fetch) {
@@ -5598,6 +5982,20 @@ async function regenSessionTitle(target, id, fetchImpl = fetch) {
     throw new Error(`daemon returned HTTP ${response.status}`);
   }
 }
+async function searchSessions(target, query, opts = {}, fetchImpl = fetch) {
+  const url = new URL(`${target.baseUrl}/v1/sessions/search`);
+  url.searchParams.set("q", query);
+  if (opts.sessionIds && opts.sessionIds.length > 0) {
+    url.searchParams.set("sessionIds", opts.sessionIds.join(","));
+  }
+  const response = await fetchImpl(url.toString(), {
+    headers: { Authorization: `Bearer ${target.token}` }
+  });
+  if (!response.ok) {
+    throw new Error(`daemon returned HTTP ${response.status}`);
+  }
+  return await response.json();
+}
 async function deleteSession(target, id, fetchImpl = fetch) {
   const response = await fetchImpl(`${target.baseUrl}/v1/sessions/${id}`, {
     method: "DELETE",
@@ -6066,6 +6464,47 @@ var init_resilient_ws = __esm({
   }
 });
 
+// src/acp/permission-pick.ts
+function pickPermissionOptionId(params, preferredKinds) {
+  const options = params && typeof params === "object" ? params.options : void 0;
+  if (Array.isArray(options)) {
+    for (const kind of preferredKinds) {
+      const match = options.find(
+        (o) => typeof o === "object" && o !== null && o.kind === kind && typeof o.optionId === "string"
+      );
+      if (match?.optionId !== void 0) {
+        return match.optionId;
+      }
+    }
+    const fallback = options.find(
+      (o) => typeof o === "object" && o !== null && typeof o.optionId === "string"
+    );
+    if (fallback?.optionId !== void 0) {
+      return fallback.optionId;
+    }
+  }
+  return preferredKinds[0] ?? "allow";
+}
+function buildApproveResponse(params) {
+  const optionId = pickPermissionOptionId(params, [
+    "allow_once",
+    "allow_always"
+  ]);
+  return { outcome: { outcome: "selected", optionId } };
+}
+function buildRejectResponse(params) {
+  const optionId = pickPermissionOptionId(params, [
+    "reject_once",
+    "reject_always"
+  ]);
+  return { outcome: { outcome: "selected", optionId } };
+}
+var init_permission_pick = __esm({
+  "src/acp/permission-pick.ts"() {
+    "use strict";
+  }
+});
+
 // src/core/update-check.ts
 function disabled() {
   if (process.env.NO_UPDATE_NOTIFIER === "1") {
@@ -7277,7 +7716,7 @@ function writeStyled(term, text, style) {
       term(text);
       return;
     case "thought":
-      term.brightBlack.noFormat(text);
+      term.brightBlack(text);
       return;
     case "tool":
       term.brightBlue.noFormat(text);
@@ -9982,11 +10421,8 @@ uncaught: ${err.stack ?? err.message}
   }
 });
 
-// src/tui/picker.ts
-function createPickerPrefs() {
-  return { filters: { cwdOnly: false, hostFilter: "__local" } };
-}
-async function pickSession(term, opts) {
+// src/tui/prompt-utils.ts
+function resetTerminalModes() {
   process.stdout.write("\x1B[<u");
   process.stdout.write("\x1B[?2004l");
   process.stdout.write("\x1B[>4;0m");
@@ -9996,36 +10432,476 @@ async function pickSession(term, opts) {
   process.stdout.write("\x1B[?1006l");
   process.stdout.write("\x1B[?1l");
   process.stdout.write("\x1B>");
-  const sortSessions = (sessions) => {
-    const score = (s) => {
-      if (s.status !== "live") {
-        return 0;
-      }
-      return s.cwd === opts.cwd ? 2 : 1;
-    };
-    return [...sessions].sort((a, b) => {
-      const tier = score(b) - score(a);
-      if (tier !== 0) {
-        return tier;
-      }
-      return b.updatedAt.slice(0, 16).localeCompare(a.updatedAt.slice(0, 16));
-    });
+}
+function readTermWidth(term) {
+  return term.width ?? 80;
+}
+function readTermHeight(term) {
+  return term.height ?? 24;
+}
+function drawBox(term, opts) {
+  const termW = readTermWidth(term);
+  const termH = readTermHeight(term);
+  const desiredContentW = opts.contentWidth ?? MAX_BOX_WIDTH;
+  const maxContentW = Math.max(10, Math.min(MAX_BOX_WIDTH, termW - 4));
+  const contentW = Math.min(desiredContentW, maxContentW);
+  const w = contentW + 2;
+  const contentH = Math.max(1, Math.min(opts.contentHeight, termH - 4));
+  const h = contentH + 2;
+  const x = Math.max(1, Math.floor((termW - w) / 2) + 1);
+  const y = Math.max(1, Math.floor((termH - h) / 2) + 1);
+  term.moveTo(1, 1).eraseDisplayBelow();
+  const topInner = HORIZ.repeat(w - 2);
+  const top = renderTitleStrip(topInner, opts.title);
+  term.moveTo(x, y);
+  term.dim.noFormat(TL);
+  paintTopStrip(term, top);
+  term.dim.noFormat(TR);
+  for (let row = 1; row <= contentH; row++) {
+    term.moveTo(x, y + row);
+    term.dim.noFormat(VERT);
+    term.moveTo(x + w - 1, y + row);
+    term.dim.noFormat(VERT);
+  }
+  term.moveTo(x, y + h - 1);
+  term.dim.noFormat(BL + HORIZ.repeat(w - 2) + BR);
+  return {
+    x,
+    y,
+    w,
+    h,
+    contentX: x + 1,
+    contentY: y + 1,
+    contentW,
+    contentH
   };
-  const prefs = opts.prefs ?? createPickerPrefs();
-  if (opts.prefs === void 0 && opts.currentSessionId !== void 0) {
-    const current = opts.sessions.find(
-      (s) => s.sessionId === opts.currentSessionId
-    );
-    if (current?.importedFromMachine) {
-      prefs.filters.hostFilter = "__all";
-    }
+}
+function renderTitleStrip(innerDashes, title) {
+  if (!title) {
+    return { dashes: innerDashes };
   }
-  let allSessions = sortSessions(opts.sessions);
-  const applyPrefsFilters = (sessions) => {
+  const chip = ` ${title} `;
+  if (chip.length + 4 > innerDashes.length) {
+    return { dashes: innerDashes };
+  }
+  const offset = 2;
+  const dashes = innerDashes.slice(0, offset) + " ".repeat(chip.length) + innerDashes.slice(offset + chip.length);
+  return { dashes, title: { offset, text: chip } };
+}
+function paintTopStrip(term, strip) {
+  if (!strip.title) {
+    term.dim.noFormat(strip.dashes);
+    return;
+  }
+  term.dim.noFormat(strip.dashes.slice(0, strip.title.offset));
+  term.brightCyan.noFormat(strip.title.text);
+  term.dim.noFormat(strip.dashes.slice(strip.title.offset + strip.title.text.length));
+}
+var MAX_BOX_WIDTH, HORIZ, VERT, TL, TR, BL, BR;
+var init_prompt_utils = __esm({
+  "src/tui/prompt-utils.ts"() {
+    "use strict";
+    MAX_BOX_WIDTH = 64;
+    HORIZ = "\u2500";
+    VERT = "\u2502";
+    TL = "\u250C";
+    TR = "\u2510";
+    BL = "\u2514";
+    BR = "\u2518";
+  }
+});
+
+// src/tui/import-action-prompt.ts
+function actionPromptStep(selected, key, choices = ACTION_CHOICES) {
+  if (key.kind === "cancel") {
+    return { kind: "cancel" };
+  }
+  if (key.kind === "back") {
+    return { kind: "back" };
+  }
+  if (key.kind === "enter") {
+    const choice = choices[selected];
+    if (!choice) {
+      return { kind: "back" };
+    }
+    return { kind: "resolve", action: choice.key };
+  }
+  if (key.kind === "up") {
+    return {
+      kind: "continue",
+      selected: Math.max(0, selected - 1)
+    };
+  }
+  if (key.kind === "down") {
+    return {
+      kind: "continue",
+      selected: Math.min(choices.length - 1, selected + 1)
+    };
+  }
+  if (key.kind === "char") {
+    const lower = key.ch.toLowerCase();
+    if (lower === "n") {
+      return {
+        kind: "continue",
+        selected: Math.min(choices.length - 1, selected + 1)
+      };
+    }
+    if (lower === "p") {
+      return {
+        kind: "continue",
+        selected: Math.max(0, selected - 1)
+      };
+    }
+    const idx = choices.findIndex((c) => c.hotkey.toLowerCase() === lower);
+    if (idx >= 0) {
+      const choice = choices[idx];
+      if (choice) {
+        return { kind: "resolve", action: choice.key };
+      }
+    }
+  }
+  return { kind: "continue", selected };
+}
+async function promptForImportAction(term, session) {
+  resetTerminalModes();
+  const shortId2 = stripHydraSessionPrefix(session.sessionId);
+  const fromMachine = session.importedFromMachine ?? "another machine";
+  const originalCwd = shortenHomePath(session.cwd);
+  let selected = ACTION_CHOICES.findIndex((c) => c.key === "view");
+  if (selected < 0) {
+    selected = 0;
+  }
+  const render = () => {
+    const choiceRows = ACTION_CHOICES.length * 2;
+    const contentHeight = 7 + choiceRows + 2;
+    const layout = drawBox(term, {
+      contentHeight,
+      title: "Imported session"
+    });
+    const innerW = layout.contentW;
+    const headerRows = [
+      { label: "session: ", value: shortId2 },
+      { label: "from:    ", value: fromMachine },
+      { label: "cwd:     ", value: originalCwd }
+    ];
+    let row = 0;
+    for (const hr of headerRows) {
+      term.moveTo(layout.contentX, layout.contentY + row);
+      term.dim.noFormat(` ${hr.label}`);
+      term.noFormat(truncate2(hr.value, innerW - hr.label.length - 2));
+      row++;
+    }
+    row++;
+    term.moveTo(layout.contentX, layout.contentY + row);
+    term.noFormat(" What do you want to do?");
+    row += 2;
+    for (let i = 0; i < ACTION_CHOICES.length; i++) {
+      const choice = ACTION_CHOICES[i];
+      if (!choice) {
+        continue;
+      }
+      const pointer = i === selected ? "\u276F" : " ";
+      const label = ` ${pointer} ${choice.label}`;
+      term.moveTo(layout.contentX, layout.contentY + row);
+      if (i === selected) {
+        term.brightWhite.bgBlue.noFormat(padRight(label, innerW));
+      } else {
+        term.noFormat(label);
+      }
+      row++;
+      term.moveTo(layout.contentX, layout.contentY + row);
+      term.dim.noFormat(`     ${choice.description}`);
+      row++;
+    }
+    row++;
+    term.moveTo(layout.contentX, layout.contentY + row);
+    term.dim.noFormat(" \u2191/\u2193 navigate \xB7 Enter select \xB7 f/v jump \xB7 Esc back");
+    return layout;
+  };
+  render();
+  term.hideCursor();
+  return await new Promise((resolve6) => {
+    let resolved = false;
+    const cleanup = () => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      term.off("key", onKey);
+      term.off("resize", onResize);
+      term.grabInput(false);
+      term.hideCursor(false);
+      term.moveTo(1, 1).eraseDisplayBelow();
+    };
+    const finish = (value) => {
+      cleanup();
+      resolve6(value);
+    };
+    const onResize = () => {
+      if (resolved) {
+        return;
+      }
+      render();
+    };
+    const onKey = (name, _matches, data) => {
+      const input = mapKey(name, data);
+      if (!input) {
+        return;
+      }
+      const step = actionPromptStep(selected, input);
+      if (step.kind === "cancel") {
+        finish("cancel");
+        return;
+      }
+      if (step.kind === "back") {
+        finish("back");
+        return;
+      }
+      if (step.kind === "resolve") {
+        finish(step.action);
+        return;
+      }
+      if (step.selected !== selected) {
+        selected = step.selected;
+        render();
+      }
+    };
+    term.grabInput({});
+    term.on("key", onKey);
+    term.on("resize", onResize);
+  });
+}
+function mapKey(name, data) {
+  if (name === "UP") {
+    return { kind: "up" };
+  }
+  if (name === "DOWN") {
+    return { kind: "down" };
+  }
+  if (name === "ENTER" || name === "KP_ENTER") {
+    return { kind: "enter" };
+  }
+  if (name === "ESCAPE") {
+    return { kind: "back" };
+  }
+  if (name === "CTRL_C" || name === "CTRL_D") {
+    return { kind: "cancel" };
+  }
+  if (data?.isCharacter) {
+    return { kind: "char", ch: name };
+  }
+  return null;
+}
+async function promptForLaunchOrView(term, session, focus) {
+  const shortId2 = stripHydraSessionPrefix(session.sessionId);
+  const titleOrCwd = session.title ?? shortenHomePath(session.cwd);
+  let selected = 1;
+  const CHOICES = [
+    { label: "Launch", hotkey: "l", description: "start a new agent session" },
+    { label: "View transcript", hotkey: "v", description: "open read-only, no agent spawn" }
+  ];
+  const render = () => {
+    const layout = drawBox(term, { contentHeight: 11, title: "Open session" });
+    const innerW = layout.contentW;
+    let row = 0;
+    term.moveTo(layout.contentX, layout.contentY + row);
+    term.dim.noFormat(" session: ");
+    term.noFormat(truncate2(shortId2, innerW - 10));
+    row++;
+    term.moveTo(layout.contentX, layout.contentY + row);
+    term.noFormat(" " + truncate2(titleOrCwd, innerW - 2));
+    row++;
+    row++;
+    term.moveTo(layout.contentX, layout.contentY + row);
+    term.noFormat(" What do you want to do?");
+    row += 2;
+    for (let i = 0; i < CHOICES.length; i++) {
+      const choice = CHOICES[i];
+      if (!choice) {
+        continue;
+      }
+      const pointer = i === selected ? "\u276F" : " ";
+      const label = ` ${pointer} ${choice.label}`;
+      term.moveTo(layout.contentX, layout.contentY + row);
+      if (i === selected) {
+        term.brightWhite.bgBlue.noFormat(padRight(label, innerW));
+      } else {
+        term.noFormat(label);
+      }
+      row++;
+      term.moveTo(layout.contentX, layout.contentY + row);
+      term.dim.noFormat(`     ${choice.description}`);
+      row++;
+    }
+    row++;
+    term.moveTo(layout.contentX, layout.contentY + row);
+    term.dim.noFormat(" \u2191/\u2193 navigate \xB7 Enter select \xB7 l/v jump \xB7 Esc back");
+  };
+  render();
+  term.hideCursor();
+  return await new Promise((resolve6) => {
+    let resolved = false;
+    const cleanup = () => {
+      resolved = true;
+    };
+    const finish = (value) => {
+      cleanup();
+      focus.pop();
+      resolve6(value);
+    };
+    const onKey = (name, _m, data) => {
+      if (name === "CTRL_C" || name === "CTRL_D") {
+        finish("cancel");
+        return;
+      }
+      if (name === "ESCAPE") {
+        finish("back");
+        return;
+      }
+      if (name === "ENTER" || name === "KP_ENTER") {
+        finish(selected === 0 ? "launch" : "view");
+        return;
+      }
+      if (name === "UP" || name === "SHIFT_TAB") {
+        if (selected > 0) {
+          selected--;
+          render();
+        }
+        return;
+      }
+      if (name === "DOWN" || name === "TAB") {
+        if (selected < CHOICES.length - 1) {
+          selected++;
+          render();
+        }
+        return;
+      }
+      if (data?.isCharacter) {
+        const lower = name.toLowerCase();
+        if (lower === "l") {
+          finish("launch");
+          return;
+        }
+        if (lower === "v") {
+          finish("view");
+          return;
+        }
+        if (lower === "n") {
+          if (selected < CHOICES.length - 1) {
+            selected++;
+            render();
+          }
+          return;
+        }
+        if (lower === "p") {
+          if (selected > 0) {
+            selected--;
+            render();
+          }
+          return;
+        }
+      }
+    };
+    focus.push({
+      onKey: (name, _m, data) => {
+        if (!resolved) onKey(name, _m, data);
+      },
+      onResize: () => {
+        if (!resolved) render();
+      }
+    });
+  });
+}
+function truncate2(s, max) {
+  if (max <= 1) {
+    return "";
+  }
+  if (s.length <= max) {
+    return s;
+  }
+  return s.slice(0, Math.max(0, max - 1)) + "\u2026";
+}
+function padRight(s, w) {
+  if (s.length >= w) {
+    return s.slice(0, w);
+  }
+  return s + " ".repeat(w - s.length);
+}
+var ACTION_CHOICES;
+var init_import_action_prompt = __esm({
+  "src/tui/import-action-prompt.ts"() {
+    "use strict";
+    init_paths();
+    init_session();
+    init_prompt_utils();
+    ACTION_CHOICES = [
+      {
+        key: "fork-local",
+        label: "Fork locally",
+        hotkey: "f",
+        description: "spawn a local fork \u2014 original imported copy stays as-is"
+      },
+      {
+        key: "view",
+        label: "View transcript",
+        hotkey: "v",
+        description: "open read-only, no agent spawn"
+      }
+    ];
+  }
+});
+
+// src/tui/picker.ts
+function createPickerPrefs() {
+  return {
+    filters: { cwdOnly: false, hostFilter: "__local", showCat: false }
+  };
+}
+async function pickSession(term, opts) {
+  process.stdout.write("\x1B[<u");
+  process.stdout.write("\x1B[?2004l");
+  process.stdout.write("\x1B[>4;0m");
+  process.stdout.write("\x1B[>5;0m");
+  process.stdout.write("\x1B[?1000l");
+  process.stdout.write("\x1B[?1002l");
+  process.stdout.write("\x1B[?1006l");
+  process.stdout.write("\x1B[?1l");
+  process.stdout.write("\x1B>");
+  const sortSessions = (sessions) => {
+    const score = (s) => {
+      if (s.status !== "live") {
+        return 0;
+      }
+      return s.cwd === opts.cwd ? 2 : 1;
+    };
+    return [...sessions].sort((a, b) => {
+      const tier = score(b) - score(a);
+      if (tier !== 0) {
+        return tier;
+      }
+      return b.updatedAt.slice(0, 16).localeCompare(a.updatedAt.slice(0, 16));
+    });
+  };
+  const prefs = opts.prefs ?? createPickerPrefs();
+  if (opts.prefs === void 0 && opts.currentSessionId !== void 0) {
+    const current = opts.sessions.find(
+      (s) => s.sessionId === opts.currentSessionId
+    );
+    if (current?.importedFromMachine) {
+      prefs.filters.hostFilter = "__all";
+    }
+  }
+  let allSessions = sortSessions(opts.sessions);
+  const applyPrefsFilters = (sessions) => {
     let base = sessions;
     if (prefs.filters.cwdOnly) {
       base = base.filter((s) => s.cwd === opts.cwd);
     }
+    if (!prefs.filters.showCat) {
+      base = base.filter(
+        (s) => s.originatingClient?.name !== HYDRA_CAT_CLIENT_NAME
+      );
+    }
     base = filterByHost(base, prefs.filters.hostFilter);
     return base;
   };
@@ -10045,11 +10921,19 @@ async function pickSession(term, opts) {
   let searchTerm = "";
   let mode = "normal";
   let pendingAction = null;
+  let findSubMode = "input";
+  let findComposer = new InputDispatcher({ history: [] });
+  let findResults = [];
+  let findTruncated = false;
+  let findSelectedIdx = 0;
+  let findSnippetIdx = 0;
+  let findError = null;
+  let findInFlight = false;
   let renameBuffer = "";
   let transientStatus = null;
   const composer = new InputDispatcher({ history: [] });
-  let termHeight = readTermHeight(term);
-  let termWidth = readTermWidth(term);
+  let termHeight = readTermHeight2(term);
+  let termWidth = readTermWidth2(term);
   let viewportSize = 0;
   let composerTitle = "";
   let composerRoom = 0;
@@ -10061,10 +10945,16 @@ async function pickSession(term, opts) {
   let headerLine = "";
   let sessionLines = [];
   let startRow = 1;
+  let findRoom = 0;
+  let findVisualRows = [];
+  let findBoxRows = 1;
+  let findBoxWindowStart = 0;
+  let findBoxCursorVisualRow = 0;
+  let findBoxCursorVisualCol = 0;
   const cwdMaxWidth = opts.config.tui.cwdColumnMaxWidth;
   const computeLayout = () => {
-    termHeight = readTermHeight(term);
-    termWidth = readTermWidth(term);
+    termHeight = readTermHeight2(term);
+    termWidth = readTermWidth2(term);
     const rowMaxWidth = Math.max(10, termWidth - ROW_PREFIX_WIDTH);
     composerRoom = Math.max(10, termWidth - BOX_HORIZONTAL_PAD);
     const titleBudget = Math.max(10, termWidth - 8);
@@ -10115,6 +11005,19 @@ async function pickSession(term, opts) {
     }
     adjustScroll();
   };
+  const restoreCursorAfterFilter = (keepId) => {
+    if (keepId !== void 0) {
+      const idx = visible.findIndex((s) => s.sessionId === keepId);
+      if (idx >= 0) {
+        selectedIdx = idx + 1;
+        adjustScroll();
+        return;
+      }
+    }
+    selectedIdx = visible.length > 0 ? 1 : 0;
+    scrollOffset = 0;
+    adjustScroll();
+  };
   const adjustScroll = () => {
     if (selectedIdx === 0) {
       return;
@@ -10191,6 +11094,9 @@ async function pickSession(term, opts) {
         prefs.filters.hostFilter === "__local" ? "host: local" : `host: ${prefs.filters.hostFilter}`
       );
     }
+    if (prefs.filters.showCat) {
+      parts.push("+cat");
+    }
     if (above > 0) {
       parts.push(`\u2191 ${above} above`);
     }
@@ -10240,59 +11146,370 @@ async function pickSession(term, opts) {
     if (visualOffset < 0 || visualOffset >= composerRows) {
       return;
     }
-    const col = 3 + composerCursorCol;
-    term.moveTo(col, composerBodyRow(visualOffset));
+    const col = 3 + composerCursorCol;
+    term.moveTo(col, composerBodyRow(visualOffset));
+  };
+  const renderFromScratch = () => {
+    withSync(() => {
+      term.hideCursor();
+      computeLayout();
+      adjustScroll();
+      startRow = 1;
+      term.moveTo(1, 1).eraseDisplayBelow();
+      paintComposerTopBorder();
+      term("\n");
+      for (let v = 0; v < composerRows; v++) {
+        paintComposerBodyRow(composerWindowStart + v);
+        term("\n");
+      }
+      paintComposerBottomBorder();
+      term("\n\n");
+      term.dim.noFormat(`  ${headerLine}`)("\n");
+      for (let v = 0; v < viewportSize; v++) {
+        paintSessionRow(scrollOffset + v);
+        term("\n");
+      }
+      paintIndicator();
+      term("\n");
+      if (selectedIdx === 0) {
+        placeComposerCursor();
+        term.hideCursor(false);
+      }
+    });
+  };
+  const renderHelp = () => {
+    withSync(() => {
+      term.hideCursor();
+      term.moveTo(1, 1).eraseDisplayBelow();
+      term.brightWhite.bold.noFormat("  Picker hotkeys")("\n\n");
+      for (const entry of HELP_ENTRIES) {
+        if (entry === null) {
+          term("\n");
+          continue;
+        }
+        const [keys, desc] = entry;
+        term.brightCyan.noFormat(`  ${keys.padEnd(HELP_KEYS_WIDTH)}`);
+        term.noFormat(desc)("\n");
+      }
+      term("\n");
+      term.dim.noFormat("  press any key to dismiss")("\n");
+    });
+  };
+  const findResultsStartRow = () => findBoxRows + 4;
+  const FIND_FOOTER_ROWS = 2;
+  let findScrollOffset = 0;
+  const findViewportSize = () => {
+    termHeight = readTermHeight2(term);
+    const avail = Math.max(2, termHeight - (findBoxRows + 3) - FIND_FOOTER_ROWS);
+    return Math.max(1, Math.floor(avail / 2));
+  };
+  const adjustFindScroll = () => {
+    const v = findViewportSize();
+    if (findSelectedIdx < findScrollOffset) {
+      findScrollOffset = findSelectedIdx;
+    } else if (findSelectedIdx >= findScrollOffset + v) {
+      findScrollOffset = findSelectedIdx - v + 1;
+    }
+    if (findScrollOffset + v > findResults.length) {
+      findScrollOffset = Math.max(0, findResults.length - v);
+    }
+    if (findScrollOffset < 0) {
+      findScrollOffset = 0;
+    }
+  };
+  const paintFindBoxTopBorder = (focused) => {
+    termWidth = readTermWidth2(term);
+    const inner = Math.max(2, termWidth - 2);
+    const title = "\u2500 Find sessions ";
+    const dashes = "\u2500".repeat(Math.max(1, inner - title.length));
+    if (focused) {
+      term.brightBlue.noFormat(`\u256D${title}${dashes}\u256E`);
+    } else {
+      term.dim.noFormat(`\u256D${title}${dashes}\u256E`);
+    }
+    term.styleReset();
+  };
+  const computeFindBoxLayout = () => {
+    termWidth = readTermWidth2(term);
+    findRoom = Math.max(10, termWidth - BOX_HORIZONTAL_PAD);
+    const state = findComposer.state();
+    findVisualRows = computePromptVisualRows(state.buffer, findRoom);
+    const layout = computePromptLayout(findVisualRows, state, FIND_BOX_MAX_ROWS);
+    findBoxRows = layout.rendered;
+    findBoxWindowStart = layout.windowStart;
+    findBoxCursorVisualRow = layout.cursorVisualRow;
+    findBoxCursorVisualCol = layout.cursorVisualCol;
+  };
+  const paintFindBoxBodyRow = (visualIdx, focused) => {
+    termWidth = readTermWidth2(term);
+    const inner = Math.max(2, termWidth - 2);
+    const vr = findVisualRows[visualIdx];
+    let slice = "";
+    if (vr) {
+      slice = (findComposer.state().buffer[vr.bufferIdx] ?? "").slice(
+        vr.startCol,
+        vr.endCol
+      );
+    }
+    const padWidth = Math.max(0, inner - 1 - slice.length);
+    const pad = " ".repeat(padWidth);
+    if (focused) {
+      term.brightBlue.noFormat("\u2502");
+      term.noFormat(` ${slice}${pad}`);
+      term.brightBlue.noFormat("\u2502");
+    } else {
+      term.dim.noFormat("\u2502");
+      term.noFormat(` ${slice}${pad}`);
+      term.dim.noFormat("\u2502");
+    }
+    term.styleReset();
+  };
+  const paintFindBoxBottomBorder = (focused) => {
+    termWidth = readTermWidth2(term);
+    const inner = Math.max(2, termWidth - 2);
+    const dashes = "\u2500".repeat(inner);
+    if (focused) {
+      term.brightBlue.noFormat(`\u2570${dashes}\u256F`);
+    } else {
+      term.dim.noFormat(`\u2570${dashes}\u256F`);
+    }
+    term.styleReset();
+  };
+  const findBoxCursorCol = () => 3 + findBoxCursorVisualCol;
+  const findBoxCursorScreenRow = () => 2 + (findBoxCursorVisualRow - findBoxWindowStart);
+  const repaintFindBoxChrome = () => {
+    const focused = findSubMode === "input";
+    withSync(() => {
+      if (focused) {
+        term.hideCursor();
+      }
+      term.moveTo(1, 1);
+      paintFindBoxTopBorder(focused);
+      for (let v = 0; v < findBoxRows; v++) {
+        term.moveTo(1, 2 + v);
+        paintFindBoxBodyRow(findBoxWindowStart + v, focused);
+      }
+      term.moveTo(1, 2 + findBoxRows);
+      paintFindBoxBottomBorder(focused);
+      if (focused) {
+        term.moveTo(findBoxCursorCol(), findBoxCursorScreenRow());
+        term.hideCursor(false);
+      }
+    });
+  };
+  const repaintFindBoxBodyRows = () => {
+    withSync(() => {
+      term.hideCursor();
+      for (let v = 0; v < findBoxRows; v++) {
+        term.moveTo(1, 2 + v);
+        paintFindBoxBodyRow(findBoxWindowStart + v, true);
+      }
+      term.moveTo(findBoxCursorCol(), findBoxCursorScreenRow());
+      term.hideCursor(false);
+    });
+  };
+  const SNIPPET_KIND_GLYPH = {
+    user: "user",
+    agent: "agent",
+    thought: "thought",
+    tool: "tool",
+    "tool-input": "tool-input"
+  };
+  const findResultData = (idx, focused) => {
+    const hit = findResults[idx];
+    if (!hit) {
+      return { rowBudget: 20, line1: "", line2: "", focusedRow: false };
+    }
+    const w = readTermWidth2(term);
+    const rowBudget = Math.max(20, w - ROW_PREFIX_WIDTH);
+    const shortId3 = stripHydraSessionPrefix(hit.sessionId);
+    const title = hit.title ?? shortenHomePath(hit.cwd);
+    const counterText = focused && hit.snippets.length > 1 ? `  [${findSnippetIdx + 1}/${hit.snippets.length}]` : focused && hit.totalMatches > hit.snippets.length ? `  [${hit.snippets.length} of ${hit.totalMatches}]` : "";
+    const head = `${shortId3}  ${hit.status === "live" ? "live" : "cold"}`;
+    const titleBudget = Math.max(5, rowBudget - head.length - counterText.length - 2);
+    const titleSlice = truncateMiddle(title, titleBudget);
+    const line1 = `${head}  ${titleSlice}${counterText}`.padEnd(rowBudget);
+    const snippet = hit.snippets[focused ? findSnippetIdx : 0];
+    const kind = snippet ? SNIPPET_KIND_GLYPH[snippet.kind] ?? snippet.kind : "";
+    const prefix = snippet?.toolName ? `${kind} \xB7 ${snippet.toolName}` : kind;
+    const snippetBudget = Math.max(10, rowBudget - prefix.length - 6);
+    const text = snippet ? truncateMiddle(snippet.text, snippetBudget) : "";
+    const line2 = snippet ? `    ${prefix}  ${text}` : "    (no snippet)";
+    return { rowBudget, line1, line2: line2.padEnd(rowBudget + ROW_PREFIX_WIDTH), focusedRow: focused };
+  };
+  const paintFindResultA = (idx, focused) => {
+    const { line1, focusedRow } = findResultData(idx, focused);
+    if (focusedRow) {
+      term.brightWhite.bgBlue.noFormat(`\u276F ${line1}`);
+    } else {
+      term.noFormat(`  ${line1}`);
+    }
+    term.styleReset();
+  };
+  const paintFindResultB = (idx, focused) => {
+    const { line2 } = findResultData(idx, focused);
+    term.dim.noFormat(line2);
+    term.styleReset();
+  };
+  const paintFindIndicator = () => {
+    if (findInFlight) {
+      term.dim.noFormat("  searching\u2026");
+      term.styleReset();
+      term.eraseLineAfter();
+    } else if (findError !== null) {
+      term.brightRed.noFormat(`  ${findError}`);
+      term.styleReset();
+      term.eraseLineAfter();
+    } else if (findSubMode === "input") {
+      if (findResults.length > 0) {
+        term.dim.noFormat("  Enter to search \xB7 \u2193 browse results \xB7 Esc cancel");
+      } else {
+        term.dim.noFormat("  Enter to search \xB7 Esc cancel");
+      }
+      term.styleReset();
+      term.eraseLineAfter();
+    } else {
+      const sCount = findResults.length;
+      const truncSuffix = findTruncated ? "  \xB7  truncated" : "";
+      const countPart = sCount > 0 ? `  ${sCount} ${sCount === 1 ? "session" : "sessions"} match${truncSuffix}  \xB7  ` : "  ";
+      term.dim.noFormat(
+        `${countPart}\u2191 edit query \xB7 Up/Down sessions \xB7 n/p snippets \xB7 Enter open \xB7 Esc back`
+      );
+      term.styleReset();
+      term.eraseLineAfter();
+    }
   };
-  const renderFromScratch = () => {
-    if (mode === "help") {
-      renderHelp();
-      return;
-    }
+  const renderFind = () => {
+    computeFindBoxLayout();
+    const focused = findSubMode === "input";
+    const queryText = findComposer.state().buffer.join("\n");
     withSync(() => {
       term.hideCursor();
-      computeLayout();
-      adjustScroll();
-      startRow = 1;
       term.moveTo(1, 1).eraseDisplayBelow();
-      paintComposerTopBorder();
-      term("\n");
-      for (let v = 0; v < composerRows; v++) {
-        paintComposerBodyRow(composerWindowStart + v);
-        term("\n");
-      }
-      paintComposerBottomBorder();
-      term("\n\n");
-      term.dim.noFormat(`  ${headerLine}`)("\n");
-      for (let v = 0; v < viewportSize; v++) {
-        paintSessionRow(scrollOffset + v);
-        term("\n");
+      paintFindBoxTopBorder(focused);
+      for (let v = 0; v < findBoxRows; v++) {
+        term.moveTo(1, 2 + v);
+        paintFindBoxBodyRow(findBoxWindowStart + v, focused);
+      }
+      term.moveTo(1, 2 + findBoxRows);
+      paintFindBoxBottomBorder(focused);
+      const sCount = findResults.length;
+      if (sCount === 0) {
+        term.moveTo(1, findResultsStartRow());
+        if (findInFlight) {
+        } else if (findError === null && queryText.trim().length === 0) {
+          term.dim.noFormat("  type a query in the box above, then press Enter");
+          term.eraseLineAfter();
+        } else if (findError === null) {
+          term.dim.noFormat("  no matches");
+          term.eraseLineAfter();
+        }
+        term.moveTo(1, findResultsStartRow() + 1);
+        paintFindIndicator();
+      } else {
+        adjustFindScroll();
+        const v = findViewportSize();
+        const listFocused = findSubMode !== "input";
+        for (let i = 0; i < v; i++) {
+          const idx = findScrollOffset + i;
+          term.moveTo(1, findResultsStartRow() + i * 2);
+          if (idx < sCount) {
+            paintFindResultA(idx, listFocused && idx === findSelectedIdx);
+          } else {
+            term.eraseLineAfter();
+          }
+          term.moveTo(1, findResultsStartRow() + i * 2 + 1);
+          if (idx < sCount) {
+            paintFindResultB(idx, listFocused && idx === findSelectedIdx);
+          } else {
+            term.eraseLineAfter();
+          }
+        }
+        term.moveTo(1, findResultsStartRow() + v * 2);
+        paintFindIndicator();
       }
-      paintIndicator();
-      term("\n");
-      if (selectedIdx === 0) {
-        placeComposerCursor();
+      if (focused) {
+        term.moveTo(findBoxCursorCol(), findBoxCursorScreenRow());
         term.hideCursor(false);
       }
     });
   };
-  const renderHelp = () => {
+  const repaintFindResult = (idx, focused) => {
+    const viewportIdx = idx - findScrollOffset;
+    if (viewportIdx < 0 || viewportIdx >= findViewportSize()) {
+      return;
+    }
     withSync(() => {
-      term.hideCursor();
-      term.moveTo(1, 1).eraseDisplayBelow();
-      term.brightWhite.bold.noFormat("  Picker hotkeys")("\n\n");
-      for (const entry of HELP_ENTRIES) {
-        if (entry === null) {
-          term("\n");
-          continue;
+      term.moveTo(1, findResultsStartRow() + viewportIdx * 2);
+      paintFindResultA(idx, focused);
+      term.moveTo(1, findResultsStartRow() + viewportIdx * 2 + 1);
+      paintFindResultB(idx, focused);
+    });
+  };
+  const repaintFindIndicatorRow = () => {
+    withSync(() => {
+      term.moveTo(1, findResultsStartRow() + findViewportSize() * 2);
+      paintFindIndicator();
+    });
+  };
+  const repaintFindViewport = () => {
+    withSync(() => {
+      const v = findViewportSize();
+      const sCount = findResults.length;
+      const listFocused = findSubMode !== "input";
+      for (let i = 0; i < v; i++) {
+        const idx = findScrollOffset + i;
+        term.moveTo(1, findResultsStartRow() + i * 2);
+        if (idx < sCount) {
+          paintFindResultA(idx, listFocused && idx === findSelectedIdx);
+        } else {
+          term.eraseLineAfter();
+        }
+        term.moveTo(1, findResultsStartRow() + i * 2 + 1);
+        if (idx < sCount) {
+          paintFindResultB(idx, listFocused && idx === findSelectedIdx);
+        } else {
+          term.eraseLineAfter();
         }
-        const [keys, desc] = entry;
-        term.brightCyan.noFormat(`  ${keys.padEnd(HELP_KEYS_WIDTH)}`);
-        term.noFormat(desc)("\n");
       }
-      term("\n");
-      term.dim.noFormat("  press any key to dismiss")("\n");
+      term.moveTo(1, findResultsStartRow() + v * 2);
+      paintFindIndicator();
     });
   };
+  const findQueryText = () => findComposer.state().buffer.join("\n");
+  const runFind = async () => {
+    const query = findQueryText().trim();
+    if (query.length === 0) {
+      return;
+    }
+    if (visible.length === 0) {
+      findError = "no sessions in view to search";
+      renderFind();
+      return;
+    }
+    findInFlight = true;
+    findError = null;
+    renderFind();
+    try {
+      const out = await searchSessions(opts.target, query, {
+        sessionIds: visible.map((s) => s.sessionId)
+      });
+      findResults = out.results;
+      findTruncated = out.truncated;
+      findSelectedIdx = 0;
+      findSnippetIdx = 0;
+      findScrollOffset = 0;
+      findSubMode = out.results.length > 0 ? "results" : "input";
+      computeFindBoxLayout();
+    } catch (err) {
+      findError = `search failed: ${err.message}`;
+    } finally {
+      findInFlight = false;
+      renderFind();
+    }
+  };
+  let exitFind = () => {
+  };
   const repaintComposerChrome = () => {
     withSync(() => {
       const showCursor = selectedIdx === 0;
@@ -10441,23 +11658,48 @@ async function pickSession(term, opts) {
     let resolved = false;
     let autoRefreshTimer = null;
     let autoRefreshInFlight = false;
-    const onResize = () => {
-      if (resolved) {
-        return;
+    const focusStack = [];
+    const pushLayer = (layer) => {
+      focusStack.push(layer);
+    };
+    const popLayer = () => {
+      focusStack.pop();
+      if (!resolved) {
+        focusStack[focusStack.length - 1]?.onResize();
       }
-      renderFromScratch();
+    };
+    const focus = { push: pushLayer, pop: popLayer };
+    exitFind = () => {
+      findComposer = new InputDispatcher({ history: [] });
+      findResults = [];
+      findTruncated = false;
+      findSelectedIdx = 0;
+      findSnippetIdx = 0;
+      findScrollOffset = 0;
+      findError = null;
+      findInFlight = false;
+      findSubMode = "input";
+      popLayer();
+    };
+    const dispatch = (name, _matches, data) => {
+      focusStack[focusStack.length - 1]?.onKey(name, _matches, data);
+    };
+    const dispatchResize = () => {
+      if (resolved) return;
+      focusStack[focusStack.length - 1]?.onResize();
     };
     const cleanup = () => {
       if (resolved) {
         return;
       }
       resolved = true;
+      focusStack.length = 0;
       if (autoRefreshTimer) {
         clearInterval(autoRefreshTimer);
         autoRefreshTimer = null;
       }
-      term.off("key", onKey);
-      term.off("resize", onResize);
+      term.off("key", dispatch);
+      term.off("resize", dispatchResize);
       process.stdout.write("\x1B[?2004l");
       const tClean = term;
       if (tClean.stdin && tkStdinHandler) {
@@ -10613,18 +11855,231 @@ ${cells}`;
       paintIndicator();
       return true;
     };
-    const onKey = (name, _matches, data) => {
-      if (mode === "busy") {
+    const openHelpLayer = () => {
+      renderHelp();
+      pushLayer({
+        onKey: (name) => {
+          if (name === "CTRL_C") {
+            cleanup();
+            resolve6({ kind: "abort" });
+            return;
+          }
+          popLayer();
+        },
+        onResize: () => renderHelp()
+      });
+    };
+    const openFindLayer = () => {
+      if (visible.length === 0) {
+        transientStatus = "no sessions to search";
+        paintIndicator();
         return;
       }
-      if (mode === "help") {
-        if (name === "CTRL_C") {
-          cleanup();
-          resolve6({ kind: "abort" });
+      findComposer = new InputDispatcher({ history: [] });
+      findResults = [];
+      findTruncated = false;
+      findSelectedIdx = 0;
+      findSnippetIdx = 0;
+      findScrollOffset = 0;
+      findError = null;
+      findInFlight = false;
+      findSubMode = "input";
+      computeFindBoxLayout();
+      renderFind();
+      const findOnKey = (name, _matches, data) => {
+        if (findSubMode === "input") {
+          if (findInFlight) {
+            return;
+          }
+          if (name === "ESCAPE" || name === "CTRL_C") {
+            exitFind();
+            return;
+          }
+          if (name === "ENTER" || name === "KP_ENTER") {
+            if (findQueryText().trim().length === 0) {
+              return;
+            }
+            void runFind();
+            return;
+          }
+          if ((name === "DOWN" || name === "TAB" || name === "CTRL_N") && findResults.length > 0) {
+            findSubMode = "results";
+            findSelectedIdx = 0;
+            findSnippetIdx = 0;
+            withSync(() => {
+              repaintFindBoxChrome();
+              repaintFindResult(0, true);
+              repaintFindIndicatorRow();
+              term.hideCursor();
+            });
+            return;
+          }
+          const before = findComposer.state();
+          let event = null;
+          if (data?.isCharacter) {
+            event = { type: "char", ch: name };
+          } else {
+            const mapped = mapKeyName(name);
+            if (mapped !== null)
+              event = { type: "key", name: mapped };
+          }
+          if (event === null) {
+            term.moveTo(findBoxCursorCol(), findBoxCursorScreenRow());
+            return;
+          }
+          findComposer.feed(event);
+          const after = findComposer.state();
+          const unchanged = before.buffer.length === after.buffer.length && before.buffer.every((l, i) => l === after.buffer[i]) && before.row === after.row && before.col === after.col;
+          if (unchanged) {
+            term.moveTo(findBoxCursorCol(), findBoxCursorScreenRow());
+            return;
+          }
+          const prevRows = findBoxRows;
+          computeFindBoxLayout();
+          if (findBoxRows !== prevRows) {
+            renderFind();
+          } else {
+            repaintFindBoxBodyRows();
+          }
           return;
         }
-        mode = "normal";
-        renderFromScratch();
+        if (findSubMode === "results") {
+          if (name === "ESCAPE" || name === "CTRL_C") {
+            exitFind();
+            return;
+          }
+          if (name === "CTRL_F") {
+            findSubMode = "input";
+            repaintFindViewport();
+            repaintFindIndicatorRow();
+            repaintFindBoxChrome();
+            return;
+          }
+          if (name === "ENTER" || name === "KP_ENTER") {
+            const hit = findResults[findSelectedIdx];
+            if (!hit) {
+              return;
+            }
+            const session = visible.find((s) => s.sessionId === hit.sessionId);
+            const isImportedPassive = !!session?.importedFromMachine && !session.upstreamSessionId;
+            if (isImportedPassive) {
+              cleanup();
+              const result = {
+                kind: "attach",
+                sessionId: hit.sessionId
+              };
+              if (session.agentId !== void 0) {
+                result.agentId = session.agentId;
+              }
+              resolve6(result);
+              return;
+            }
+            void (async () => {
+              const action = await promptForLaunchOrView(term, {
+                sessionId: hit.sessionId,
+                title: hit.title,
+                cwd: hit.cwd
+              }, focus);
+              if (action === "cancel") {
+                cleanup();
+                resolve6({ kind: "abort" });
+                return;
+              }
+              if (action === "back") return;
+              cleanup();
+              const result = {
+                kind: "attach",
+                sessionId: hit.sessionId,
+                readonly: action === "view"
+              };
+              if (session?.agentId !== void 0) {
+                result.agentId = session.agentId;
+              }
+              resolve6(result);
+            })();
+            return;
+          }
+          if (data?.isCharacter && (name === "n" || name === "N")) {
+            const hit = findResults[findSelectedIdx];
+            if (!hit || hit.snippets.length <= 1) {
+              return;
+            }
+            findSnippetIdx = (findSnippetIdx + 1) % hit.snippets.length;
+            repaintFindResult(findSelectedIdx, true);
+            return;
+          }
+          if (data?.isCharacter && (name === "p" || name === "P")) {
+            const hit = findResults[findSelectedIdx];
+            if (!hit || hit.snippets.length <= 1) {
+              return;
+            }
+            findSnippetIdx = (findSnippetIdx - 1 + hit.snippets.length) % hit.snippets.length;
+            repaintFindResult(findSelectedIdx, true);
+            return;
+          }
+          const moveDeep = (delta) => {
+            if (delta < 0 && findSelectedIdx === 0) {
+              findSubMode = "input";
+              withSync(() => {
+                repaintFindResult(0, false);
+                repaintFindIndicatorRow();
+                repaintFindBoxChrome();
+              });
+              return;
+            }
+            const next = Math.min(
+              findResults.length - 1,
+              Math.max(0, findSelectedIdx + delta)
+            );
+            if (next === findSelectedIdx) {
+              return;
+            }
+            const oldIdx = findSelectedIdx;
+            const oldScroll = findScrollOffset;
+            findSelectedIdx = next;
+            findSnippetIdx = 0;
+            adjustFindScroll();
+            if (findScrollOffset !== oldScroll) {
+              repaintFindViewport();
+            } else {
+              withSync(() => {
+                repaintFindResult(oldIdx, false);
+                repaintFindResult(findSelectedIdx, true);
+              });
+              repaintFindIndicatorRow();
+            }
+          };
+          switch (name) {
+            case "UP":
+            case "SHIFT_TAB":
+            case "CTRL_P":
+              moveDeep(-1);
+              return;
+            case "DOWN":
+            case "TAB":
+            case "CTRL_N":
+              moveDeep(1);
+              return;
+            case "PAGE_UP":
+              moveDeep(-findViewportSize());
+              return;
+            case "PAGE_DOWN":
+              moveDeep(findViewportSize());
+              return;
+            case "HOME":
+              moveDeep(-findSelectedIdx);
+              return;
+            case "END":
+              moveDeep(findResults.length);
+              return;
+          }
+          return;
+        }
+      };
+      pushLayer({ onKey: findOnKey, onResize: () => renderFind() });
+    };
+    const onKey = (name, _matches, data) => {
+      if (mode === "busy") {
         return;
       }
       if (mode === "rename") {
@@ -10688,6 +12143,10 @@ ${cells}`;
         return;
       }
       clearTransient();
+      if (name === "CTRL_F") {
+        openFindLayer();
+        return;
+      }
       if (selectedIdx === 0 && !searchActive) {
         if (name === "ESCAPE" || name === "CTRL_C" || name === "CTRL_D") {
           cleanup();
@@ -10759,8 +12218,7 @@ ${cells}`;
         return;
       }
       if (!searchActive && data?.isCharacter && name === "?") {
-        mode = "help";
-        renderHelp();
+        openHelpLayer();
         return;
       }
       if (searchActive) {
@@ -10820,13 +12278,7 @@ ${cells}`;
           const keepId = selectedIdx > 0 ? visible[selectedIdx - 1]?.sessionId : void 0;
           prefs.filters.cwdOnly = !prefs.filters.cwdOnly;
           applyFilter();
-          if (keepId !== void 0) {
-            const idx = visible.findIndex((s) => s.sessionId === keepId);
-            if (idx >= 0) {
-              selectedIdx = idx + 1;
-              adjustScroll();
-            }
-          }
+          restoreCursorAfterFilter(keepId);
           renderFromScratch();
           return;
         }
@@ -10837,13 +12289,15 @@ ${cells}`;
             allSessions
           );
           applyFilter();
-          if (keepId !== void 0) {
-            const idx = visible.findIndex((s) => s.sessionId === keepId);
-            if (idx >= 0) {
-              selectedIdx = idx + 1;
-              adjustScroll();
-            }
-          }
+          restoreCursorAfterFilter(keepId);
+          renderFromScratch();
+          return;
+        }
+        if (name === "i" || name === "I") {
+          const keepId = selectedIdx > 0 ? visible[selectedIdx - 1]?.sessionId : void 0;
+          prefs.filters.showCat = !prefs.filters.showCat;
+          applyFilter();
+          restoreCursorAfterFilter(keepId);
           renderFromScratch();
           return;
         }
@@ -10980,6 +12434,12 @@ ${cells}`;
           return;
       }
     };
+    pushLayer({
+      onKey: (name, _matches, data) => onKey(name, _matches, data),
+      onResize: () => {
+        if (!resolved) renderFromScratch();
+      }
+    });
     term.grabInput({});
     const tSetup = term;
     if (tSetup.stdin && typeof tSetup.onStdin === "function") {
@@ -10988,10 +12448,10 @@ ${cells}`;
       tSetup.stdin.on("data", rawStdinHandler);
       process.stdout.write("\x1B[?2004h");
     }
-    term.on("key", onKey);
-    term.on("resize", onResize);
+    term.on("key", dispatch);
+    term.on("resize", dispatchResize);
     autoRefreshTimer = setInterval(() => {
-      if (resolved || mode !== "normal" || searchActive || autoRefreshInFlight) {
+      if (resolved || focusStack.length > 1 || mode !== "normal" || searchActive || autoRefreshInFlight) {
         return;
       }
       const currentId = selectedIdx > 0 ? visible[selectedIdx - 1]?.sessionId : void 0;
@@ -11002,10 +12462,10 @@ ${cells}`;
     }, 3e3);
   });
 }
-function readTermHeight(term) {
+function readTermHeight2(term) {
   return term.height ?? 24;
 }
-function readTermWidth(term) {
+function readTermWidth2(term) {
   return term.width ?? 80;
 }
 function formatComposerTitle(cwd, maxWidth) {
@@ -11060,19 +12520,22 @@ function matchesSearch(s, term) {
   }
   return false;
 }
-var ROW_PREFIX_WIDTH, PICKER_COMPOSER_MAX_ROWS, BOX_HORIZONTAL_PAD, HELP_KEYS_WIDTH, HELP_ENTRIES;
+var ROW_PREFIX_WIDTH, PICKER_COMPOSER_MAX_ROWS, FIND_BOX_MAX_ROWS, BOX_HORIZONTAL_PAD, HELP_KEYS_WIDTH, HELP_ENTRIES;
 var init_picker = __esm({
   "src/tui/picker.ts"() {
     "use strict";
     init_session_row();
     init_paths();
     init_session();
+    init_hydra_version();
     init_discovery();
     init_input();
     init_screen();
+    init_import_action_prompt();
     init_sync();
     ROW_PREFIX_WIDTH = 2;
     PICKER_COMPOSER_MAX_ROWS = 4;
+    FIND_BOX_MAX_ROWS = 4;
     BOX_HORIZONTAL_PAD = 4;
     HELP_KEYS_WIDTH = 20;
     HELP_ENTRIES = [
@@ -11085,9 +12548,11 @@ var init_picker = __esm({
       ["Enter", "open selected session"],
       ["v", "view-only (open transcript without spawning the agent)"],
       null,
-      ["/", "search sessions"],
+      ["/", "search sessions (metadata)"],
+      ["^f", "find in session history (content + tool inputs)"],
       ["o", "toggle cwd-only filter"],
       ["h", "cycle host filter (local / <peer> / all)"],
+      ["i", "toggle include-cat filter"],
       ["r", "refresh from daemon"],
       null,
       ["k", "kill the selected live session"],
@@ -11116,105 +12581,15 @@ async function validateLocalCwd(input) {
   } catch {
     return { ok: false, reason: `${resolved} does not exist` };
   }
-  if (!stat5.isDirectory()) {
-    return { ok: false, reason: `${resolved} is not a directory` };
-  }
-  return { ok: true, path: resolved };
-}
-var init_cwd = __esm({
-  "src/core/cwd.ts"() {
-    "use strict";
-    init_config();
-  }
-});
-
-// src/tui/prompt-utils.ts
-function resetTerminalModes() {
-  process.stdout.write("\x1B[<u");
-  process.stdout.write("\x1B[?2004l");
-  process.stdout.write("\x1B[>4;0m");
-  process.stdout.write("\x1B[>5;0m");
-  process.stdout.write("\x1B[?1000l");
-  process.stdout.write("\x1B[?1002l");
-  process.stdout.write("\x1B[?1006l");
-  process.stdout.write("\x1B[?1l");
-  process.stdout.write("\x1B>");
-}
-function readTermWidth2(term) {
-  return term.width ?? 80;
-}
-function readTermHeight2(term) {
-  return term.height ?? 24;
-}
-function drawBox(term, opts) {
-  const termW = readTermWidth2(term);
-  const termH = readTermHeight2(term);
-  const desiredContentW = opts.contentWidth ?? MAX_BOX_WIDTH;
-  const maxContentW = Math.max(10, Math.min(MAX_BOX_WIDTH, termW - 4));
-  const contentW = Math.min(desiredContentW, maxContentW);
-  const w = contentW + 2;
-  const contentH = Math.max(1, Math.min(opts.contentHeight, termH - 4));
-  const h = contentH + 2;
-  const x = Math.max(1, Math.floor((termW - w) / 2) + 1);
-  const y = Math.max(1, Math.floor((termH - h) / 2) + 1);
-  term.moveTo(1, 1).eraseDisplayBelow();
-  const topInner = HORIZ.repeat(w - 2);
-  const top = renderTitleStrip(topInner, opts.title);
-  term.moveTo(x, y);
-  term.dim.noFormat(TL);
-  paintTopStrip(term, top);
-  term.dim.noFormat(TR);
-  for (let row = 1; row <= contentH; row++) {
-    term.moveTo(x, y + row);
-    term.dim.noFormat(VERT);
-    term.moveTo(x + w - 1, y + row);
-    term.dim.noFormat(VERT);
-  }
-  term.moveTo(x, y + h - 1);
-  term.dim.noFormat(BL + HORIZ.repeat(w - 2) + BR);
-  return {
-    x,
-    y,
-    w,
-    h,
-    contentX: x + 1,
-    contentY: y + 1,
-    contentW,
-    contentH
-  };
-}
-function renderTitleStrip(innerDashes, title) {
-  if (!title) {
-    return { dashes: innerDashes };
-  }
-  const chip = ` ${title} `;
-  if (chip.length + 4 > innerDashes.length) {
-    return { dashes: innerDashes };
-  }
-  const offset = 2;
-  const dashes = innerDashes.slice(0, offset) + " ".repeat(chip.length) + innerDashes.slice(offset + chip.length);
-  return { dashes, title: { offset, text: chip } };
-}
-function paintTopStrip(term, strip) {
-  if (!strip.title) {
-    term.dim.noFormat(strip.dashes);
-    return;
+  if (!stat5.isDirectory()) {
+    return { ok: false, reason: `${resolved} is not a directory` };
   }
-  term.dim.noFormat(strip.dashes.slice(0, strip.title.offset));
-  term.brightCyan.noFormat(strip.title.text);
-  term.dim.noFormat(strip.dashes.slice(strip.title.offset + strip.title.text.length));
+  return { ok: true, path: resolved };
 }
-var MAX_BOX_WIDTH, HORIZ, VERT, TL, TR, BL, BR;
-var init_prompt_utils = __esm({
-  "src/tui/prompt-utils.ts"() {
+var init_cwd = __esm({
+  "src/core/cwd.ts"() {
     "use strict";
-    MAX_BOX_WIDTH = 64;
-    HORIZ = "\u2500";
-    VERT = "\u2502";
-    TL = "\u250C";
-    TR = "\u2510";
-    BL = "\u2514";
-    BR = "\u2518";
+    init_config();
   }
 });
 
@@ -11246,7 +12621,7 @@ async function promptForImportCwd(term, session, opts = {}) {
     for (const hr of headerRows) {
       term.moveTo(layout.contentX, layout.contentY + row);
       term.dim.noFormat(` ${hr.label}`);
-      term.noFormat(truncate2(hr.value, innerW - hr.label.length - 2));
+      term.noFormat(truncate3(hr.value, innerW - hr.label.length - 2));
       row++;
     }
     row++;
@@ -11257,7 +12632,7 @@ async function promptForImportCwd(term, session, opts = {}) {
     row += 2;
     if (errorLine !== null) {
       term.moveTo(layout.contentX, layout.contentY + row);
-      term.red.noFormat(` ${truncate2(errorLine, innerW - 2)}`);
+      term.red.noFormat(` ${truncate3(errorLine, innerW - 2)}`);
     } else {
       term.moveTo(layout.contentX, layout.contentY + row);
       term.dim.noFormat(
@@ -11293,7 +12668,7 @@ async function promptForImportCwd(term, session, opts = {}) {
     term.dim.noFormat("\u2502");
     term.moveTo(layout.contentX, layout.contentY + errRow);
     if (errorLine !== null) {
-      term.red.noFormat(` ${truncate2(errorLine, layout.contentW - 2)}`);
+      term.red.noFormat(` ${truncate3(errorLine, layout.contentW - 2)}`);
     } else {
       term.dim.noFormat(
         " Enter accept \xB7 Esc back \xB7 ^U clear \xB7 ^W kill word"
@@ -11389,7 +12764,7 @@ async function promptForImportCwd(term, session, opts = {}) {
     term.on("resize", onResize);
   });
 }
-function truncate2(s, max) {
+function truncate3(s, max) {
   if (max <= 1) {
     return "";
   }
@@ -11417,226 +12792,6 @@ var init_import_cwd_prompt = __esm({
   }
 });
 
-// src/tui/import-action-prompt.ts
-function actionPromptStep(selected, key, choices = ACTION_CHOICES) {
-  if (key.kind === "cancel") {
-    return { kind: "cancel" };
-  }
-  if (key.kind === "back") {
-    return { kind: "back" };
-  }
-  if (key.kind === "enter") {
-    const choice = choices[selected];
-    if (!choice) {
-      return { kind: "back" };
-    }
-    return { kind: "resolve", action: choice.key };
-  }
-  if (key.kind === "up") {
-    return {
-      kind: "continue",
-      selected: Math.max(0, selected - 1)
-    };
-  }
-  if (key.kind === "down") {
-    return {
-      kind: "continue",
-      selected: Math.min(choices.length - 1, selected + 1)
-    };
-  }
-  if (key.kind === "char") {
-    const lower = key.ch.toLowerCase();
-    if (lower === "n") {
-      return {
-        kind: "continue",
-        selected: Math.min(choices.length - 1, selected + 1)
-      };
-    }
-    if (lower === "p") {
-      return {
-        kind: "continue",
-        selected: Math.max(0, selected - 1)
-      };
-    }
-    const idx = choices.findIndex((c) => c.hotkey.toLowerCase() === lower);
-    if (idx >= 0) {
-      const choice = choices[idx];
-      if (choice) {
-        return { kind: "resolve", action: choice.key };
-      }
-    }
-  }
-  return { kind: "continue", selected };
-}
-async function promptForImportAction(term, session) {
-  resetTerminalModes();
-  const shortId2 = stripHydraSessionPrefix(session.sessionId);
-  const fromMachine = session.importedFromMachine ?? "another machine";
-  const originalCwd = shortenHomePath(session.cwd);
-  let selected = ACTION_CHOICES.findIndex((c) => c.key === "view");
-  if (selected < 0) {
-    selected = 0;
-  }
-  const render = () => {
-    const choiceRows = ACTION_CHOICES.length * 2;
-    const contentHeight = 7 + choiceRows + 2;
-    const layout = drawBox(term, {
-      contentHeight,
-      title: "Imported session"
-    });
-    const innerW = layout.contentW;
-    const headerRows = [
-      { label: "session: ", value: shortId2 },
-      { label: "from:    ", value: fromMachine },
-      { label: "cwd:     ", value: originalCwd }
-    ];
-    let row = 0;
-    for (const hr of headerRows) {
-      term.moveTo(layout.contentX, layout.contentY + row);
-      term.dim.noFormat(` ${hr.label}`);
-      term.noFormat(truncate3(hr.value, innerW - hr.label.length - 2));
-      row++;
-    }
-    row++;
-    term.moveTo(layout.contentX, layout.contentY + row);
-    term.noFormat(" What do you want to do?");
-    row += 2;
-    for (let i = 0; i < ACTION_CHOICES.length; i++) {
-      const choice = ACTION_CHOICES[i];
-      if (!choice) {
-        continue;
-      }
-      const pointer = i === selected ? "\u276F" : " ";
-      const label = ` ${pointer} ${choice.label}`;
-      term.moveTo(layout.contentX, layout.contentY + row);
-      if (i === selected) {
-        term.brightWhite.bgBlue.noFormat(padRight(label, innerW));
-      } else {
-        term.noFormat(label);
-      }
-      row++;
-      term.moveTo(layout.contentX, layout.contentY + row);
-      term.dim.noFormat(`     ${choice.description}`);
-      row++;
-    }
-    row++;
-    term.moveTo(layout.contentX, layout.contentY + row);
-    term.dim.noFormat(" \u2191/\u2193 navigate \xB7 Enter select \xB7 f/v jump \xB7 Esc back");
-    return layout;
-  };
-  render();
-  term.hideCursor();
-  return await new Promise((resolve6) => {
-    let resolved = false;
-    const cleanup = () => {
-      if (resolved) {
-        return;
-      }
-      resolved = true;
-      term.off("key", onKey);
-      term.off("resize", onResize);
-      term.grabInput(false);
-      term.hideCursor(false);
-      term.moveTo(1, 1).eraseDisplayBelow();
-    };
-    const finish = (value) => {
-      cleanup();
-      resolve6(value);
-    };
-    const onResize = () => {
-      if (resolved) {
-        return;
-      }
-      render();
-    };
-    const onKey = (name, _matches, data) => {
-      const input = mapKey(name, data);
-      if (!input) {
-        return;
-      }
-      const step = actionPromptStep(selected, input);
-      if (step.kind === "cancel") {
-        finish("cancel");
-        return;
-      }
-      if (step.kind === "back") {
-        finish("back");
-        return;
-      }
-      if (step.kind === "resolve") {
-        finish(step.action);
-        return;
-      }
-      if (step.selected !== selected) {
-        selected = step.selected;
-        render();
-      }
-    };
-    term.grabInput({});
-    term.on("key", onKey);
-    term.on("resize", onResize);
-  });
-}
-function mapKey(name, data) {
-  if (name === "UP") {
-    return { kind: "up" };
-  }
-  if (name === "DOWN") {
-    return { kind: "down" };
-  }
-  if (name === "ENTER" || name === "KP_ENTER") {
-    return { kind: "enter" };
-  }
-  if (name === "ESCAPE") {
-    return { kind: "back" };
-  }
-  if (name === "CTRL_C" || name === "CTRL_D") {
-    return { kind: "cancel" };
-  }
-  if (data?.isCharacter) {
-    return { kind: "char", ch: name };
-  }
-  return null;
-}
-function truncate3(s, max) {
-  if (max <= 1) {
-    return "";
-  }
-  if (s.length <= max) {
-    return s;
-  }
-  return s.slice(0, Math.max(0, max - 1)) + "\u2026";
-}
-function padRight(s, w) {
-  if (s.length >= w) {
-    return s.slice(0, w);
-  }
-  return s + " ".repeat(w - s.length);
-}
-var ACTION_CHOICES;
-var init_import_action_prompt = __esm({
-  "src/tui/import-action-prompt.ts"() {
-    "use strict";
-    init_paths();
-    init_session();
-    init_prompt_utils();
-    ACTION_CHOICES = [
-      {
-        key: "fork-local",
-        label: "Fork locally",
-        hotkey: "f",
-        description: "spawn a local fork \u2014 original imported copy stays as-is"
-      },
-      {
-        key: "view",
-        label: "View transcript",
-        hotkey: "v",
-        description: "open read-only, no agent spawn"
-      }
-    ];
-  }
-});
-
 // src/tui/clipboard.ts
 import { spawn as nodeSpawn } from "child_process";
 import fs21 from "fs/promises";
@@ -12035,41 +13190,69 @@ function formatEvent(event) {
       return [];
   }
 }
-function applyInlineMarkup(text) {
+function applyInlineMarkup(text, opts) {
+  const codeOpen = opts?.codeOpen ?? "^C";
+  const boldReset = opts?.boldReset ?? "^:";
+  const codeReset = opts?.codeReset ?? "^:";
   let s = text.replace(/\^/g, "^^");
-  s = s.replace(/\*\*(.+?)\*\*/g, "^+$1^:");
-  s = s.replace(/`([^`]+)`/g, "^C$1^:");
+  s = s.replace(/\*\*(.+?)\*\*/g, `^+$1${boldReset}`);
+  s = s.replace(/`([^`]+)`/g, `${codeOpen}$1${codeReset}`);
   return s;
 }
-function parseAgentMarkdown(text) {
+function parseMarkdown(text, opts) {
+  const {
+    proseStyle,
+    highlightCode,
+    prefixStyle,
+    firstPrefix = "  ",
+    inlineOpts
+  } = opts;
   const out = [];
   const lines = text.split("\n");
   let inCode = false;
   let codeLang = "";
   let codeBuffer = [];
+  let firstNonBlank = firstPrefix !== "  ";
+  const line = (body, bodyStyle, prefix = "  ") => {
+    const entry = { prefix, body, bodyStyle };
+    if (prefixStyle !== void 0)
+      entry.prefixStyle = prefixStyle;
+    out.push(entry);
+  };
+  const nextPrefix = () => {
+    if (!firstNonBlank)
+      return "  ";
+    firstNonBlank = false;
+    return firstPrefix;
+  };
   const flushCode = () => {
-    if (codeBuffer.length === 0) {
+    if (codeBuffer.length === 0)
       return;
-    }
-    const highlighted = highlightFencedBlock(codeLang, codeBuffer);
-    for (const piece of highlighted) {
-      const entry = {
-        prefix: "  ",
-        body: piece.body,
-        bodyStyle: "code",
-        fillRow: true
-      };
-      if (piece.ansi) {
-        entry.ansi = true;
+    if (highlightCode) {
+      const highlighted = highlightFencedBlock(codeLang, codeBuffer);
+      for (const piece of highlighted) {
+        const entry = {
+          prefix: "  ",
+          body: piece.body,
+          bodyStyle: "code",
+          fillRow: true
+        };
+        if (prefixStyle !== void 0)
+          entry.prefixStyle = prefixStyle;
+        if (piece.ansi)
+          entry.ansi = true;
+        out.push(entry);
       }
-      out.push(entry);
+    } else {
+      for (const cl of codeBuffer)
+        line(cl.replace(/\^/g, "^^"), proseStyle);
     }
     codeBuffer = [];
     codeLang = "";
   };
   for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const fence = line.match(/^\s*```\s*(\w*)\s*$/);
+    const l = lines[i];
+    const fence = l.match(/^\s*```\s*(\w*)\s*$/);
     if (fence) {
       if (!inCode) {
         inCode = true;
@@ -12081,68 +13264,81 @@ function parseAgentMarkdown(text) {
       continue;
     }
     if (inCode) {
-      codeBuffer.push(line);
+      codeBuffer.push(l);
       continue;
     }
-    const heading = line.match(/^(#{1,6})\s+(.*)$/);
+    const heading = l.match(/^(#{1,6})\s+(.*)$/);
     if (heading) {
       const level = heading[1].length;
-      const text2 = heading[2] ?? "";
-      const style = level === 1 ? "heading-1" : level === 2 ? "heading-2" : "heading-3";
-      out.push({
-        prefix: "  ",
-        body: text2,
-        bodyStyle: style
-      });
+      const headingText = heading[2] ?? "";
+      const headingStyle = highlightCode ? level === 1 ? "heading-1" : level === 2 ? "heading-2" : "heading-3" : proseStyle;
+      line(headingText, headingStyle, nextPrefix());
       continue;
     }
     const next = lines[i + 1];
-    if (line.includes("|") && next !== void 0 && isTableSeparatorLine(next) && parseTableRow(line).length === parseTableRow(next).length) {
-      const header = parseTableRow(line);
+    if (l.includes("|") && next !== void 0 && isTableSeparatorLine(next) && parseTableRow(l).length === parseTableRow(next).length) {
+      const header = parseTableRow(l);
       const body = [];
       let j = i + 2;
       while (j < lines.length && lines[j].includes("|")) {
         body.push(parseTableRow(lines[j]));
         j++;
       }
-      out.push(...formatTable(header, body));
+      const tableLines = formatTable(header, body);
+      for (const tl of tableLines) {
+        if (prefixStyle !== void 0)
+          tl.prefixStyle = prefixStyle;
+        out.push(tl);
+      }
       i = j - 1;
       continue;
     }
-    const bullet = line.match(/^(\s*)[-*+]\s+(.*)$/);
+    const bullet = l.match(/^(\s*)[-*+]\s+(.*)$/);
     if (bullet) {
       const indent = bullet[1] ?? "";
       const item = bullet[2] ?? "";
-      out.push({
-        prefix: "  ",
-        body: `${indent}\u2022 ${applyInlineMarkup(item)}`,
-        bodyStyle: "agent"
-      });
+      line(
+        `${indent}\u2022 ${applyInlineMarkup(item, inlineOpts)}`,
+        proseStyle,
+        nextPrefix()
+      );
       continue;
     }
-    const ordered = line.match(/^(\s*)(\d+)\.\s+(.*)$/);
+    const ordered = l.match(/^(\s*)(\d+)\.\s+(.*)$/);
     if (ordered) {
       const indent = ordered[1] ?? "";
       const num = ordered[2] ?? "";
       const item = ordered[3] ?? "";
-      out.push({
-        prefix: "  ",
-        body: `${indent}${num}. ${applyInlineMarkup(item)}`,
-        bodyStyle: "agent"
-      });
+      line(
+        `${indent}${num}. ${applyInlineMarkup(item, inlineOpts)}`,
+        proseStyle,
+        nextPrefix()
+      );
       continue;
     }
-    out.push({
-      prefix: "  ",
-      body: applyInlineMarkup(line),
-      bodyStyle: "agent"
-    });
+    const isBlank = l.trim() === "";
+    line(
+      applyInlineMarkup(l, inlineOpts),
+      proseStyle,
+      isBlank ? "  " : nextPrefix()
+    );
   }
-  if (inCode) {
+  if (inCode)
     flushCode();
-  }
   return out;
 }
+function parseAgentMarkdown(text) {
+  return parseMarkdown(text, { proseStyle: "agent", highlightCode: true });
+}
+function parseThoughtMarkdown(text) {
+  return parseMarkdown(text, {
+    proseStyle: "thought",
+    highlightCode: false,
+    prefixStyle: "thought",
+    firstPrefix: "\xB7 ",
+    inlineOpts: { codeOpen: "^c", boldReset: "^-", codeReset: "^K" }
+  });
+}
 function parseTableRow(line) {
   let s = line.trim();
   if (s.startsWith("|")) {
@@ -12893,6 +14089,9 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     if (teardownStarted) {
       return { outcome: { outcome: "cancelled" } };
     }
+    if (opts.dangerouslySkipPermissions) {
+      return buildApproveResponse(params);
+    }
     const p = params ?? {};
     const rawOptions = Array.isArray(p.options) ? p.options : [];
     const options = rawOptions.map((o) => ({
@@ -14169,6 +15368,33 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     agentKey = null;
     agentBuffer = "";
   };
+  let thoughtBuffer = "";
+  let thoughtKey = null;
+  let thoughtSeq = 0;
+  const renderThoughtBlock = () => {
+    if (thoughtKey === null)
+      return;
+    const lines = parseThoughtMarkdown(thoughtBuffer);
+    if (lines.length === 0)
+      return;
+    screen.upsertLines(thoughtKey, lines);
+  };
+  const appendThought = (text) => {
+    if (text.length === 0)
+      return;
+    if (thoughtKey === null) {
+      screen.ensureSeparator();
+      thoughtKey = `thought:${thoughtSeq}`;
+      thoughtSeq += 1;
+      thoughtBuffer = "";
+    }
+    thoughtBuffer += text;
+    renderThoughtBlock();
+  };
+  const closeThought = () => {
+    thoughtKey = null;
+    thoughtBuffer = "";
+  };
   const renderToolsBlock = () => {
     if (toolsBlockStartedAt === null) {
       return;
@@ -14310,6 +15536,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         recordHistoryEntry(event.text);
       }
       closeAgentText();
+      closeThought();
       if (toolsBlockStartedAt !== null) {
         toolsBlockEndedAt = Date.now();
         renderToolsBlock();
@@ -14333,16 +15560,18 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       return;
     }
     if (event.kind === "agent-text") {
+      closeThought();
       appendAgentText(event.text);
       return;
     }
     if (event.kind === "agent-thought") {
       closeAgentText();
-      screen.appendStreaming(event.text, "\xB7 ", "thought", "thought");
+      appendThought(event.text);
       return;
     }
     if (event.kind === "exit-plan-mode") {
       closeAgentText();
+      closeThought();
       const existing = exitPlanStates.get(event.toolCallId);
       const merged = {
         plan: event.plan ?? existing?.plan ?? "",
@@ -14360,12 +15589,14 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     }
     if (event.kind === "tool-call") {
       closeAgentText();
+      closeThought();
       recordToolCall(event.toolCallId, event.title, event.status, void 0);
       renderToolsBlock();
       return;
     }
     if (event.kind === "plan") {
       closeAgentText();
+      closeThought();
       lastPlanEvent = event;
       const lines = formatEvent(event);
       if (lines.length > 0) {
@@ -14375,6 +15606,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     }
     if (event.kind === "tool-call-update") {
       closeAgentText();
+      closeThought();
       recordToolCall(
         event.toolCallId,
         event.title,
@@ -14397,6 +15629,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     if (event.kind === "turn-complete") {
       currentHeadMessageId = void 0;
       closeAgentText();
+      closeThought();
       let effectiveStopReason = event.amended ? "amended" : event.stopReason;
       if (!event.amended && upstreamInterruptedSeen && (effectiveStopReason === void 0 || effectiveStopReason === "end_turn")) {
         effectiveStopReason = "error";
@@ -14491,6 +15724,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       resolve6({ outcome: { outcome: "cancelled" } });
     }
     closeAgentText();
+    closeThought();
   };
   const markToolsBlockRecoveryFailed = () => {
     if (toolsBlockStartedAt === null) {
@@ -14870,6 +16104,7 @@ var init_app = __esm({
     init_session();
     init_paths();
     init_hydra_version();
+    init_permission_pick();
     init_update_check();
     init_history();
     init_discovery();
@@ -14938,9 +16173,14 @@ import { dirname as dirname6, resolve as resolve5 } from "path";
 // src/cli/parse-args.ts
 var KNOWN_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "all",
+  "dangerously-skip-permissions",
   "detach",
+  "disabled",
+  "follow",
+  "force",
   "foreground",
   "help",
+  "include-cat",
   "info",
   "json",
   "new",
@@ -14948,9 +16188,32 @@ var KNOWN_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "readonly",
   "replace",
   "rotate-token",
-  "stream",
   "version"
 ]);
+var KNOWN_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "agent",
+  "args",
+  "command",
+  "cwd",
+  "env",
+  "host",
+  "model",
+  "name",
+  "out",
+  "prompt",
+  "session",
+  "stream-bytes",
+  "stream-threshold",
+  "tail"
+]);
+function validateKnownFlags(flags) {
+  for (const key of Object.keys(flags)) {
+    if (!KNOWN_BOOLEAN_FLAGS.has(key) && !KNOWN_VALUE_FLAGS.has(key)) {
+      return key;
+    }
+  }
+  return void 0;
+}
 function parseArgs(argv) {
   const positional = [];
   const flags = {};
@@ -16097,6 +17360,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(),
@@ -16147,6 +17414,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()
 });
@@ -16269,6 +17540,7 @@ function recordFromMemorySession(args) {
     agentModels: args.agentModels,
     pendingHistorySync: args.pendingHistorySync,
     parentSessionId: args.parentSessionId,
+    originatingClient: args.originatingClient,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
   };
@@ -16453,6 +17725,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();
@@ -16471,6 +17744,7 @@ var SessionManager = class {
   metaWriteQueues = /* @__PURE__ */ new Map();
   logger;
   npmRegistry;
+  extensionCommands;
   async create(params) {
     const fresh = await this.bootstrapAgent({
       agentId: params.agentId,
@@ -16524,7 +17798,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;
@@ -16595,12 +17871,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) {
@@ -16616,7 +17894,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 ?? {}));
@@ -16634,6 +17915,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,
@@ -16650,11 +17955,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,
@@ -16663,13 +17964,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;
@@ -16688,7 +17991,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({
@@ -16699,6 +18006,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,
@@ -16715,16 +18031,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);
@@ -17073,7 +18389,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) {
@@ -17174,6 +18491,7 @@ var SessionManager = class {
         currentModel: session.currentModel,
         currentUsage: session.currentUsage,
         parentSessionId: session.parentSessionId,
+        originatingClient: session.originatingClient,
         updatedAt: used,
         attachedClients: session.attachedCount,
         status: "live",
@@ -17203,6 +18521,7 @@ var SessionManager = class {
         importedFromMachine: r.importedFromMachine,
         importedFromUpstreamSessionId: r.importedFromUpstreamSessionId,
         parentSessionId: r.parentSessionId,
+        originatingClient: r.originatingClient,
         updatedAt: used,
         attachedClients: 0,
         status: "cold",
@@ -17548,6 +18867,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()
   });
 }
@@ -17576,6 +18896,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) {
@@ -17755,6 +19082,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 [];
@@ -18710,6 +20064,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/daemon/server.ts
 init_paths();
 
@@ -19443,37 +20846,410 @@ function isVisible(event) {
       return true;
   }
 }
-function formatToolLine(state) {
-  const status = state.status;
-  const suffix = status === "completed" || status === void 0 ? "" : ` _(${status})_`;
-  return `${escapeInline(state.title)}${suffix}`;
+function formatToolLine(state) {
+  const status = state.status;
+  const suffix = status === "completed" || status === void 0 ? "" : ` _(${status})_`;
+  return `${escapeInline(state.title)}${suffix}`;
+}
+function statusGlyph(status) {
+  switch (status) {
+    case "completed":
+      return "\u2713";
+    case "failed":
+      return "\u2717";
+    case "cancelled":
+    case "rejected":
+      return "\u2298";
+    case "in_progress":
+      return "\u21BB";
+    default:
+      return "\xB7";
+  }
+}
+function escapeInline(text) {
+  return text.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function formatNumber(n) {
+  return n.toLocaleString("en-US");
+}
+
+// src/daemon/routes/sessions.ts
+init_types();
+init_hydra_version();
+init_remote_url();
+
+// src/core/history-search.ts
+init_render_update();
+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 statusGlyph(status) {
-  switch (status) {
-    case "completed":
-      return "\u2713";
-    case "failed":
-      return "\u2717";
-    case "cancelled":
-    case "rejected":
-      return "\u2298";
-    case "in_progress":
-      return "\u21BB";
-    default:
-      return "\xB7";
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
   }
 }
-function escapeInline(text) {
-  return text.replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function formatNumber(n) {
-  return n.toLocaleString("en-US");
+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
-init_types();
-init_hydra_version();
-init_remote_url();
 function resolveHydraHost(defaults) {
   if (defaults.publicHost && defaults.publicHost.length > 0) {
     return defaults.publicHost;
@@ -19489,6 +21265,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);
@@ -20229,6 +22016,7 @@ import { nanoid as nanoid2 } from "nanoid";
 import * as os5 from "os";
 import * as path13 from "path";
 init_hydra_version();
+import { randomBytes as randomBytes3 } from "crypto";
 function registerAcpWsEndpoint(app, deps) {
   app.get("/acp", { websocket: true }, async (socket, request) => {
     const token = tokenFromUpgradeRequest({
@@ -20266,6 +22054,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") {
@@ -20276,6 +22070,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 ?? {};
@@ -20417,16 +22239,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, {
@@ -20823,7 +22679,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;
@@ -21144,6 +23003,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 resolveSession2;
+    let rejectSession;
+    const sessionReady = new Promise((resolve6, reject) => {
+      resolveSession2 = resolve6;
+      rejectSession = reject;
+    });
+    sessionReady.catch(() => void 0);
+    const entry = { session: void 0, sessionReady };
+    this.byToken.set(token, entry);
+    return {
+      complete: (session) => {
+        entry.session = session;
+        resolveSession2(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((resolve6) => {
+      timer = setTimeout(() => resolve6(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);
@@ -21214,13 +23403,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
@@ -21247,6 +23438,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,
@@ -21254,7 +23458,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();
@@ -21510,14 +23717,14 @@ async function runDaemonStart(flags = {}) {
   }
   if (flagBool(flags, "foreground")) {
     process.title = "hydra-daemon";
-    const handle = await startDaemon(config, serviceToken);
+    const handle2 = await startDaemon(config, serviceToken);
     process.stdout.write(
       `hydra-acp daemon listening on ${config.daemon.host}:${config.daemon.port}
 `
     );
     const shutdown = async () => {
       process.stdout.write("Shutting down...\n");
-      await handle.shutdown();
+      await handle2.shutdown();
       process.exit(0);
     };
     process.on("SIGINT", () => void shutdown());
@@ -21687,6 +23894,7 @@ init_remote_target();
 init_remote_url();
 init_session();
 init_discovery();
+init_hydra_version();
 import * as fs19 from "fs/promises";
 import * as path14 from "path";
 init_session_row();
@@ -21704,10 +23912,13 @@ async function runSessionsList(opts = {}) {
     process.exit(1);
   }
   const body = await response.json();
+  const sessionsAfterCatFilter = opts.includeCat ? body.sessions : body.sessions.filter(
+    (s) => s.originatingClient?.name !== HYDRA_CAT_CLIENT_NAME
+  );
   const host = opts.host ?? "local";
-  const hostFiltered = host === "all" ? body.sessions : host === "local" ? body.sessions.filter(
+  const hostFiltered = host === "all" ? sessionsAfterCatFilter : host === "local" ? sessionsAfterCatFilter.filter(
     (s) => !s.importedFromMachine || !!s.upstreamSessionId
-  ) : body.sessions.filter(
+  ) : sessionsAfterCatFilter.filter(
     (s) => s.importedFromMachine === host && !s.upstreamSessionId
   );
   if (opts.json) {
@@ -23558,6 +25769,9 @@ function isResponse2(msg) {
   return !("method" in msg) && "id" in msg;
 }
 
+// src/shim/proxy.ts
+init_permission_pick();
+
 // src/core/process-title.ts
 init_bin_name();
 import { writeFileSync as writeFileSync3 } from "fs";
@@ -23642,6 +25856,14 @@ function wireShim({
 }) {
   upstream.onMessage((msg) => {
     tracker.observeFromServer(msg);
+    if (opts.dangerouslySkipPermissions === true && isPermissionRequest(msg)) {
+      void upstream.send({
+        jsonrpc: "2.0",
+        id: msg.id,
+        result: buildApproveResponse(msg.params)
+      });
+      return;
+    }
     maybeReplyToResolvedPermission(msg, tracker, downstream);
     void downstream.send(msg);
   });
@@ -23791,6 +26013,9 @@ async function replayAttach(stream, ctx, afterMessageId) {
 function isSessionNewRequest(msg) {
   return "method" in msg && "id" in msg && msg.id !== void 0 && msg.method === "session/new";
 }
+function isPermissionRequest(msg) {
+  return "method" in msg && "id" in msg && msg.id !== void 0 && msg.method === "session/request_permission";
+}
 function buildAttachFromNew(msg, sessionId) {
   return {
     jsonrpc: "2.0",
@@ -23837,6 +26062,10 @@ init_daemon_bootstrap();
 init_render_update();
 init_types();
 init_hydra_version();
+init_permission_pick();
+import { mkdtempSync, rmSync } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join11 } from "path";
 import { WebSocket as WebSocket2 } from "ws";
 
 // src/cli/commands/cat-chunker.ts
@@ -23891,8 +26120,26 @@ function createChunker(opts) {
 }
 
 // src/cli/commands/cat.ts
-var DEFAULT_STREAM_THRESHOLD = 32 * 1024;
-var DEFAULT_STREAM_FILE_CAP = 64 * 1024 * 1024;
+var DEFAULT_STREAM_THRESHOLD = 1 * 1024 * 1024;
+var HYDRA_STDIN_TOOL_PREFIX = "mcp__hydra_stdin__";
+function isHydraStdinPermissionRequest(params) {
+  if (!params || typeof params !== "object") {
+    return false;
+  }
+  const toolCall = params.toolCall;
+  if (!toolCall || typeof toolCall !== "object") {
+    return false;
+  }
+  const title = toolCall.title;
+  if (typeof title === "string" && title.startsWith(HYDRA_STDIN_TOOL_PREFIX)) {
+    return true;
+  }
+  const toolName = toolCall.toolName;
+  if (typeof toolName === "string" && toolName.startsWith(HYDRA_STDIN_TOOL_PREFIX)) {
+    return true;
+  }
+  return false;
+}
 async function runCat(opts) {
   setHydraProcessTitle(buildTitleFromArgv(process.argv.slice(2)));
   if (process.stdin.isTTY && !opts.prompt && !opts.sessionId) {
@@ -23902,6 +26149,18 @@ async function runCat(opts) {
     process.exit(2);
     return;
   }
+  if (!opts.sessionId && opts.cwd === void 0 && process.stdin.isTTY !== true) {
+    const sandbox = mkdtempSync(join11(tmpdir2(), "hydra-cat-"));
+    opts.cwd = sandbox;
+    if (!opts.detach) {
+      process.on("exit", () => {
+        try {
+          rmSync(sandbox, { recursive: true, force: true });
+        } catch {
+        }
+      });
+    }
+  }
   const config = await loadConfig();
   const target = opts.target ?? await resolveLocalTarget(config);
   if (target.isLocal && !opts.target) {
@@ -23925,9 +26184,19 @@ async function runCat(opts) {
 }
 async function runCatLoop(args) {
   const { conn, opts, stdin, stdinIsTty, stdout, stderr } = args;
+  const useAutoStream = !stdinIsTty && opts.sessionId === void 0 && opts.follow !== true;
   conn.setDefaultHandler(async () => {
     return { error: { code: -32601, message: "method not implemented" } };
   });
+  conn.onRequest("session/request_permission", async (params) => {
+    if (opts.dangerouslySkipPermissions) {
+      return buildApproveResponse(params);
+    }
+    if (!isHydraStdinPermissionRequest(params)) {
+      return buildRejectResponse(params);
+    }
+    return buildApproveResponse(params);
+  });
   try {
     await conn.request("initialize", {
       protocolVersion: ACP_PROTOCOL_VERSION,
@@ -23935,11 +26204,11 @@ async function runCatLoop(args) {
         fs: { readTextFile: false, writeTextFile: false },
         terminal: false
       },
-      clientInfo: { name: "hydra-acp-cat", version: HYDRA_VERSION }
+      clientInfo: { name: HYDRA_CAT_CLIENT_NAME, version: HYDRA_VERSION }
     });
   } catch {
   }
-  const sessionId = await openOrAttachSession(conn, opts);
+  const sessionId = await openOrAttachSession(conn, opts, useAutoStream);
   let turnHadOutput = false;
   let lastCharWasNewline = true;
   const writeStdout = (text) => {
@@ -23968,9 +26237,10 @@ async function runCatLoop(args) {
       finalizeTurn();
     }
   });
+  let firstChunkSent = false;
   const sendChunk = async (text) => {
     const promptBlocks = [];
-    if (opts.prompt) {
+    if (opts.prompt && !firstChunkSent) {
       promptBlocks.push({ type: "text", text: opts.prompt });
     }
     if (text.length > 0) {
@@ -23984,6 +26254,7 @@ async function runCatLoop(args) {
         sessionId,
         prompt: promptBlocks
       });
+      firstChunkSent = true;
     } catch (err) {
       stderr(`hydra-acp cat: prompt failed: ${err.message}
 `);
@@ -24042,22 +26313,6 @@ async function runCatLoop(args) {
       }
     }
   };
-  const chunker = createChunker({
-    // setImmediate fires in the libuv "check" phase, after pending
-    // I/O has been polled and any back-to-back "data" events have
-    // been emitted. That makes it the natural hook for "the writer
-    // has paused, time to flush": if more bytes were sitting in the
-    // pipe buffer, Node would have emitted another "data" event
-    // before this fires, and the chunker would detect that and defer.
-    scheduleFlushCheck: (cb) => {
-      const h = setImmediate(cb);
-      return () => clearImmediate(h);
-    },
-    onChunk: (text) => {
-      chunkQueue.push(text);
-      void drainQueue();
-    }
-  });
   if (stdinIsTty && !opts.sessionId) {
     if (opts.prompt) {
       await sendChunk("");
@@ -24065,7 +26320,7 @@ async function runCatLoop(args) {
     await settle(0);
     return done;
   }
-  if (opts.stream && !stdinIsTty) {
+  if (useAutoStream) {
     if (typeof stdin.setEncoding === "function") {
       stdin.setEncoding("utf8");
     }
@@ -24106,15 +26361,49 @@ async function runCatLoop(args) {
   if (typeof stdin.setEncoding === "function") {
     stdin.setEncoding("utf8");
   }
+  const useFollow = opts.follow === true || stdinIsTty && Boolean(opts.sessionId);
+  if (useFollow) {
+    const chunker = createChunker({
+      scheduleFlushCheck: (cb) => {
+        const h = setImmediate(cb);
+        return () => clearImmediate(h);
+      },
+      onChunk: (text) => {
+        chunkQueue.push(text);
+        void drainQueue();
+      }
+    });
+    stdin.on("data", (data) => {
+      chunker.feed(typeof data === "string" ? data : data.toString("utf8"));
+    });
+    stdin.on("end", () => {
+      chunker.eof();
+      stdinEnded = true;
+      if (!draining && chunkQueue.length === 0) {
+        void settle(exitCode);
+      }
+    });
+    stdin.on("error", (err) => {
+      stderr(`hydra-acp cat: stdin error: ${err.message}
+`);
+      exitCode = 1;
+      stdinEnded = true;
+      if (!draining && chunkQueue.length === 0) {
+        void settle(exitCode);
+      }
+    });
+    return done;
+  }
+  let oneShotBuffer = "";
   stdin.on("data", (data) => {
-    chunker.feed(typeof data === "string" ? data : data.toString("utf8"));
+    oneShotBuffer += typeof data === "string" ? data : data.toString("utf8");
   });
   stdin.on("end", () => {
-    chunker.eof();
     stdinEnded = true;
-    if (!draining && chunkQueue.length === 0) {
-      void settle(exitCode);
+    if (oneShotBuffer.length > 0) {
+      chunkQueue.push(oneShotBuffer);
     }
+    void drainQueue();
   });
   stdin.on("error", (err) => {
     stderr(`hydra-acp cat: stdin error: ${err.message}
@@ -24167,12 +26456,11 @@ function runStreamingPath(args) {
     try {
       const openParams = {
         sessionId,
-        mode: "file"
+        mode: "memory"
       };
       if (opts.streamBufferBytes !== void 0) {
         openParams.capacityBytes = opts.streamBufferBytes;
       }
-      openParams.fileCapBytes = opts.streamFileCapBytes ?? DEFAULT_STREAM_FILE_CAP;
       open2 = await conn.request("hydra-acp/stream_open", openParams);
     } catch (err) {
       args.onPromptFailed(
@@ -24180,23 +26468,12 @@ function runStreamingPath(args) {
       );
       return;
     }
-    const filePath = open2.filePath;
-    if (filePath === void 0) {
-      args.onPromptFailed(
-        new Error("daemon did not return a filePath for stream mode")
-      );
-      return;
-    }
     if (headBuffer.length > 0) {
       writeToStream(headBuffer, false);
       headBuffer = Buffer.alloc(0);
     }
     await writeChain.catch(() => void 0);
-    const promptText = buildStreamPromptText(
-      opts.prompt,
-      filePath,
-      opts.streamFileCapBytes ?? DEFAULT_STREAM_FILE_CAP
-    );
+    const promptText = buildStreamPromptText(opts.prompt, open2.capacityBytes);
     const promptDone = conn.request("session/prompt", {
       sessionId,
       prompt: [{ type: "text", text: promptText }]
@@ -24239,22 +26516,35 @@ function runStreamingPath(args) {
   });
   stdin.on("error", args.onError);
 }
-function buildStreamPromptText(standing, filePath, fileCapBytes) {
-  const capHuman = fileCapBytes >= 1024 * 1024 ? `${(fileCapBytes / (1024 * 1024)).toFixed(0)} MB` : `${(fileCapBytes / 1024).toFixed(0)} KB`;
-  const note = `Stdin is being streamed to ${filePath}. The file is being appended to live; use whatever shell tools fit (\`tail -f\`, \`head\`, \`grep\`, \`wc -l\`, etc.). Soft cap ${capHuman} \u2014 if more is written past that, older bytes are dropped.`;
+function buildStreamPromptText(standing, ringCapacityBytes) {
+  const capHuman = ringCapacityBytes >= 1024 * 1024 ? `${(ringCapacityBytes / (1024 * 1024)).toFixed(0)} MB` : `${(ringCapacityBytes / 1024).toFixed(0)} KB`;
+  const toolNote = `The user has piped data into this session. The bytes are NOT in your prompt; they live in the \`hydra_stdin\` MCP server and you read them via its tools:
+- \`stdin_info()\` \u2014 current writeCursor / oldestAvailable / capacity / closed. Cheap; call first to see how much data is there.
+- \`grep_stdin({pattern, regex?, case_insensitive?, context_before?, context_after?, cursor?})\` \u2014 server-side line filter; returns matching lines as decoded strings (not base64). Prefer this for "find lines that mention X" questions on multi-MB inputs.
+- \`head_stdin({bytes})\` \u2014 first N bytes (good for headers / preamble / file signatures).
+- \`tail_stdin({bytes})\` \u2014 most recent N bytes (good for log endings / recent errors).
+- \`read_stdin({cursor, max_bytes, wait_ms})\` \u2014 windowed read at an absolute byte cursor; iterate to sweep the whole stream.
+- \`wait_for_more({cursor, timeout_ms})\` \u2014 block for new bytes past a cursor (only useful for live tails).
+
+Byte payloads (head/tail/read) come back base64-encoded \u2014 decode before reading them as text. \`grep_stdin\` returns plain strings. The ring holds the most recent ~${capHuman}; older bytes are evicted, and the byte tools report the gap when that happens. Per-call cap is 64 KiB for byte tools; loop \`read_stdin\` (advancing the cursor by \`nextCursor\`) when you need more.`;
   if (standing && standing.length > 0) {
-    return `${standing}
+    return `${toolNote}
 
-${note}`;
+Use those tools NOW to answer the user's question \u2014 do not ask whether to check stdin; just check it. Pick the right tool for the question (grep_stdin for finding specific lines, head for preamble / file type, tail for recent events, read_stdin + cursor sweep for whole-stream scans), then answer.
+
+User's question:
+${standing}`;
   }
-  return note;
+  return `${toolNote}
+
+Use those tools to inspect the piped input and report what's there. Start with \`stdin_info()\` to see the size, then \`head_stdin\` and/or \`tail_stdin\` to look at the bytes.`;
 }
-async function openOrAttachSession(conn, opts) {
+async function openOrAttachSession(conn, opts, useAutoStream) {
   if (opts.sessionId) {
     const attached = await conn.request("session/attach", {
       sessionId: opts.sessionId,
       historyPolicy: "pending_only",
-      clientInfo: { name: "hydra-acp-cat", version: HYDRA_VERSION }
+      clientInfo: { name: HYDRA_CAT_CLIENT_NAME, version: HYDRA_VERSION }
     });
     return attached.sessionId;
   }
@@ -24265,6 +26555,9 @@ async function openOrAttachSession(conn, opts) {
   if (opts.model) {
     hydraMeta.model = opts.model;
   }
+  if (useAutoStream) {
+    hydraMeta.mcpStdin = true;
+  }
   const cwd = opts.cwd ?? process.cwd();
   const params = { cwd };
   if (opts.agentId) {
@@ -24296,6 +26589,16 @@ async function openWs2(url, subprotocols) {
 // src/cli.ts
 init_update_check();
 var suppressUpdateNotice = false;
+var dangerousNoticePrinted = false;
+function warnIfDangerouslySkipping(active) {
+  if (!active || dangerousNoticePrinted) {
+    return;
+  }
+  dangerousNoticePrinted = true;
+  process.stderr.write(
+    "hydra-acp: --dangerously-skip-permissions is set \u2014 all tool permission requests will be auto-approved.\n"
+  );
+}
 async function main() {
   const argv = process.argv.slice(2);
   const launchIdx = argv.indexOf("launch");
@@ -24305,6 +26608,7 @@ async function main() {
     const positionalAgentId = afterLaunch[0];
     const agentArgs = afterLaunch.slice(1);
     const { flags: flags2 } = parseArgs(beforeLaunch);
+    rejectUnknownFlags(flags2);
     if (flags2.reattach === true) {
       process.stderr.write(
         "hydra-acp launch: --reattach is not valid here. Pass --session <id-or-url> to attach to a specific session.\n"
@@ -24327,11 +26631,14 @@ async function main() {
     const name2 = resolveOption(flags2, "name");
     const model2 = resolveOption(flags2, "model");
     suppressUpdateNotice = true;
+    const dangerous = flags2["dangerously-skip-permissions"] === true;
+    warnIfDangerouslySkipping(dangerous);
     const shimOpts = {
       agentId,
       agentArgs,
       name: name2,
-      model: model2
+      model: model2,
+      dangerouslySkipPermissions: dangerous
     };
     if (resolved2?.sessionId !== void 0) {
       shimOpts.sessionId = resolved2.sessionId;
@@ -24343,6 +26650,7 @@ async function main() {
     return;
   }
   const { positional, flags } = parseArgs(argv);
+  rejectUnknownFlags(flags);
   if (flags.version === true || positional[0] === "--version") {
     process.stdout.write(`hydra-acp ${readVersion()}
 `);
@@ -24356,6 +26664,8 @@ async function main() {
   const name = resolveOption(flags, "name");
   const agentIdFromFlag = resolveOption(flags, "agent");
   const model = resolveOption(flags, "model");
+  const dangerouslySkipPermissions = flags["dangerously-skip-permissions"] === true;
+  warnIfDangerouslySkipping(dangerouslySkipPermissions);
   const sessionInput = readSessionInput(flags);
   const interactive = subcommand === "tui" || subcommand === void 0 && process.stdout.isTTY;
   const resolved = await resolveSessionFlagOrExit(sessionInput, {
@@ -24377,7 +26687,8 @@ async function main() {
         agentId: agentIdFromFlag,
         name,
         model,
-        target: sessionTarget
+        target: sessionTarget,
+        dangerouslySkipPermissions
       });
       return;
     }
@@ -24385,7 +26696,8 @@ async function main() {
     const shimOpts = {
       name,
       model,
-      agentId: agentIdFromFlag
+      agentId: agentIdFromFlag,
+      dangerouslySkipPermissions
     };
     if (sessionId !== void 0) {
       shimOpts.sessionId = sessionId;
@@ -24402,7 +26714,8 @@ async function main() {
       const shimOpts = {
         name,
         model,
-        agentId: agentIdFromFlag
+        agentId: agentIdFromFlag,
+        dangerouslySkipPermissions
       };
       if (sessionId !== void 0) {
         shimOpts.sessionId = sessionId;
@@ -24425,7 +26738,8 @@ async function main() {
         model,
         agentId: agentIdFromFlag,
         detach: flags.detach === true,
-        stream: flags.stream === true
+        follow: flags.follow === true,
+        dangerouslySkipPermissions
       };
       if (cwd !== void 0) {
         catOpts.cwd = cwd;
@@ -24441,10 +26755,6 @@ async function main() {
       if (streamBufferBytes !== void 0) {
         catOpts.streamBufferBytes = streamBufferBytes;
       }
-      const streamFileCap = parseNumericFlag(flags, "stream-file-cap");
-      if (streamFileCap !== void 0) {
-        catOpts.streamFileCapBytes = streamFileCap;
-      }
       suppressUpdateNotice = true;
       await runCat(catOpts);
       return;
@@ -24488,7 +26798,8 @@ async function main() {
         await runSessionsList({
           all: flags.all === true,
           json: flags.json === true,
-          host: typeof flags.host === "string" ? flags.host : void 0
+          host: typeof flags.host === "string" ? flags.host : void 0,
+          includeCat: flags["include-cat"] === true
         });
         return;
       }
@@ -24670,7 +26981,8 @@ async function main() {
         agentId: agentIdFromFlag,
         name,
         model,
-        target: sessionTarget
+        target: sessionTarget,
+        dangerouslySkipPermissions
       });
       return;
     default:
@@ -24712,6 +27024,9 @@ async function dispatchTui(flags, base) {
   if (base.target !== void 0) {
     tuiOpts.target = base.target;
   }
+  if (base.dangerouslySkipPermissions === true) {
+    tuiOpts.dangerouslySkipPermissions = true;
+  }
   await runTui(tuiOpts);
 }
 function parseNumericFlag(flags, name) {
@@ -24730,6 +27045,17 @@ function parseNumericFlag(flags, name) {
   }
   return void 0;
 }
+function rejectUnknownFlags(flags) {
+  const unknown = validateKnownFlags(flags);
+  if (unknown === void 0) {
+    return;
+  }
+  process.stderr.write(`hydra-acp: unknown flag: --${unknown}
+
+`);
+  printHelp();
+  process.exit(2);
+}
 function readShortPrompt(argv) {
   for (let i = 0; i < argv.length; i += 1) {
     const tok = argv[i];
@@ -24802,15 +27128,17 @@ function printHelp() {
       "  --reattach                         Pick the most-recent session for the current cwd.",
       "  --new                              Force a fresh session.",
       "  --readonly                         Open a session as a transcript viewer (requires --session).",
+      "  --dangerously-skip-permissions     Auto-approve every tool permission request (tui / shim / launch / cat).",
       "  HYDRA_ACP_SESSION                  Env var equivalent of --session (flag wins).",
       "  hydra-acp init [--rotate-token]    Initialize ~/.hydra-acp/config.json",
       "  hydra-acp daemon [status]          Show daemon pid/version (default when no subcommand)",
       "  hydra-acp daemon start [--foreground]   Start daemon (detached by default; --foreground to attach)",
       "  hydra-acp daemon stop|restart",
       "  hydra-acp daemon logs [-f] [-n N]  Tail or follow the daemon log",
-      "  hydra-acp session [list] [--all] [--json] [--host=<host>]",
+      "  hydra-acp session [list] [--all] [--json] [--host=<host>] [--include-cat]",
       "                                     List sessions (live + 20 most-recent cold; --all for everything; --json emits JSON for scripts).",
       "                                     --host filters by origin machine: 'local' (default) shows only sessions created here, 'all' shows everything, or pass a hostname (e.g. machine-b) to show only imports from that peer.",
+      "                                     --include-cat surfaces sessions spawned by `hydra cat` (hidden by default).",
       "  hydra-acp session kill <id>        Demote a live session to cold (keeps the on-disk record)",
       "  hydra-acp session remove <id>      Remove a session entirely (live or cold)",
       "  hydra-acp session export <id> [--out <file>|.]",