@hydra-acp/cli 0.1.47 → 0.1.49

package/dist/cli.js

@@ -1397,7 +1397,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);
@@ -2265,6 +2268,8 @@ var init_session = __esm({
       listSessions;
       logger;
       transformChain;
+      extensionCommands;
+      extensionCommandsUnsub;
       // Outstanding "processing" claims: token → claim waiting for respondsTo discharge.
       pendingClaims = /* @__PURE__ */ new Map();
       agentChangeHandlers = [];
@@ -2360,6 +2365,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 +2387,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 +3554,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 +3602,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 +3773,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 +3807,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 +3862,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 +3938,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 +4112,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", {
@@ -4398,6 +4548,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,
@@ -5598,6 +5752,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",
@@ -7277,7 +7445,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,8 +10150,8 @@ uncaught: ${err.stack ?? err.message}
   }
 });
 
-// src/tui/picker.ts
-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");
@@ -9993,55 +10161,503 @@ 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
   };
-  let cwdOnly = false;
-  let hostFilter = "__local";
-  if (opts.currentSessionId !== void 0) {
-    const current = opts.sessions.find(
-      (s) => s.sessionId === opts.currentSessionId
-    );
-    if (current?.importedFromMachine) {
-      hostFilter = "__all";
+}
+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;
+  }
+  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 };
   }
-  let allSessions = sortSessions(opts.sessions);
-  let visible = filterByHost(allSessions, hostFilter);
-  let rows = visible.map((s) => toRow(s, Date.now()));
-  let widths = computeWidths(rows);
-  let total = 1 + visible.length;
-  let selectedIdx = 0;
-  let scrollOffset = 0;
-  if (opts.currentSessionId !== void 0) {
-    const idx = visible.findIndex((s) => s.sessionId === opts.currentSessionId);
+  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) {
-      selectedIdx = idx + 1;
+      const choice = choices[idx];
+      if (choice) {
+        return { kind: "resolve", action: choice.key };
+      }
     }
   }
-  let searchActive = false;
-  let searchTerm = "";
-  let mode = "normal";
-  let pendingAction = null;
-  let renameBuffer = "";
-  let transientStatus = null;
-  const composer = new InputDispatcher({ history: [] });
-  let termHeight = readTermHeight(term);
-  let termWidth = readTermWidth(term);
-  let viewportSize = 0;
-  let composerTitle = "";
+  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" } };
+}
+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);
+    }
+    base = filterByHost(base, prefs.filters.hostFilter);
+    return base;
+  };
+  let visible = applyPrefsFilters(allSessions);
+  let rows = visible.map((s) => toRow(s, Date.now()));
+  let widths = computeWidths(rows);
+  let total = 1 + visible.length;
+  let selectedIdx = 0;
+  let scrollOffset = 0;
+  if (opts.currentSessionId !== void 0) {
+    const idx = visible.findIndex((s) => s.sessionId === opts.currentSessionId);
+    if (idx >= 0) {
+      selectedIdx = idx + 1;
+    }
+  }
+  let searchActive = false;
+  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 = readTermHeight2(term);
+  let termWidth = readTermWidth2(term);
+  let viewportSize = 0;
+  let composerTitle = "";
   let composerRoom = 0;
   let composerVisualRows = [];
   let composerRows = 1;
@@ -10051,10 +10667,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);
@@ -10087,11 +10709,7 @@ async function pickSession(term, opts) {
     computeLayout();
   };
   const applyFilter = () => {
-    let base = allSessions;
-    if (cwdOnly) {
-      base = base.filter((s) => s.cwd === opts.cwd);
-    }
-    base = filterByHost(base, hostFilter);
+    const base = applyPrefsFilters(allSessions);
     if (searchActive && searchTerm.length > 0) {
       visible = base.filter((s) => matchesSearch(s, searchTerm));
     } else {
@@ -10109,6 +10727,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;
@@ -10177,12 +10808,12 @@ async function pickSession(term, opts) {
     const above = scrollOffset;
     const below = Math.max(0, visible.length - scrollOffset - viewportSize);
     const parts = [];
-    if (cwdOnly) {
+    if (prefs.filters.cwdOnly) {
       parts.push("cwd-only");
     }
-    if (hostFilter !== "__all") {
+    if (prefs.filters.hostFilter !== "__all") {
       parts.push(
-        hostFilter === "__local" ? "host: local" : `host: ${hostFilter}`
+        prefs.filters.hostFilter === "__local" ? "host: local" : `host: ${prefs.filters.hostFilter}`
       );
     }
     if (above > 0) {
@@ -10234,59 +10865,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;
@@ -10435,23 +11377,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) {
@@ -10607,18 +11574,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") {
@@ -10682,6 +11862,10 @@ ${cells}`;
         return;
       }
       clearTransient();
+      if (name === "CTRL_F") {
+        openFindLayer();
+        return;
+      }
       if (selectedIdx === 0 && !searchActive) {
         if (name === "ESCAPE" || name === "CTRL_C" || name === "CTRL_D") {
           cleanup();
@@ -10753,8 +11937,7 @@ ${cells}`;
         return;
       }
       if (!searchActive && data?.isCharacter && name === "?") {
-        mode = "help";
-        renderHelp();
+        openHelpLayer();
         return;
       }
       if (searchActive) {
@@ -10812,29 +11995,20 @@ ${cells}`;
         }
         if (name === "o" || name === "O") {
           const keepId = selectedIdx > 0 ? visible[selectedIdx - 1]?.sessionId : void 0;
-          cwdOnly = !cwdOnly;
+          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;
         }
         if (name === "h" || name === "H") {
           const keepId = selectedIdx > 0 ? visible[selectedIdx - 1]?.sessionId : void 0;
-          hostFilter = nextHostFilter(hostFilter, allSessions);
+          prefs.filters.hostFilter = nextHostFilter(
+            prefs.filters.hostFilter,
+            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;
         }
@@ -10971,6 +12145,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") {
@@ -10979,10 +12159,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;
@@ -10993,10 +12173,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) {
@@ -11051,7 +12231,7 @@ 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";
@@ -11061,9 +12241,11 @@ var init_picker = __esm({
     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 = [
@@ -11076,7 +12258,8 @@ 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)"],
       ["r", "refresh from daemon"],
@@ -11109,103 +12292,13 @@ async function validateLocalCwd(input) {
   }
   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;
-  }
-  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();
   }
 });
 
@@ -11225,7 +12318,7 @@ async function promptForImportCwd(term, session, opts = {}) {
     const contentHeight = 9;
     layout = drawBox(term, {
       contentHeight,
-      title: "Run locally \u2014 choose cwd"
+      title: "Fork locally \u2014 choose cwd"
     });
     const innerW = layout.contentW;
     const headerRows = [
@@ -11237,7 +12330,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++;
@@ -11248,7 +12341,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(
@@ -11284,7 +12377,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"
@@ -11380,7 +12473,7 @@ async function promptForImportCwd(term, session, opts = {}) {
     term.on("resize", onResize);
   });
 }
-function truncate2(s, max) {
+function truncate3(s, max) {
   if (max <= 1) {
     return "";
   }
@@ -11408,223 +12501,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 = 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 r/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: "run-local",
-        label: "Run locally",
-        hotkey: "r",
-        description: "spawn the agent on this machine with a local cwd"
-      },
-      {
-        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";
@@ -12023,41 +12899,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;
@@ -12069,68 +12973,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"
-      });
+      const item = ordered[3] ?? "";
+      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("|")) {
@@ -12487,6 +13404,7 @@ async function runTuiApp(opts) {
   const viewPrefs = {
     showThoughts: config.tui.showThoughts
   };
+  const pickerPrefs = createPickerPrefs();
   let altScreenEngaged = false;
   const enterAltScreen = () => {
     if (altScreenEngaged) {
@@ -12514,7 +13432,15 @@ async function runTuiApp(opts) {
   let nextOpts = opts;
   try {
     while (nextOpts !== null) {
-      nextOpts = await runSession(term, config, target, nextOpts, exitHint, viewPrefs);
+      nextOpts = await runSession(
+        term,
+        config,
+        target,
+        nextOpts,
+        exitHint,
+        viewPrefs,
+        pickerPrefs
+      );
     }
   } finally {
     leaveAltScreen();
@@ -12534,8 +13460,8 @@ async function runTuiApp(opts) {
     );
   }
 }
-async function runSession(term, config, target, opts, exitHint, viewPrefs) {
-  const ctx = await resolveSession(term, config, target, opts);
+async function runSession(term, config, target, opts, exitHint, viewPrefs, pickerPrefs) {
+  const ctx = await resolveSession(term, config, target, opts, pickerPrefs);
   if (!ctx) {
     term.grabInput(false);
     return null;
@@ -13454,7 +14380,8 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
         sessions,
         config,
         target,
-        currentSessionId: resolvedSessionId
+        currentSessionId: resolvedSessionId,
+        prefs: pickerPrefs
       });
       if (choice2.kind === "abort") {
         screen.start({ skipFullscreen: true });
@@ -14147,6 +15074,33 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
     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;
@@ -14288,6 +15242,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
         recordHistoryEntry(event.text);
       }
       closeAgentText();
+      closeThought();
       if (toolsBlockStartedAt !== null) {
         toolsBlockEndedAt = Date.now();
         renderToolsBlock();
@@ -14311,16 +15266,18 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
       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 ?? "",
@@ -14338,12 +15295,14 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
     }
     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) {
@@ -14353,6 +15312,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
     }
     if (event.kind === "tool-call-update") {
       closeAgentText();
+      closeThought();
       recordToolCall(
         event.toolCallId,
         event.title,
@@ -14375,6 +15335,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
     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";
@@ -14469,6 +15430,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
       resolve6({ outcome: { outcome: "cancelled" } });
     }
     closeAgentText();
+    closeThought();
   };
   const markToolsBlockRecoveryFailed = () => {
     if (toolsBlockStartedAt === null) {
@@ -14596,7 +15558,7 @@ connection lost: ${err.message}
   }
   return await sessionDone;
 }
-async function resolveSession(term, config, target, opts) {
+async function resolveSession(term, config, target, opts, pickerPrefs) {
   const cwd = opts.cwd ?? process.cwd();
   if (opts.sessionId) {
     const ctx = {
@@ -14632,7 +15594,8 @@ async function resolveSession(term, config, target, opts) {
       cwd,
       sessions,
       config,
-      target
+      target,
+      prefs: pickerPrefs
     });
     if (choice.kind === "abort") {
       return null;
@@ -14916,6 +15879,9 @@ import { dirname as dirname6, resolve as resolve5 } from "path";
 var KNOWN_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "all",
   "detach",
+  "disabled",
+  "follow",
+  "force",
   "foreground",
   "help",
   "info",
@@ -14928,6 +15894,31 @@ var KNOWN_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "stream",
   "version"
 ]);
+var KNOWN_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "agent",
+  "args",
+  "command",
+  "cwd",
+  "env",
+  "host",
+  "model",
+  "name",
+  "out",
+  "prompt",
+  "session",
+  "stream-bytes",
+  "stream-file-cap",
+  "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 = {};
@@ -16430,6 +17421,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();
@@ -16448,6 +17440,7 @@ var SessionManager = class {
   metaWriteQueues = /* @__PURE__ */ new Map();
   logger;
   npmRegistry;
+  extensionCommands;
   async create(params) {
     const fresh = await this.bootstrapAgent({
       agentId: params.agentId,
@@ -16501,7 +17494,8 @@ var SessionManager = class {
       agentModes: fresh.initialModes,
       agentModels: fresh.initialModels,
       transformChain: params.transformChain,
-      parentSessionId: params.parentSessionId
+      parentSessionId: params.parentSessionId,
+      extensionCommands: this.extensionCommands
     });
     await this.attachManagerHooks(session);
     return session;
@@ -16572,12 +17566,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) {
@@ -16593,7 +17589,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 ?? {}));
@@ -16611,6 +17610,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,
@@ -16627,11 +17650,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,
@@ -16640,13 +17659,14 @@ var SessionManager = class {
       // snapshot — the proxy's available models can change between daemon
       // restarts (quota resets, rollouts), so meta.json is intentionally
       // treated as a cold fallback here, not the authoritative source.
-      agentModels: nonEmptyOrUndefined(extractInitialModels(loadResult ?? {})) ?? params.agentModels,
+      agentModels: advertisedModels,
       // Only gate the first-prompt title heuristic when we actually have
       // a title to preserve. A title-less session (lost to a write race
       // or never seeded) should re-derive from the next prompt rather
       // than stay stuck.
       firstPromptSeeded: !!params.title,
-      createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0
+      createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0,
+      extensionCommands: this.extensionCommands
     });
     await this.attachManagerHooks(session);
     return session;
@@ -16665,7 +17685,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({
@@ -16676,6 +17700,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,
@@ -16692,16 +17725,15 @@ var SessionManager = class {
       listSessions: () => this.list(),
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
-      // Prefer the stored value (set by a previous current_model_update);
-      // fall back to whatever the agent ships in its session/new response.
-      currentModel: params.currentModel ?? fresh.initialModel,
+      currentModel: effectiveModel,
       currentMode: effectiveMode,
       currentUsage: params.currentUsage,
       agentCommands: params.agentCommands,
       agentModes: advertisedModes,
-      agentModels: params.agentModels ?? fresh.initialModels,
+      agentModels: advertisedModels,
       firstPromptSeeded: !!params.title,
-      createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0
+      createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0,
+      extensionCommands: this.extensionCommands
     });
     await this.attachManagerHooks(session);
     void session.seedFromImport().catch(() => void 0);
@@ -17553,6 +18585,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) {
@@ -17732,6 +18771,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 [];
@@ -18687,6 +19753,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();
 
@@ -19451,6 +20566,379 @@ function formatNumber(n) {
 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 safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+function buildSnippet(text, matchIdx, matchLen) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  if (flat.length === 0) {
+    return "";
+  }
+  const flatLower = flat.toLowerCase();
+  const needleSlice = text.slice(matchIdx, matchIdx + matchLen).toLowerCase().replace(/\s+/g, " ").trim();
+  let pos = needleSlice.length > 0 ? flatLower.indexOf(needleSlice) : 0;
+  if (pos === -1) {
+    pos = 0;
+  }
+  const start = Math.max(0, pos - SNIPPET_SIDE);
+  const end = Math.min(flat.length, pos + needleSlice.length + SNIPPET_SIDE);
+  const head = start > 0 ? "\u2026" : "";
+  const tail = end < flat.length ? "\u2026" : "";
+  return `${head}${flat.slice(start, end)}${tail}`;
+}
+
+// src/daemon/routes/sessions.ts
 function resolveHydraHost(defaults) {
   if (defaults.publicHost && defaults.publicHost.length > 0) {
     return defaults.publicHost;
@@ -19466,6 +20954,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);
@@ -20253,6 +21752,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 ?? {};
@@ -20800,7 +22327,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;
@@ -21191,13 +22721,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
@@ -21231,7 +22763,8 @@ async function startDaemon(config, serviceToken) {
     processRegistry,
     onExtensionVersion: (name, version) => extensions.reportVersion(name, version),
     onTransformerVersion: (name, version) => transformers.reportVersion(name, version),
-    transformers
+    transformers,
+    extensionCommands
   });
   await app.listen({ host: config.daemon.host, port: config.daemon.port });
   const address = app.server.address();
@@ -24282,6 +25815,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"
@@ -24320,6 +25854,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()}
 `);
@@ -24707,6 +26242,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];