@hydra-acp/cli 0.1.6 → 0.1.8

package/dist/cli.js

@@ -12,6 +12,19 @@ var __export = (target, all) => {
 // src/core/paths.ts
 import * as path from "path";
 import * as os from "os";
+function shortenHomePath(p) {
+  const home = os.homedir();
+  if (!home) {
+    return p;
+  }
+  if (p === home) {
+    return "~";
+  }
+  if (p.startsWith(home + "/")) {
+    return "~" + p.slice(home.length);
+  }
+  return p;
+}
 function hydraHome() {
   const override = process.env[ROOT_ENV];
   if (override && override.length > 0) {
@@ -32,6 +45,9 @@ var init_paths = __esm({
     paths = {
       home: hydraHome,
       config: () => path.join(hydraHome(), "config.json"),
+      // Auth token lives in its own file so config.json can be version-
+      // controlled without leaking the secret. Raw string contents, mode 0600.
+      authToken: () => path.join(hydraHome(), "auth-token"),
       pidFile: () => path.join(hydraHome(), "daemon.pid"),
       logFile: () => path.join(hydraHome(), "daemon.log"),
       currentLogFile: () => path.join(hydraHome(), "current.log"),
@@ -42,6 +58,18 @@ var init_paths = __esm({
       // machine's binaries cleanly separated. `ls agents/` immediately
       // shows which platforms have ever installed anything.
       agentInstallDir: (id, platformKey, version) => path.join(hydraHome(), "agents", platformKey, id, version),
+      // npm install cache for npx-distributed agents. The trailing
+      // node<ABI> segment keys on process.versions.modules so a Node
+      // major bump (different ABI → native modules incompatible) yields
+      // a fresh install rather than failing at require() time.
+      agentNpmInstallDir: (id, platformKey, version) => path.join(
+        hydraHome(),
+        "agents",
+        platformKey,
+        id,
+        version,
+        `node${process.versions.modules}`
+      ),
       sessionsDir: () => path.join(hydraHome(), "sessions"),
       // One directory per session id under sessions/. Co-locates the
       // session record, its transcript, and any future per-session state
@@ -68,61 +96,98 @@ function extensionList(config) {
     ...body
   }));
 }
-async function loadConfig() {
-  const configPath = paths.config();
+async function readConfigFile() {
   let raw;
   try {
-    raw = await fs.readFile(configPath, "utf8");
+    raw = await fs.readFile(paths.config(), "utf8");
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
-      throw new Error(
-        `No config found at ${configPath}. Run \`hydra-acp init\` to create one.`
-      );
+      return {};
     }
     throw err;
   }
-  const parsed = JSON.parse(raw);
-  return HydraConfig.parse(parsed);
+  return JSON.parse(raw);
 }
-async function ensureConfig() {
+async function loadAuthToken() {
+  let tokenFile;
   try {
-    await fs.access(paths.config());
+    const text = await fs.readFile(paths.authToken(), "utf8");
+    const trimmed = text.trim();
+    if (trimmed.length > 0) {
+      tokenFile = trimmed;
+    }
   } catch (err) {
     const e = err;
     if (e.code !== "ENOENT") {
       throw err;
     }
-    const config = await writeMinimalInitConfig();
-    process.stderr.write(
-      `hydra-acp: initialized ${paths.config()} with a fresh auth token.
-`
+  }
+  const raw = await readConfigFile();
+  const daemon = raw.daemon;
+  const legacy = daemon && typeof daemon.authToken === "string" ? daemon.authToken : void 0;
+  if (tokenFile && legacy) {
+    throw new Error(
+      `Auth token present in both ${paths.authToken()} and ${paths.config()} (daemon.authToken). Remove daemon.authToken from config.json to resolve.`
     );
-    return config;
   }
-  return loadConfig();
+  if (tokenFile) {
+    return tokenFile;
+  }
+  if (legacy) {
+    await migrateLegacyAuthToken(raw, daemon, legacy);
+    return legacy;
+  }
+  return void 0;
 }
-async function writeMinimalInitConfig(authToken) {
-  const token = authToken ?? generateAuthToken();
-  const minimal = { daemon: { authToken: token } };
-  await fs.mkdir(paths.home(), { recursive: true });
-  await fs.writeFile(paths.config(), JSON.stringify(minimal, null, 2) + "\n", {
+async function migrateLegacyAuthToken(raw, daemon, token) {
+  await writeAuthToken(token);
+  delete daemon.authToken;
+  if (Object.keys(daemon).length === 0) {
+    delete raw.daemon;
+  }
+  await fs.writeFile(paths.config(), JSON.stringify(raw, null, 2) + "\n", {
     encoding: "utf8",
     mode: 384
   });
-  return HydraConfig.parse(minimal);
-}
-async function updateConfigField(mutate) {
-  const path7 = paths.config();
-  const text = await fs.readFile(path7, "utf8");
-  const raw = JSON.parse(text);
-  mutate(raw);
-  HydraConfig.parse(raw);
-  await fs.writeFile(path7, JSON.stringify(raw, null, 2) + "\n", {
+  process.stderr.write(
+    `hydra-acp: migrated auth token from ${paths.config()} to ${paths.authToken()}.
+`
+  );
+}
+async function writeAuthToken(token) {
+  await fs.mkdir(paths.home(), { recursive: true });
+  await fs.writeFile(paths.authToken(), token + "\n", {
     encoding: "utf8",
     mode: 384
   });
 }
+async function loadConfig() {
+  const token = await loadAuthToken();
+  if (!token) {
+    throw new Error(
+      `No auth token found at ${paths.authToken()}. Run \`hydra-acp init\` to create one.`
+    );
+  }
+  const raw = await readConfigFile();
+  const daemon = raw.daemon ??= {};
+  daemon.authToken = token;
+  return HydraConfig.parse(raw);
+}
+async function loadConfigReadOnly() {
+  return HydraConfigReadOnly.parse(await readConfigFile());
+}
+async function ensureConfig() {
+  if (!await loadAuthToken()) {
+    const token = generateAuthToken();
+    await writeAuthToken(token);
+    process.stderr.write(
+      `hydra-acp: initialized ${paths.authToken()} with a fresh auth token.
+`
+    );
+  }
+  return loadConfig();
+}
 function generateAuthToken() {
   const bytes = new Uint8Array(32);
   crypto.getRandomValues(bytes);
@@ -144,7 +209,7 @@ function expandHome(p) {
   }
   return p;
 }
-var REGISTRY_URL_DEFAULT, TlsConfig, DaemonConfig, RegistryConfig, TuiConfig, ExtensionName, ExtensionBody, HydraConfig;
+var REGISTRY_URL_DEFAULT, TlsConfig, DaemonConfig, RegistryConfig, TuiConfig, ExtensionName, ExtensionBody, HydraConfig, HydraConfigReadOnly;
 var init_config = __esm({
   "src/core/config.ts"() {
     "use strict";
@@ -160,7 +225,16 @@ var init_config = __esm({
       authToken: z.string().min(16),
       logLevel: z.enum(["debug", "info", "warn", "error"]).default("info"),
       tls: TlsConfig.optional(),
-      sessionIdleTimeoutSeconds: z.number().int().nonnegative().default(3600)
+      sessionIdleTimeoutSeconds: z.number().int().nonnegative().default(3600),
+      // Cap on entries kept in a session's on-disk replay log (history.jsonl).
+      // Compaction trims to this many on a periodic basis; reads also slice
+      // to the tail at this length as a defensive measure against older
+      // daemons that may have written unbounded files.
+      sessionHistoryMaxEntries: z.number().int().positive().default(1e3),
+      // Bytes of trailing agent stderr buffered per AgentInstance so the
+      // daemon can include it in the diagnostic message when a spawn fails.
+      // Bump if your agents emit large tracebacks you want surfaced.
+      agentStderrTailBytes: z.number().int().positive().default(4096)
     });
     RegistryConfig = z.object({
       url: z.string().url().default(REGISTRY_URL_DEFAULT),
@@ -177,7 +251,20 @@ var init_config = __esm({
       // Cap on logical lines retained in the in-memory scrollback render
       // buffer. Oldest lines are dropped on overflow. The on-disk session
       // history is unaffected; this only bounds the TUI's local view buffer.
-      maxScrollbackLines: z.number().int().positive().default(1e4)
+      maxScrollbackLines: z.number().int().positive().default(1e4),
+      // When true (default), the TUI captures mouse events so the wheel can
+      // drive scrollback. The cost: terminals route clicks to the app, so
+      // text selection requires shift+drag to bypass mouse reporting. Set
+      // false to disable capture — wheel scrollback stops working, but
+      // plain click-drag selects text via the terminal emulator.
+      mouse: z.boolean().default(true),
+      // Size at which the TUI's session/update debug log (tui.log) rotates
+      // to tui.log.0 and resets. Bounds on-disk use at ~2x this value.
+      logMaxBytes: z.number().int().positive().default(5 * 1024 * 1024),
+      // Width cap on the cwd column in the `sessions list` output and the
+      // TUI picker. Set higher if you keep deeply-nested working directories
+      // and want them visible; the elastic title column shrinks to make room.
+      cwdColumnMaxWidth: z.number().int().positive().default(24)
     });
     ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
     ExtensionBody = z.object({
@@ -210,7 +297,16 @@ var init_config = __esm({
       // recency and truncated to this count. `--all` overrides in the CLI.
       sessionListColdLimit: z.number().int().nonnegative().default(20),
       extensions: z.record(ExtensionName, ExtensionBody).default({}),
-      tui: TuiConfig.default({ repaintThrottleMs: 1e3, maxScrollbackLines: 1e4 })
+      tui: TuiConfig.default({
+        repaintThrottleMs: 1e3,
+        maxScrollbackLines: 1e4,
+        mouse: true,
+        logMaxBytes: 5 * 1024 * 1024,
+        cwdColumnMaxWidth: 24
+      })
+    });
+    HydraConfigReadOnly = HydraConfig.extend({
+      daemon: DaemonConfig.omit({ authToken: true })
     });
   }
 });
@@ -285,10 +381,11 @@ function extractHydraMeta(meta) {
 function mergeMeta(passthrough, ours) {
   return { ...passthrough ?? {}, [HYDRA_META_KEY]: ours };
 }
-var JsonRpcErrorCodes, InitializeParams, HistoryPolicy, SessionNewParams, SessionResumeHints, SessionAttachParams, HYDRA_META_KEY, SessionDetachParams, SessionListParams, SessionListUsage, SessionListEntry, SessionListResult, SessionPromptParams, SessionCancelParams, ProxyInitializeParams;
+var ACP_PROTOCOL_VERSION, JsonRpcErrorCodes, InitializeParams, HistoryPolicy, SessionNewParams, SessionResumeHints, SessionAttachParams, HYDRA_META_KEY, SessionDetachParams, SessionListParams, SessionListUsage, SessionListEntry, SessionListResult, SessionPromptParams, SessionCancelParams, ProxyInitializeParams;
 var init_types = __esm({
   "src/acp/types.ts"() {
     "use strict";
+    ACP_PROTOCOL_VERSION = 1;
     JsonRpcErrorCodes = {
       ParseError: -32700,
       InvalidRequest: -32600,
@@ -395,7 +492,7 @@ var init_connection = __esm({
   "src/acp/connection.ts"() {
     "use strict";
     init_types();
-    JsonRpcConnection = class {
+    JsonRpcConnection = class _JsonRpcConnection {
       constructor(stream) {
         this.stream = stream;
         this.stream.onMessage((m) => this.handleIncoming(m));
@@ -405,6 +502,16 @@ var init_connection = __esm({
       requestHandlers = /* @__PURE__ */ new Map();
       defaultRequestHandler;
       notificationHandlers = /* @__PURE__ */ new Map();
+      // Notifications received before a handler was registered. Some agents
+      // (e.g. claude-acp) advertise their command list in the same chunk as
+      // the `session/new` response, which is processed before the consumer
+      // can attach its `session/update` handler. Without this buffer those
+      // notifications would be silently dropped, so e.g. `/model` would
+      // never appear in the TUI's slash-completion palette. Capped per
+      // method to keep the buffer from growing unboundedly when nothing
+      // ever subscribes.
+      bufferedNotifications = /* @__PURE__ */ new Map();
+      static MAX_BUFFERED_PER_METHOD = 64;
       pending = /* @__PURE__ */ new Map();
       closed = false;
       closeHandlers = [];
@@ -416,6 +523,17 @@ var init_connection = __esm({
       }
       onNotification(method, handler) {
         this.notificationHandlers.set(method, handler);
+        const queued = this.bufferedNotifications.get(method);
+        if (!queued) {
+          return;
+        }
+        this.bufferedNotifications.delete(method);
+        for (const note of queued) {
+          try {
+            handler(note.params, note.method);
+          } catch {
+          }
+        }
       }
       onClose(handler) {
         this.closeHandlers.push(handler);
@@ -460,6 +578,13 @@ var init_connection = __esm({
         }
         await this.stream.close();
       }
+      // Force-close with an error. Rejects all pending requests and fires
+      // close handlers carrying `err`. Used by transports that detect a
+      // failure (e.g. child process crash, spawn ENOENT) the stream itself
+      // can't surface as a stdout/stdin error.
+      fail(err) {
+        this.handleClose(err);
+      }
       handleIncoming(message) {
         if ("method" in message) {
           if ("id" in message && message.id !== void 0) {
@@ -501,6 +626,16 @@ var init_connection = __esm({
         const handler = this.notificationHandlers.get(note.method);
         if (handler) {
           handler(note.params, note.method);
+          return;
+        }
+        let queued = this.bufferedNotifications.get(note.method);
+        if (!queued) {
+          queued = [];
+          this.bufferedNotifications.set(note.method, queued);
+        }
+        queued.push(note);
+        if (queued.length > _JsonRpcConnection.MAX_BUFFERED_PER_METHOD) {
+          queued.shift();
         }
       }
       handleResponse(res) {
@@ -557,12 +692,12 @@ var init_hydra_commands = __esm({
     HYDRA_COMMANDS = [
       {
         verb: "title",
-        name: "/hydra title",
+        name: "hydra title",
         description: "Regenerate the session title via the agent (or set manually with an arg)"
       },
       {
         verb: "agent",
-        name: "/hydra agent",
+        name: "hydra agent",
         argsHint: "<agent>",
         description: "Swap the agent backing this session, preserving context"
       }
@@ -661,7 +796,7 @@ function firstLine(text, max) {
   }
   return void 0;
 }
-var HYDRA_ID_ALPHABET, generateHydraId, HYDRA_SESSION_PREFIX, MAX_HISTORY_ENTRIES, COMPACT_EVERY, Session, STATE_UPDATE_KINDS;
+var HYDRA_ID_ALPHABET, generateHydraId, HYDRA_SESSION_PREFIX, DEFAULT_HISTORY_MAX_ENTRIES, Session, STATE_UPDATE_KINDS;
 var init_session = __esm({
   "src/core/session.ts"() {
     "use strict";
@@ -670,8 +805,7 @@ var init_session = __esm({
     HYDRA_ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     generateHydraId = customAlphabet(HYDRA_ID_ALPHABET, 16);
     HYDRA_SESSION_PREFIX = "hydra_session_";
-    MAX_HISTORY_ENTRIES = 1e3;
-    COMPACT_EVERY = 200;
+    DEFAULT_HISTORY_MAX_ENTRIES = 1e3;
     Session = class {
       sessionId;
       cwd;
@@ -713,11 +847,13 @@ var init_session = __esm({
       // Bumped by broadcastPromptReceived, cleared by broadcastTurnComplete.
       // Drives the mid-turn elapsed counter delivered to fresh attachers.
       promptStartedAt;
-      // Counts appends since the last compaction. When it hits COMPACT_EVERY
+      // Counts appends since the last compaction. When it hits compactEvery
       // we ask the history store to trim the file to the most recent
-      // MAX_HISTORY_ENTRIES. Keeps file growth bounded without per-append
+      // historyMaxEntries. Keeps file growth bounded without per-append
       // file-size checks.
       appendCount = 0;
+      historyMaxEntries;
+      compactEvery;
       // Permission requests that have been broadcast to one or more
       // clients but have not yet resolved. Replayed to clients that
       // attach mid-flight so a late joiner sees the prompt instead of an
@@ -774,6 +910,8 @@ var init_session = __esm({
           this.firstPromptSeeded = true;
         }
         this.historyStore = init.historyStore;
+        this.historyMaxEntries = init.historyMaxEntries ?? DEFAULT_HISTORY_MAX_ENTRIES;
+        this.compactEvery = Math.max(1, Math.floor(this.historyMaxEntries * 0.2));
         this.updatedAt = Date.now();
         this.createdAt = init.createdAt ?? this.updatedAt;
         this.lastRecordedAt = this.updatedAt;
@@ -1612,9 +1750,9 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
           if (this.historyStore) {
             const store = this.historyStore;
             void store.append(this.sessionId, entry).catch(() => void 0);
-            if (this.appendCount >= COMPACT_EVERY) {
+            if (this.appendCount >= this.compactEvery) {
               this.appendCount = 0;
-              void store.compact(this.sessionId, MAX_HISTORY_ENTRIES).catch(
+              void store.compact(this.sessionId, this.historyMaxEntries).catch(
                 () => void 0
               );
             }
@@ -1731,9 +1869,187 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
   }
 });
 
+// src/core/session-store.ts
+import * as fs5 from "fs/promises";
+import * as path4 from "path";
+import { customAlphabet as customAlphabet2 } from "nanoid";
+import { z as z4 } from "zod";
+function generateLineageId() {
+  return `${HYDRA_LINEAGE_PREFIX}${generateRawId()}`;
+}
+function assertSafeId(id) {
+  if (!SESSION_ID_PATTERN.test(id)) {
+    throw new Error(`unsafe session id: ${id}`);
+  }
+}
+function recordFromMemorySession(args) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    sessionId: args.sessionId,
+    lineageId: args.lineageId,
+    upstreamSessionId: args.upstreamSessionId,
+    importedFromSessionId: args.importedFromSessionId,
+    agentId: args.agentId,
+    cwd: args.cwd,
+    title: args.title,
+    agentArgs: args.agentArgs,
+    currentModel: args.currentModel,
+    currentMode: args.currentMode,
+    currentUsage: args.currentUsage,
+    agentCommands: args.agentCommands,
+    createdAt: args.createdAt ?? now,
+    updatedAt: args.updatedAt ?? now
+  };
+}
+var HYDRA_ID_ALPHABET2, generateRawId, HYDRA_LINEAGE_PREFIX, PersistedAgentCommand, PersistedUsage, SessionRecord, SESSION_ID_PATTERN, SessionStore;
+var init_session_store = __esm({
+  "src/core/session-store.ts"() {
+    "use strict";
+    init_paths();
+    HYDRA_ID_ALPHABET2 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    generateRawId = customAlphabet2(HYDRA_ID_ALPHABET2, 16);
+    HYDRA_LINEAGE_PREFIX = "hydra_lineage_";
+    PersistedAgentCommand = z4.object({
+      name: z4.string(),
+      description: z4.string().optional()
+    });
+    PersistedUsage = z4.object({
+      used: z4.number().optional(),
+      size: z4.number().optional(),
+      costAmount: z4.number().optional(),
+      costCurrency: z4.string().optional()
+    });
+    SessionRecord = z4.object({
+      version: z4.literal(1),
+      sessionId: z4.string(),
+      // Optional for back-compat with records written before this field
+      // existed; mergeForPersistence generates one on next write so any
+      // touched session converges to having a lineageId. A record that
+      // never gets written again (truly cold and untouched) just won't
+      // participate in lineage-based dedup, which is correct — it was
+      // never exported, so no incoming bundle can claim its lineage.
+      lineageId: z4.string().optional(),
+      upstreamSessionId: z4.string(),
+      // When non-empty, marks a session that was created by import and is
+      // waiting for its first attach to bootstrap a fresh upstream agent
+      // and replay the imported history as a takeover transcript. The
+      // origin's local id at export time, kept for debuggability and as a
+      // breadcrumb in `sessions list` (informational, not used for routing).
+      importedFromSessionId: z4.string().optional(),
+      agentId: z4.string(),
+      cwd: z4.string(),
+      title: z4.string().optional(),
+      agentArgs: z4.array(z4.string()).optional(),
+      // Snapshot of "what is currently true about this session" carried in
+      // meta.json so a late-attaching or cold-resurrected client can be
+      // told via the attach response _meta without depending on history
+      // replay of a snapshot-shaped notification.
+      currentModel: z4.string().optional(),
+      currentMode: z4.string().optional(),
+      currentUsage: PersistedUsage.optional(),
+      agentCommands: z4.array(PersistedAgentCommand).optional(),
+      createdAt: z4.string(),
+      updatedAt: z4.string()
+    });
+    SESSION_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+    SessionStore = class {
+      async write(record) {
+        assertSafeId(record.sessionId);
+        await fs5.mkdir(paths.sessionDir(record.sessionId), { recursive: true });
+        const full = { version: 1, ...record };
+        await fs5.writeFile(
+          paths.sessionFile(record.sessionId),
+          JSON.stringify(full, null, 2) + "\n",
+          { encoding: "utf8", mode: 384 }
+        );
+      }
+      async read(sessionId) {
+        if (!SESSION_ID_PATTERN.test(sessionId)) {
+          return void 0;
+        }
+        let raw;
+        try {
+          raw = await fs5.readFile(paths.sessionFile(sessionId), "utf8");
+        } catch (err) {
+          const e = err;
+          if (e.code === "ENOENT") {
+            return void 0;
+          }
+          throw err;
+        }
+        try {
+          return SessionRecord.parse(JSON.parse(raw));
+        } catch {
+          return void 0;
+        }
+      }
+      async delete(sessionId) {
+        if (!SESSION_ID_PATTERN.test(sessionId)) {
+          return;
+        }
+        try {
+          await fs5.unlink(paths.sessionFile(sessionId));
+        } catch (err) {
+          const e = err;
+          if (e.code !== "ENOENT") {
+            throw err;
+          }
+        }
+        try {
+          await fs5.rmdir(paths.sessionDir(sessionId));
+        } catch (err) {
+          const e = err;
+          if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
+            throw err;
+          }
+        }
+      }
+      // Find a persisted session by lineageId. Used by SessionManager.import
+      // to detect bundles that have already been imported (lineageId match)
+      // so we can either error out or, with replace:true, overwrite.
+      // Returns undefined if no record has that lineageId. Records that
+      // pre-date the lineageId field simply don't match — which is
+      // correct: they were never exported, so no incoming bundle can
+      // legitimately claim their lineage.
+      async findByLineageId(lineageId) {
+        if (lineageId.length === 0) {
+          return void 0;
+        }
+        const all = await this.list().catch(() => []);
+        for (const record of all) {
+          if (record.lineageId === lineageId) {
+            return record;
+          }
+        }
+        return void 0;
+      }
+      async list() {
+        let entries;
+        try {
+          entries = await fs5.readdir(paths.sessionsDir());
+        } catch (err) {
+          const e = err;
+          if (e.code === "ENOENT") {
+            return [];
+          }
+          throw err;
+        }
+        const records = [];
+        for (const entry of entries) {
+          const record = await this.read(entry);
+          if (record) {
+            records.push(record);
+          }
+        }
+        return records;
+      }
+    };
+  }
+});
+
 // src/tui/history.ts
 import { promises as fs7 } from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 async function loadHistory(file) {
   let text;
   try {
@@ -1777,7 +2093,7 @@ function appendEntry(history, entry) {
   return out;
 }
 async function saveHistory(file, history) {
-  await fs7.mkdir(path4.dirname(file), { recursive: true });
+  await fs7.mkdir(path5.dirname(file), { recursive: true });
   const lines = history.map((entry) => JSON.stringify(entry));
   await fs7.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
 }
@@ -1789,6 +2105,113 @@ var init_history = __esm({
   }
 });
 
+// src/core/hydra-version.ts
+import { fileURLToPath } from "url";
+import * as path6 from "path";
+import * as fs8 from "fs";
+function resolveVersion() {
+  try {
+    let dir = path6.dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 8; i += 1) {
+      const candidate = path6.join(dir, "package.json");
+      if (fs8.existsSync(candidate)) {
+        const pkg = JSON.parse(fs8.readFileSync(candidate, "utf8"));
+        if (typeof pkg.version === "string" && pkg.version.length > 0 && (typeof pkg.name !== "string" || pkg.name.includes("hydra-acp"))) {
+          return pkg.version;
+        }
+      }
+      const parent = path6.dirname(dir);
+      if (parent === dir) {
+        break;
+      }
+      dir = parent;
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+var HYDRA_VERSION;
+var init_hydra_version = __esm({
+  "src/core/hydra-version.ts"() {
+    "use strict";
+    HYDRA_VERSION = resolveVersion();
+  }
+});
+
+// src/core/bundle.ts
+import { z as z5 } from "zod";
+function encodeBundle(params) {
+  const bundle = {
+    version: 1,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    exportedFrom: {
+      hydraVersion: params.hydraVersion,
+      machine: params.machine
+    },
+    session: {
+      sessionId: params.record.sessionId,
+      lineageId: params.record.lineageId,
+      agentId: params.record.agentId,
+      cwd: params.record.cwd,
+      ...params.record.title !== void 0 ? { title: params.record.title } : {},
+      ...params.record.currentModel !== void 0 ? { currentModel: params.record.currentModel } : {},
+      ...params.record.currentMode !== void 0 ? { currentMode: params.record.currentMode } : {},
+      ...params.record.currentUsage !== void 0 ? { currentUsage: params.record.currentUsage } : {},
+      ...params.record.agentCommands !== void 0 ? { agentCommands: params.record.agentCommands } : {},
+      createdAt: params.record.createdAt,
+      updatedAt: params.record.updatedAt
+    },
+    history: params.history
+  };
+  if (params.promptHistory !== void 0) {
+    bundle.promptHistory = params.promptHistory;
+  }
+  return bundle;
+}
+function decodeBundle(raw) {
+  return Bundle.parse(raw);
+}
+var HistoryEntrySchema, BundleSession, Bundle;
+var init_bundle = __esm({
+  "src/core/bundle.ts"() {
+    "use strict";
+    init_session_store();
+    HistoryEntrySchema = z5.object({
+      method: z5.string(),
+      params: z5.unknown(),
+      recordedAt: z5.number()
+    });
+    BundleSession = z5.object({
+      // The exporter's local id. Regenerated fresh on import (sessionId is
+      // the local namespace; lineageId is what survives across hops).
+      sessionId: z5.string(),
+      // Required on bundles — the export path backfills if the source
+      // record was written before lineageId existed.
+      lineageId: z5.string(),
+      agentId: z5.string(),
+      cwd: z5.string(),
+      title: z5.string().optional(),
+      currentModel: z5.string().optional(),
+      currentMode: z5.string().optional(),
+      currentUsage: PersistedUsage.optional(),
+      agentCommands: z5.array(PersistedAgentCommand).optional(),
+      createdAt: z5.string(),
+      updatedAt: z5.string()
+    });
+    Bundle = z5.object({
+      version: z5.literal(1),
+      exportedAt: z5.string(),
+      exportedFrom: z5.object({
+        hydraVersion: z5.string(),
+        machine: z5.string()
+      }),
+      session: BundleSession,
+      history: z5.array(HistoryEntrySchema),
+      promptHistory: z5.array(z5.string()).optional()
+    });
+  }
+});
+
 // src/acp/ws-stream.ts
 function wsToMessageStream(ws) {
   const messageHandlers = [];
@@ -1867,7 +2290,7 @@ var init_ws_stream = __esm({
 });
 
 // src/core/daemon-bootstrap.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { setTimeout as sleep } from "timers/promises";
 async function ensureDaemonReachable(config) {
   if (await pingHealth(config)) {
@@ -1894,7 +2317,7 @@ function spawnDaemonDetached() {
   if (!cliPath) {
     throw new Error("Cannot determine hydra-acp binary path to spawn daemon");
   }
-  const child = spawn4(
+  const child = spawn5(
     process.execPath,
     [cliPath, "daemon", "start", "--foreground"],
     {
@@ -1942,8 +2365,8 @@ function formatAgentWithModel(agentId, model) {
   }
   return `${agent}${AGENT_MODEL_SEP}${short}`;
 }
-function formatAgentCell(agentId, model, usage) {
-  const base = formatAgentWithModel(agentId, model);
+function formatAgentCell(agentId, usage) {
+  const base = agentId ?? "?";
   if (!usage || typeof usage.costAmount !== "number") {
     return base;
   }
@@ -1980,10 +2403,10 @@ function toRow(s, now = Date.now()) {
     session: stripHydraSessionPrefix(s.sessionId),
     upstream: s.upstreamSessionId ?? "-",
     state: formatState(s.status, s.attachedClients),
-    agent: formatAgentCell(s.agentId, s.currentModel, s.currentUsage),
+    agent: formatAgentCell(s.agentId, s.currentUsage),
     age: formatRelativeAge(s.updatedAt, now),
     title: s.title ?? "-",
-    cwd: s.cwd
+    cwd: shortenHomePath(s.cwd)
   };
 }
 function formatState(status, clients) {
@@ -1999,6 +2422,7 @@ function computeWidths(rows) {
     state: maxLen(HEADER.state, rows.map((r) => r.state)),
     agent: maxLen(HEADER.agent, rows.map((r) => r.agent)),
     age: maxLen(HEADER.age, rows.map((r) => r.age)),
+    cwd: maxLen(HEADER.cwd, rows.map((r) => r.cwd)),
     title: maxLen(HEADER.title, rows.map((r) => r.title))
   };
 }
@@ -2047,7 +2471,7 @@ function maxLen(headerCell, values) {
   }
   return max;
 }
-function formatRow(r, w, maxWidth) {
+function formatRow(r, w, maxWidth, cwdMaxWidth = DEFAULT_CWD_MAX_WIDTH) {
   const fixed = [
     r.session.padEnd(w.session),
     r.upstream.padEnd(w.upstream),
@@ -2056,20 +2480,18 @@ function formatRow(r, w, maxWidth) {
     r.age.padStart(w.age)
   ].join(SEP);
   if (maxWidth === void 0) {
-    return [fixed, r.title.padEnd(w.title), r.cwd].join(SEP);
+    return [fixed, r.cwd.padEnd(w.cwd), r.title].join(SEP);
   }
-  const titleCap = Math.min(w.title, TITLE_MAX_WIDTH);
   const budget = maxWidth - fixed.length - SEP.length;
   if (budget <= 0) {
     return fixed.slice(0, maxWidth);
   }
-  const titleNatural = Math.min(r.title.length, titleCap);
-  let titleAlloc = titleNatural + SEP.length + MIN_CWD <= budget ? titleCap : Math.max(0, budget - SEP.length - MIN_CWD);
-  titleAlloc = Math.min(titleAlloc, Math.max(0, budget - SEP.length - 1));
-  const titleCell = truncateRight(r.title, titleAlloc).padEnd(titleAlloc);
-  const cwdBudget = Math.max(0, budget - titleAlloc - SEP.length);
-  const cwdCell = truncateMiddle(r.cwd, cwdBudget);
-  return [fixed, titleCell, cwdCell].join(SEP);
+  const cwdCap = Math.min(w.cwd, cwdMaxWidth);
+  const cwdAlloc = Math.min(cwdCap, Math.max(0, budget - SEP.length - 1));
+  const cwdCell = truncateMiddle(r.cwd, cwdAlloc).padEnd(cwdAlloc);
+  const titleBudget = Math.max(0, budget - cwdAlloc - SEP.length);
+  const titleCell = truncateRight(r.title, titleBudget);
+  return [fixed, cwdCell, titleCell].join(SEP);
 }
 function truncateRight(s, max) {
   if (max <= 0) {
@@ -2097,11 +2519,12 @@ function truncateMiddle(s, max) {
   const tail = max - 1 - head;
   return s.slice(0, head) + "\u2026" + s.slice(s.length - tail);
 }
-var HEADER, SEP, MIN_CWD, TITLE_MAX_WIDTH;
+var HEADER, SEP, DEFAULT_CWD_MAX_WIDTH;
 var init_session_row = __esm({
   "src/cli/session-row.ts"() {
     "use strict";
     init_agent_display();
+    init_paths();
     init_session();
     HEADER = {
       session: "SESSION",
@@ -2113,14 +2536,13 @@ var init_session_row = __esm({
       cwd: "CWD"
     };
     SEP = "  ";
-    MIN_CWD = 8;
-    TITLE_MAX_WIDTH = 40;
+    DEFAULT_CWD_MAX_WIDTH = 24;
   }
 });
 
 // src/cli/commands/sessions.ts
-import * as fs12 from "fs/promises";
-import * as path6 from "path";
+import * as fs13 from "fs/promises";
+import * as path8 from "path";
 async function runSessionsList(opts = {}) {
   const config = await loadConfig();
   const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
@@ -2159,9 +2581,10 @@ async function runSessionsList(opts = {}) {
   const rows = visible.map((s) => toRow(s, now));
   const widths = computeWidths(rows);
   const maxWidth = process.stdout.isTTY ? process.stdout.columns : void 0;
-  process.stdout.write(formatRow(HEADER, widths, maxWidth) + "\n");
+  const cwdMax = config.tui.cwdColumnMaxWidth;
+  process.stdout.write(formatRow(HEADER, widths, maxWidth, cwdMax) + "\n");
   for (const r of rows) {
-    process.stdout.write(formatRow(r, widths, maxWidth) + "\n");
+    process.stdout.write(formatRow(r, widths, maxWidth, cwdMax) + "\n");
   }
   if (truncated > 0) {
     process.stdout.write(
@@ -2190,9 +2613,9 @@ async function runSessionsKill(id) {
   process.stdout.write(`Killed ${id}
 `);
 }
-async function runSessionsRm(id) {
+async function runSessionsRemove(id) {
   if (!id) {
-    process.stderr.write("Usage: hydra-acp sessions rm <session-id>\n");
+    process.stderr.write("Usage: hydra-acp sessions remove <session-id>\n");
     process.exit(2);
   }
   const config = await loadConfig();
@@ -2239,23 +2662,40 @@ async function runSessionsExport(id, outPath) {
     return;
   }
   const resolved = outPath === "." ? deriveFilenameFrom(response, id) : outPath;
-  await fs12.mkdir(path6.dirname(path6.resolve(resolved)), { recursive: true });
-  await fs12.writeFile(resolved, body, { encoding: "utf8", mode: 384 });
+  await fs13.mkdir(path8.dirname(path8.resolve(resolved)), { recursive: true });
+  await fs13.writeFile(resolved, body, { encoding: "utf8", mode: 384 });
   process.stdout.write(`Wrote ${resolved}
 `);
 }
 async function runSessionsImport(file, opts = {}) {
   if (!file) {
     process.stderr.write(
-      "Usage: hydra-acp sessions import <file>|- [--replace]\n"
+      "Usage: hydra-acp sessions import <file>|- [--replace] [--cwd <path>] [--info]\n"
     );
     process.exit(2);
   }
+  let cwdOverride;
+  if (opts.cwd !== void 0) {
+    const resolved = path8.resolve(opts.cwd);
+    try {
+      const stat4 = await fs13.stat(resolved);
+      if (!stat4.isDirectory()) {
+        process.stderr.write(`--cwd ${resolved} is not a directory
+`);
+        process.exit(1);
+      }
+    } catch {
+      process.stderr.write(`--cwd ${resolved} does not exist
+`);
+      process.exit(1);
+    }
+    cwdOverride = resolved;
+  }
   let body;
   if (file === "-") {
     body = await readStdin();
   } else {
-    body = await fs12.readFile(file, "utf8");
+    body = await fs13.readFile(file, "utf8");
   }
   let bundle;
   try {
@@ -2265,6 +2705,11 @@ async function runSessionsImport(file, opts = {}) {
 `);
     process.exit(1);
   }
+  if (opts.info === true) {
+    const inspectConfig = await loadConfigReadOnly();
+    printBundleInfo(bundle, inspectConfig.tui.cwdColumnMaxWidth);
+    return;
+  }
   const config = await loadConfig();
   const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
   const response = await fetch(`${baseUrl}/v1/sessions/import`, {
@@ -2273,7 +2718,11 @@ async function runSessionsImport(file, opts = {}) {
       "Content-Type": "application/json",
       Authorization: `Bearer ${config.daemon.authToken}`
     },
-    body: JSON.stringify({ bundle, replace: opts.replace === true })
+    body: JSON.stringify({
+      bundle,
+      replace: opts.replace === true,
+      ...cwdOverride !== void 0 ? { cwd: cwdOverride } : {}
+    })
   });
   if (response.status === 409) {
     const detail = await response.json().catch(() => ({}));
@@ -2296,6 +2745,42 @@ async function runSessionsImport(file, opts = {}) {
 `
   );
 }
+function bundleToSummary(parsed) {
+  return {
+    sessionId: parsed.session.sessionId,
+    upstreamSessionId: "-",
+    cwd: parsed.session.cwd,
+    agentId: parsed.session.agentId,
+    currentUsage: parsed.session.currentUsage,
+    title: parsed.session.title,
+    attachedClients: 0,
+    updatedAt: parsed.session.updatedAt,
+    status: "cold"
+  };
+}
+function printBundleInfo(raw, cwdColumnMaxWidth) {
+  let parsed;
+  try {
+    parsed = decodeBundle(raw);
+  } catch (err) {
+    process.stderr.write(`Not a valid bundle: ${err.message}
+`);
+    process.exit(1);
+  }
+  const summary = bundleToSummary(parsed);
+  const row = toRow(summary);
+  const widths = computeWidths([row]);
+  const maxWidth = process.stdout.isTTY ? process.stdout.columns : void 0;
+  process.stdout.write(formatRow(HEADER, widths, maxWidth, cwdColumnMaxWidth) + "\n");
+  process.stdout.write(formatRow(row, widths, maxWidth, cwdColumnMaxWidth) + "\n");
+  process.stdout.write(
+    `
+lineage: ${parsed.session.lineageId}
+exported: ${parsed.exportedAt} from ${parsed.exportedFrom.machine} (hydra ${parsed.exportedFrom.hydraVersion})
+history entries: ${parsed.history.length}` + (parsed.promptHistory ? `, prompt history: ${parsed.promptHistory.length}
+` : "\n")
+  );
+}
 async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -2322,6 +2807,7 @@ var init_sessions = __esm({
   "src/cli/commands/sessions.ts"() {
     "use strict";
     init_config();
+    init_bundle();
     init_session_row();
   }
 });
@@ -2656,12 +3142,15 @@ async function pickSession(term, opts) {
       return b.updatedAt.localeCompare(a.updatedAt);
     });
   };
-  let visible = sortSessions(opts.sessions);
+  let allSessions = sortSessions(opts.sessions);
+  let visible = 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;
+  let searchActive = false;
+  let searchTerm = "";
   let mode = "normal";
   let pendingAction = null;
   let transientStatus = null;
@@ -2672,6 +3161,7 @@ async function pickSession(term, opts) {
   let headerLine = "";
   let sessionLines = [];
   let startRow = 1;
+  const cwdMaxWidth = opts.config.tui.cwdColumnMaxWidth;
   const computeLayout = () => {
     termHeight = readTermHeight(term);
     termWidth = readTermWidth(term);
@@ -2679,8 +3169,8 @@ async function pickSession(term, opts) {
     viewportSize = Math.min(visible.length, maxViewportRows);
     const rowMaxWidth = Math.max(10, termWidth - ROW_PREFIX_WIDTH);
     newSessionLabel = formatNewSessionLabel(opts.cwd, rowMaxWidth);
-    headerLine = formatRow(HEADER, widths, rowMaxWidth);
-    sessionLines = rows.map((r) => formatRow(r, widths, rowMaxWidth));
+    headerLine = formatRow(HEADER, widths, rowMaxWidth, cwdMaxWidth);
+    sessionLines = rows.map((r) => formatRow(r, widths, rowMaxWidth, cwdMaxWidth));
   };
   const rebuildRows = () => {
     rows = visible.map((s) => toRow(s, Date.now()));
@@ -2688,6 +3178,24 @@ async function pickSession(term, opts) {
     total = 1 + visible.length;
     computeLayout();
   };
+  const applyFilter = () => {
+    if (searchActive && searchTerm.length > 0) {
+      visible = allSessions.filter((s) => matchesSearch(s, searchTerm));
+    } else {
+      visible = allSessions;
+    }
+    rebuildRows();
+    if (searchActive) {
+      scrollOffset = 0;
+      selectedIdx = visible.length > 0 ? 1 : 0;
+    } else if (selectedIdx > total - 1) {
+      selectedIdx = Math.max(0, total - 1);
+    }
+    if (scrollOffset + viewportSize > visible.length) {
+      scrollOffset = Math.max(0, visible.length - viewportSize);
+    }
+    adjustScroll();
+  };
   const adjustScroll = () => {
     if (selectedIdx === 0) {
       return;
@@ -2750,6 +3258,13 @@ async function pickSession(term, opts) {
       term.dim.noFormat(`  ${transientStatus}`);
       return;
     }
+    if (searchActive) {
+      term.brightYellow.noFormat(`  /${searchTerm}`);
+      term.bgBrightYellow(" ");
+      const hint = visible.length === 0 ? " no matches" : ` ${visible.length} match${visible.length === 1 ? "" : "es"}`;
+      term.dim.noFormat(`${hint} \xB7 ^c clears`);
+      return;
+    }
     term.dim.noFormat(formatIndicator());
   };
   const indicatorRow = () => startRow + 3 + viewportSize;
@@ -2816,8 +3331,8 @@ async function pickSession(term, opts) {
     const refresh = async (preferredId) => {
       try {
         const next = await listSessions(opts.config);
-        visible = sortSessions(next);
-        rebuildRows();
+        allSessions = sortSessions(next);
+        applyFilter();
         if (preferredId !== void 0) {
           const idx = visible.findIndex((s) => s.sessionId === preferredId);
           if (idx >= 0) {
@@ -2914,7 +3429,37 @@ async function pickSession(term, opts) {
         return;
       }
       clearTransient();
+      if (searchActive) {
+        if (data?.isCharacter) {
+          searchTerm += name;
+          applyFilter();
+          renderFromScratch();
+          return;
+        }
+        if (name === "BACKSPACE") {
+          if (searchTerm.length > 0) {
+            searchTerm = searchTerm.slice(0, -1);
+            applyFilter();
+            renderFromScratch();
+          }
+          return;
+        }
+        if (name === "ESCAPE" || name === "CTRL_C") {
+          searchActive = false;
+          searchTerm = "";
+          applyFilter();
+          renderFromScratch();
+          return;
+        }
+      }
       if (data?.isCharacter) {
+        if (name === "/") {
+          searchActive = true;
+          searchTerm = "";
+          applyFilter();
+          renderFromScratch();
+          return;
+        }
         if (name === "r" || name === "R") {
           const currentId = selectedIdx > 0 ? visible[selectedIdx - 1]?.sessionId : void 0;
           void refresh(currentId);
@@ -3019,13 +3564,34 @@ function readTermWidth(term) {
 function formatNewSessionLabel(cwd, maxWidth) {
   const prefix = "+ New session in ";
   const budget = Math.max(1, maxWidth - prefix.length);
-  return prefix + truncateMiddle(cwd, budget);
+  return prefix + truncateMiddle(shortenHomePath(cwd), budget);
+}
+function matchesSearch(s, term) {
+  if (term.length === 0) {
+    return true;
+  }
+  const t = term.toLowerCase();
+  const haystacks = [
+    stripHydraSessionPrefix(s.sessionId),
+    s.upstreamSessionId ?? "",
+    s.agentId ?? "",
+    s.title ?? "",
+    s.cwd,
+    shortenHomePath(s.cwd)
+  ];
+  for (const h of haystacks) {
+    if (h.toLowerCase().includes(t)) {
+      return true;
+    }
+  }
+  return false;
 }
 var ROW_PREFIX_WIDTH;
 var init_picker = __esm({
   "src/tui/picker.ts"() {
     "use strict";
     init_session_row();
+    init_paths();
     init_session();
     init_discovery();
     ROW_PREFIX_WIDTH = 2;
@@ -3033,14 +3599,14 @@ var init_picker = __esm({
 });
 
 // src/tui/screen.ts
-import os3 from "os";
 import stringWidth from "string-width";
 import wrapAnsi from "wrap-ansi";
-function formattedLineSig(zone, width, line) {
+function formattedLineSig(zone, width, line, highlight2 = null, activeCol = null) {
+  const active = activeCol === null ? "" : `a${activeCol}`;
   if (!line) {
-    return `${zone}|${width}|empty`;
+    return `${zone}|${width}|empty|${highlight2 ?? ""}|${active}`;
   }
-  return `${zone}|${width}|${line.prefix ?? ""}|${line.prefixStyle ?? ""}|${line.body}|${line.bodyStyle ?? ""}|${line.ansi ? "1" : "0"}|${line.fillRow ? "1" : "0"}`;
+  return `${zone}|${width}|${line.prefix ?? ""}|${line.prefixStyle ?? ""}|${line.body}|${line.bodyStyle ?? ""}|${line.ansi ? "1" : "0"}|${line.fillRow ? "1" : "0"}|${highlight2 ?? ""}|${active}`;
 }
 function computePromptVisualRows(buffer, room) {
   const rows = [];
@@ -3052,12 +3618,27 @@ function computePromptVisualRows(buffer, room) {
     }
     let pos = 0;
     while (pos < line.length) {
-      const end = Math.min(line.length, pos + room);
-      rows.push({ bufferIdx: i, startCol: pos, endCol: end });
-      pos = end;
-    }
-  }
-  if (rows.length === 0) {
+      if (line.length - pos <= room) {
+        rows.push({ bufferIdx: i, startCol: pos, endCol: line.length });
+        pos = line.length;
+        break;
+      }
+      let breakAt = -1;
+      for (let j = pos + room - 1; j >= pos; j--) {
+        const c = line[j];
+        if (c === " " || c === "	") {
+          breakAt = j + 1;
+          break;
+        }
+      }
+      if (breakAt === -1) {
+        breakAt = pos + room;
+      }
+      rows.push({ bufferIdx: i, startCol: pos, endCol: breakAt });
+      pos = breakAt;
+    }
+  }
+  if (rows.length === 0) {
     rows.push({ bufferIdx: 0, startCol: 0, endCol: 0 });
   }
   return rows;
@@ -3102,6 +3683,34 @@ function computePromptLayout(visualRows, state, maxRows) {
   }
   return { cursorVisualRow, cursorVisualCol, windowStart, rendered };
 }
+function writeBodyWithHighlight(termObj, text, style, term, activeCol = null, _activeLength = 0) {
+  if (text.length === 0) {
+    return;
+  }
+  if (term.length === 0) {
+    writeStyled(termObj, text, style);
+    return;
+  }
+  const haystack = text.toLowerCase();
+  let i = 0;
+  while (i < text.length) {
+    const next = haystack.indexOf(term, i);
+    if (next === -1) {
+      writeStyled(termObj, text.slice(i), style);
+      return;
+    }
+    if (next > i) {
+      writeStyled(termObj, text.slice(i, next), style);
+    }
+    const isActive = activeCol !== null && next === activeCol;
+    writeStyled(
+      termObj,
+      text.slice(next, next + term.length),
+      isActive ? "search-highlight-active" : "search-highlight"
+    );
+    i = next + term.length;
+  }
+}
 function writeStyled(term, text, style) {
   if (text.length === 0) {
     return;
@@ -3164,6 +3773,12 @@ function writeStyled(term, text, style) {
     case "heading-3":
       term.bold.noFormat(text);
       return;
+    case "search-highlight":
+      term.bgBrightYellow.black.noFormat(text);
+      return;
+    case "search-highlight-active":
+      term.bgRed.brightWhite.noFormat(text);
+      return;
     default:
       term.noFormat(text);
   }
@@ -3177,17 +3792,80 @@ function wrapAnsiBody(text, width) {
   }
   return wrapAnsi(text, width, { hard: true, trim: false }).split("\n");
 }
-function wrap(text, width) {
+function matchTkMarkupAt(text, i) {
+  if (text.charCodeAt(i) !== 94) {
+    return null;
+  }
+  const c = text[i + 1];
+  if (c === void 0) {
+    return null;
+  }
+  if (c === "^") {
+    return { text: "^^", width: 1 };
+  }
+  if (c === "[") {
+    const end = text.indexOf("]", i + 2);
+    if (end !== -1) {
+      return { text: text.slice(i, end + 1), width: 0 };
+    }
+  }
+  if (TK_MARKUP_STYLE_CHAR.test(c)) {
+    return { text: text.slice(i, i + 2), width: 0 };
+  }
+  return null;
+}
+function hasTkMarkup(text) {
+  if (!text.includes("^")) {
+    return false;
+  }
+  for (let i = 0; i < text.length; i++) {
+    if (matchTkMarkupAt(text, i)) {
+      return true;
+    }
+  }
+  return false;
+}
+function* segmentForWidth(text) {
+  let i = 0;
+  while (i < text.length) {
+    const m = matchTkMarkupAt(text, i);
+    if (m) {
+      yield { text: m.text, width: m.width };
+      i += m.text.length;
+      continue;
+    }
+    let runEnd = text.length;
+    let probe = text.indexOf("^", i);
+    while (probe !== -1 && probe < text.length) {
+      if (matchTkMarkupAt(text, probe)) {
+        runEnd = probe;
+        break;
+      }
+      probe = text.indexOf("^", probe + 1);
+    }
+    if (runEnd === i) {
+      yield { text: "^", width: 1 };
+      i += 1;
+      continue;
+    }
+    for (const { segment } of SEGMENTER.segment(text.slice(i, runEnd))) {
+      yield { text: segment, width: stringWidth(segment) };
+    }
+    i = runEnd;
+  }
+}
+function wrap(text, width, opts = {}) {
   if (width <= 0) {
     return [text];
   }
   if (text.length === 0) {
     return [""];
   }
-  if (!NON_ASCII.test(text)) {
+  const stripMarkup = opts.stripMarkup === true && hasTkMarkup(text);
+  if (!stripMarkup && !NON_ASCII.test(text)) {
     return wrapAscii(text, width);
   }
-  return wrapVisible(text, width);
+  return wrapVisible(text, width, stripMarkup);
 }
 function wrapAscii(text, width) {
   const out = [];
@@ -3212,32 +3890,33 @@ function wrapAscii(text, width) {
   out.push(remaining);
   return out;
 }
-function wrapVisible(text, width) {
+function wrapVisible(text, width, stripMarkup) {
   const out = [];
-  const graphemes = [];
-  for (const { segment } of SEGMENTER.segment(text)) {
-    graphemes.push({ seg: segment, w: stringWidth(segment) });
-  }
+  const segments = stripMarkup ? [...segmentForWidth(text)] : graphemeSegments(text);
   let i = 0;
-  while (i < graphemes.length) {
+  while (i < segments.length) {
     let chunk = "";
     let chunkW = 0;
     let lastSpaceI = -1;
     let chunkAtLastSpace = "";
-    while (i < graphemes.length) {
-      const g = graphemes[i];
-      if (chunkW + g.w > width) {
+    while (i < segments.length) {
+      const s = segments[i];
+      if (chunkW + s.width > width) {
+        if (s.text === " " && s.width === 1) {
+          lastSpaceI = i;
+          chunkAtLastSpace = chunk;
+        }
         break;
       }
-      if (g.seg === " ") {
+      if (s.text === " " && s.width === 1) {
         lastSpaceI = i;
         chunkAtLastSpace = chunk;
       }
-      chunk += g.seg;
-      chunkW += g.w;
+      chunk += s.text;
+      chunkW += s.width;
       i += 1;
     }
-    if (i >= graphemes.length) {
+    if (i >= segments.length) {
       out.push(chunk);
       break;
     }
@@ -3245,7 +3924,7 @@ function wrapVisible(text, width) {
       out.push(chunkAtLastSpace);
       i = lastSpaceI + 1;
     } else if (chunk.length === 0) {
-      out.push(graphemes[i].seg);
+      out.push(segments[i].text);
       i += 1;
     } else {
       out.push(chunk);
@@ -3253,34 +3932,43 @@ function wrapVisible(text, width) {
   }
   return out;
 }
-function shortenHomePath(p) {
-  const home = os3.homedir();
-  if (!home) {
-    return p;
-  }
-  if (p === home) {
-    return "~";
-  }
-  if (p.startsWith(home + "/")) {
-    return "~" + p.slice(home.length);
+function graphemeSegments(text) {
+  const out = [];
+  for (const { segment } of SEGMENTER.segment(text)) {
+    out.push({ text: segment, width: stringWidth(segment) });
   }
-  return p;
+  return out;
 }
-function truncate(text, max) {
+function truncate(text, max, opts = {}) {
   if (max <= 0) {
     return "";
   }
-  if (text.length <= max && !NON_ASCII.test(text)) {
+  const stripMarkup = opts.stripMarkup === true && hasTkMarkup(text);
+  if (!stripMarkup && text.length <= max && !NON_ASCII.test(text)) {
     return text;
   }
-  const visible = stringWidth(text);
+  if (!stripMarkup) {
+    const visible2 = stringWidth(text);
+    if (visible2 <= max) {
+      return text;
+    }
+    if (max <= 1) {
+      return takeByWidth(text, max);
+    }
+    return takeByWidth(text, max - 1) + "\u2026";
+  }
+  const segments = [...segmentForWidth(text)];
+  let visible = 0;
+  for (const s of segments) {
+    visible += s.width;
+  }
   if (visible <= max) {
     return text;
   }
   if (max <= 1) {
-    return takeByWidth(text, max);
+    return takeFromSegments(segments, max);
   }
-  return takeByWidth(text, max - 1) + "\u2026";
+  return takeFromSegments(segments, max - 1) + "\u2026";
 }
 function takeByWidth(text, budget) {
   if (budget <= 0) {
@@ -3298,6 +3986,21 @@ function takeByWidth(text, budget) {
   }
   return out;
 }
+function takeFromSegments(segments, budget) {
+  if (budget <= 0) {
+    return "";
+  }
+  let out = "";
+  let used = 0;
+  for (const s of segments) {
+    if (used + s.width > budget) {
+      break;
+    }
+    out += s.text;
+    used += s.width;
+  }
+  return out;
+}
 function firstLine2(text) {
   const idx = text.indexOf("\n");
   return idx === -1 ? text : `${text.slice(0, idx)} \u21B5`;
@@ -3394,6 +4097,10 @@ function mapKeyName(name) {
       return "ctrl-o";
     case "CTRL_P":
       return "ctrl-p";
+    case "CTRL_R":
+      return "ctrl-r";
+    case "CTRL_S":
+      return "ctrl-s";
     case "CTRL_U":
       return "ctrl-u";
     case "CTRL_W":
@@ -3406,11 +4113,12 @@ function mapKeyName(name) {
       return null;
   }
 }
-var HEADER_ROWS, BANNER_ROWS, SEPARATOR_ROWS, MAX_PROMPT_ROWS, MAX_QUEUED_ROWS, MAX_PERMISSION_ROWS, MAX_COMPLETION_ROWS, CONFIRM_PROMPT_ROWS, DEFAULT_CONTENT_REPAINT_THROTTLE_MS, DEFAULT_MAX_SCROLLBACK_LINES, Screen, NON_ASCII, SEGMENTER, shortId;
+var HEADER_ROWS, BANNER_ROWS, SEPARATOR_ROWS, MAX_PROMPT_ROWS, MAX_QUEUED_ROWS, MAX_PERMISSION_ROWS, MAX_COMPLETION_ROWS, CONFIRM_PROMPT_ROWS, DEFAULT_CONTENT_REPAINT_THROTTLE_MS, DEFAULT_MAX_SCROLLBACK_LINES, Screen, NON_ASCII, SEGMENTER, TK_MARKUP_STYLE_CHAR, shortId;
 var init_screen = __esm({
   "src/tui/screen.ts"() {
     "use strict";
     init_agent_display();
+    init_paths();
     init_session();
     HEADER_ROWS = 2;
     BANNER_ROWS = 1;
@@ -3437,6 +4145,7 @@ var init_screen = __esm({
       streamingActive = false;
       lastPromptRows = 0;
       queuedTexts = [];
+      lastQueueEditingIndex = -1;
       repaintPaused = 0;
       repaintPending = false;
       lastRepaintAt = 0;
@@ -3453,6 +4162,12 @@ var init_screen = __esm({
       lineIds = /* @__PURE__ */ new WeakMap();
       wrapCache = /* @__PURE__ */ new Map();
       wrapCacheWidth = 0;
+      // For each wrapped chunk (produced by wrapOne), record the source
+      // line's id and the col offset where this chunk starts in the source
+      // body. Used by the active-match highlight in scrollback search to
+      // map currentMatch (sourceLineId, sourceCol) onto the wrapped chunk
+      // that owns it without scanning the wrap cache.
+      wrapOrigin = /* @__PURE__ */ new WeakMap();
       // Per-row signature of what was painted to each terminal row on the
       // previous repaint. drawX methods funnel through paintRow(), which
       // skips the moveTo+eraseLineAfter+write sequence when the new
@@ -3470,10 +4185,30 @@ var init_screen = __esm({
       // above the bottom. Mouse wheel and PgUp/PgDn adjust this; new content
       // pushes the view down naturally when at 0.
       scrollOffset = 0;
+      // Scrollback search state. While active the prompt area is taken over
+      // by a single-row search input (drawSearchPrompt) and matches in the
+      // visible scrollback are rendered with a background-highlight style.
+      // baselineScroll captures the scrollOffset at the moment the user
+      // engaged search so cancel can restore the view.
+      scrollbackSearch = null;
+      // Lowercased search term used by drawScrollback to drive per-row
+      // highlight rendering. Mirrors scrollbackSearch?.term but cached as a
+      // separate field so the per-row signature can include it cheaply.
+      scrollbackHighlight = null;
+      // Right-side banner slot. Three sources, in priority order:
+      //   1. Active scrollback search term (auto, from this.scrollbackSearch)
+      //   2. External search indicator pushed by the app while prompt-
+      //      history reverse-search is active (gives that mode visible
+      //      feedback for its otherwise-hidden query)
+      //   3. Transient notification set via notify(), auto-cleared after
+      //      durationMs
+      bannerNotification = null;
+      bannerNotificationTimer = null;
+      bannerSearchIndicator = null;
       banner = {
         status: "ready",
         planMode: false,
-        hint: "\u21E7\u21E5 plan \xB7 \u2325\u23CE newline \xB7 \u2303P pick \xB7 \u2303C cancel \xB7 \u2303D quit",
+        hint: "\u21E7\u21E5 plan \xB7 \u2325\u23CE newline \xB7 \u2303P pick \xB7 \u2303C cancel \xB7 \u2303D detach",
         queued: 0
       };
       header = { agent: "?", cwd: "?", sessionId: "?" };
@@ -3493,12 +4228,14 @@ var init_screen = __esm({
       pasteActive = false;
       pasteBuffer = "";
       rawStdinHandler;
+      mouseEnabled;
       constructor(opts) {
         this.term = opts.term;
         this.dispatcher = opts.dispatcher;
         this.onKey = opts.onKey;
         this.contentRepaintThrottleMs = opts.repaintThrottleMs ?? DEFAULT_CONTENT_REPAINT_THROTTLE_MS;
         this.maxScrollbackLines = opts.maxScrollbackLines ?? DEFAULT_MAX_SCROLLBACK_LINES;
+        this.mouseEnabled = opts.mouse ?? true;
         this.resizeHandler = () => this.repaint();
         this.keyHandler = (name, _matches, data) => this.handleKey(name, data);
         this.mouseHandler = (name) => this.handleMouse(name);
@@ -3515,10 +4252,16 @@ var init_screen = __esm({
         this.lastFrameH = 0;
         this.lastWindowTitle = null;
         process.stdout.write("\x1B[?7l");
-        this.term.grabInput({ mouse: "button" });
+        if (this.mouseEnabled) {
+          this.term.grabInput({ mouse: "button" });
+        } else {
+          this.term.grabInput(true);
+        }
         this.term.hideCursor(false);
         this.term.on("key", this.keyHandler);
-        this.term.on("mouse", this.mouseHandler);
+        if (this.mouseEnabled) {
+          this.term.on("mouse", this.mouseHandler);
+        }
         this.term.on("resize", this.resizeHandler);
         this.installBracketedPaste();
         this.repaint();
@@ -3528,9 +4271,15 @@ var init_screen = __esm({
           return;
         }
         this.started = false;
+        if (this.bannerNotificationTimer) {
+          clearTimeout(this.bannerNotificationTimer);
+          this.bannerNotificationTimer = null;
+        }
         this.uninstallBracketedPaste();
         this.term.off("key", this.keyHandler);
-        this.term.off("mouse", this.mouseHandler);
+        if (this.mouseEnabled) {
+          this.term.off("mouse", this.mouseHandler);
+        }
         this.term.off("resize", this.resizeHandler);
         this.term.grabInput(false);
         this.term.hideCursor(false);
@@ -3800,6 +4549,58 @@ var init_screen = __esm({
         this.drawBanner();
         this.placeCursor();
       }
+      // Transient right-side banner message. Cleared automatically after
+      // durationMs (default 4s). Each call resets the timer, so rapid
+      // successive notifications coalesce on the latest text. Active
+      // scrollback / prompt-history search indicators take priority over
+      // notifications, so a notification queued during search is held
+      // behind it and visible once search exits — unless its timer fires
+      // first, in which case it's dropped.
+      notify(text, durationMs = 4e3) {
+        if (this.bannerNotificationTimer) {
+          clearTimeout(this.bannerNotificationTimer);
+        }
+        this.bannerNotification = text;
+        this.bannerNotificationTimer = setTimeout(() => {
+          this.bannerNotification = null;
+          this.bannerNotificationTimer = null;
+          this.drawBanner();
+          this.placeCursor();
+        }, durationMs);
+        this.drawBanner();
+        this.placeCursor();
+      }
+      // Pushed by the app each onKey tick to reflect prompt-history
+      // reverse-search state in the banner — the only place that mode's
+      // query is visible. Pass null when not searching.
+      setBannerSearchIndicator(text) {
+        if (this.bannerSearchIndicator === text) {
+          return;
+        }
+        this.bannerSearchIndicator = text;
+        this.drawBanner();
+        this.placeCursor();
+      }
+      // Computes what (if anything) the right-side banner slot should show
+      // this paint. Priority: scrollback search term > prompt-history
+      // indicator > notification. Scrollback gets a "N/M" counter suffix
+      // since the user can't see which match they're on from the highlight
+      // alone; prompt-history's match is visible in the buffer, so no
+      // counter needed there.
+      bannerRightContent() {
+        if (this.scrollbackSearch !== null) {
+          const sb = this.scrollbackSearch;
+          const counter = sb.matches.length > 0 ? ` ${sb.matchIndex + 1}/${sb.matches.length}` : sb.term.length === 0 ? "" : " 0/0";
+          return { text: `\u{1F50D} ${sb.term}${counter}`, kind: "search" };
+        }
+        if (this.bannerSearchIndicator !== null) {
+          return { text: `\u{1F50D} ${this.bannerSearchIndicator}`, kind: "search" };
+        }
+        if (this.bannerNotification !== null) {
+          return { text: this.bannerNotification, kind: "notify" };
+        }
+        return null;
+      }
       clearScrollback() {
         this.lines = [];
         this.keyedBlocks.clear();
@@ -3880,6 +4681,7 @@ var init_screen = __esm({
       }
       setQueuedPrompts(texts) {
         this.queuedTexts = [...texts];
+        this.lastQueueEditingIndex = this.dispatcher.state().queueIndex;
         this.repaint();
       }
       // While a permission prompt is active, the prompt area is replaced with
@@ -3932,12 +4734,19 @@ var init_screen = __esm({
       // row count changed (alt+enter added a line, backspace joined two), the
       // separator and scrollback bottom shift, so we need a full repaint;
       // otherwise an in-place prompt redraw is enough. (Queued-zone changes
-      // already trigger a full repaint via setQueuedPrompts.)
+      // already trigger a full repaint via setQueuedPrompts.) Queue-edit
+      // navigation may also change which queued row is marked, so check
+      // for that and redraw just that zone in-place.
       refreshPrompt() {
         if (this.promptRows() !== this.lastPromptRows) {
           this.repaint();
           return;
         }
+        const editingIndex = this.dispatcher.state().queueIndex;
+        if (editingIndex !== this.lastQueueEditingIndex) {
+          this.lastQueueEditingIndex = editingIndex;
+          this.drawQueuedZone();
+        }
         this.drawPrompt();
         this.placeCursor();
       }
@@ -3973,6 +4782,9 @@ var init_screen = __esm({
         if (delta === 0) {
           return;
         }
+        if (this.scrollbackSearch !== null) {
+          this.acceptScrollbackSearch();
+        }
         const max = this.maxScrollOffset();
         const next = Math.min(max, Math.max(0, this.scrollOffset + delta));
         if (next === this.scrollOffset) {
@@ -3982,12 +4794,241 @@ var init_screen = __esm({
         this.repaint();
       }
       scrollToBottom() {
+        if (this.scrollbackSearch !== null) {
+          this.acceptScrollbackSearch();
+        }
         if (this.scrollOffset === 0) {
           return;
         }
         this.scrollOffset = 0;
         this.repaint();
       }
+      scrollToTop() {
+        if (this.scrollbackSearch !== null) {
+          this.acceptScrollbackSearch();
+        }
+        const max = this.maxScrollOffset();
+        if (this.scrollOffset === max) {
+          return;
+        }
+        this.scrollOffset = max;
+        this.repaint();
+      }
+      // True iff the user is scrolled above the live tail — gates the
+      // app-level decision of whether ^r engages scrollback search vs.
+      // prompt-history search.
+      isScrolledBack() {
+        return this.scrollOffset > 0;
+      }
+      // True iff a scrollback search is currently active. Used by the app
+      // to decide whether to keep routing keys into search vs. the prompt
+      // dispatcher.
+      isScrollbackSearchActive() {
+        return this.scrollbackSearch !== null;
+      }
+      // Engage scrollback reverse-search. Captures the current scroll
+      // position so cancel can restore it, and seeds an empty search term
+      // (the prompt row renders the search input immediately so the user
+      // sees the entry). Idempotent: no-op when already active.
+      enterScrollbackSearch() {
+        if (this.scrollbackSearch !== null) {
+          return;
+        }
+        this.scrollbackSearch = {
+          term: "",
+          matchIndex: 0,
+          matches: [],
+          baselineScroll: this.scrollOffset
+        };
+        this.scrollbackHighlight = null;
+        this.repaint();
+      }
+      // Update the search term and recompute matches. Walks `lines` from
+      // the tail (newest) toward the head (oldest), pushing every case-
+      // insensitive substring hit. Snaps the viewport to the newest match
+      // when found. Called per keystroke; sub-millisecond on typical
+      // scrollback sizes.
+      updateScrollbackSearchTerm(term) {
+        if (this.scrollbackSearch === null) {
+          return;
+        }
+        const lowered = term.toLowerCase();
+        const matches = [];
+        if (lowered.length > 0) {
+          for (let i = this.lines.length - 1; i >= 0; i--) {
+            const line = this.lines[i];
+            if (!line || line.body.length === 0) {
+              continue;
+            }
+            if (line.ansi) {
+              continue;
+            }
+            const hay = line.body.toLowerCase();
+            const lineCols = [];
+            let pos = 0;
+            while (pos < hay.length) {
+              const found = hay.indexOf(lowered, pos);
+              if (found === -1) {
+                break;
+              }
+              lineCols.push(found);
+              pos = found + lowered.length;
+            }
+            for (let j = lineCols.length - 1; j >= 0; j--) {
+              matches.push({ lineIdx: i, col: lineCols[j] });
+            }
+          }
+        }
+        this.scrollbackSearch.term = term;
+        this.scrollbackSearch.matches = matches;
+        this.scrollbackSearch.matchIndex = 0;
+        this.scrollbackHighlight = lowered.length > 0 ? lowered : null;
+        if (matches.length > 0) {
+          this.scrollToMatch(matches[0]);
+        }
+        this.repaint();
+      }
+      // Advance to the next-older match (called for repeated ^r). Stops at
+      // the oldest match (does not wrap). No-op when there are no matches
+      // or search is inactive.
+      advanceScrollbackSearch() {
+        if (this.scrollbackSearch === null || this.scrollbackSearch.matches.length === 0) {
+          return;
+        }
+        const nextIdx = Math.min(
+          this.scrollbackSearch.matches.length - 1,
+          this.scrollbackSearch.matchIndex + 1
+        );
+        if (nextIdx === this.scrollbackSearch.matchIndex) {
+          return;
+        }
+        this.scrollbackSearch.matchIndex = nextIdx;
+        this.scrollToMatch(this.scrollbackSearch.matches[nextIdx]);
+        this.repaint();
+      }
+      // Retreat to the previous (newer) match — ^s forward-search. Stops
+      // at the newest match (no wrap).
+      retreatScrollbackSearch() {
+        if (this.scrollbackSearch === null || this.scrollbackSearch.matches.length === 0) {
+          return;
+        }
+        if (this.scrollbackSearch.matchIndex === 0) {
+          return;
+        }
+        this.scrollbackSearch.matchIndex -= 1;
+        this.scrollToMatch(this.scrollbackSearch.matches[this.scrollbackSearch.matchIndex]);
+        this.repaint();
+      }
+      // Exit search keeping the viewport at the current match. Highlight is
+      // cleared so subsequent scrollback content reads normally.
+      acceptScrollbackSearch() {
+        if (this.scrollbackSearch === null) {
+          return;
+        }
+        this.scrollbackSearch = null;
+        this.scrollbackHighlight = null;
+        this.repaint();
+      }
+      // Exit search and restore the viewport to where the user was when
+      // they engaged search.
+      cancelScrollbackSearch() {
+        if (this.scrollbackSearch === null) {
+          return;
+        }
+        const baseline = this.scrollbackSearch.baselineScroll;
+        this.scrollbackSearch = null;
+        this.scrollbackHighlight = null;
+        this.scrollOffset = baseline;
+        this.repaint();
+      }
+      scrollbackSearchTerm() {
+        return this.scrollbackSearch?.term ?? "";
+      }
+      // Source-line identity + col + term length for whichever match is
+      // currently selected (advanced via ^r / retreated via ^s). Used by
+      // drawScrollback to give the current match a distinct highlight
+      // style without disturbing the bulk-highlight on the other matches.
+      currentMatchInfo() {
+        if (this.scrollbackSearch === null || this.scrollbackSearch.matches.length === 0) {
+          return null;
+        }
+        const match = this.scrollbackSearch.matches[this.scrollbackSearch.matchIndex];
+        if (!match) {
+          return null;
+        }
+        const sourceLine = this.lines[match.lineIdx];
+        if (!sourceLine) {
+          return null;
+        }
+        const lineId = this.lineIds.get(sourceLine);
+        if (lineId === void 0) {
+          return null;
+        }
+        return {
+          lineId,
+          col: match.col,
+          length: this.scrollbackSearch.term.length
+        };
+      }
+      // If `line` is the wrapped chunk that contains the active match,
+      // returns the col within the chunk's body where the match starts;
+      // otherwise null. The chunk's source identity comes from
+      // this.wrapOrigin which wrapOne populates for every wrapped chunk.
+      activeMatchCol(line, info) {
+        if (!line || info === null) {
+          return null;
+        }
+        const origin = this.wrapOrigin.get(line);
+        if (!origin || origin.sourceLineId !== info.lineId) {
+          return null;
+        }
+        const colInChunk = info.col - origin.sourceColOffset;
+        if (colInChunk < 0 || colInChunk >= line.body.length) {
+          return null;
+        }
+        return colInChunk;
+      }
+      // Position scrollOffset so the wrapped row containing the given
+      // (lineIdx, col) lands on a visible row of the scrollback viewport.
+      // Walks wrapTail to count wrapped rows between the target line and
+      // the tail.
+      scrollToMatch(match) {
+        const w = this.term.width;
+        const visibleRows = this.scrollbackVisibleRows();
+        if (visibleRows <= 0) {
+          return;
+        }
+        let rowsBelowMatchLine = 0;
+        for (let i = this.lines.length - 1; i > match.lineIdx; i--) {
+          const line = this.lines[i];
+          if (!line) {
+            continue;
+          }
+          rowsBelowMatchLine += this.wrapOne(line, w).length;
+        }
+        const matchLine = this.lines[match.lineIdx];
+        let rowsWithinMatchLine = 0;
+        if (matchLine) {
+          const wrapped = this.wrapOne(matchLine, w);
+          let consumed = 0;
+          for (let r = 0; r < wrapped.length; r++) {
+            const piece = wrapped[r];
+            if (!piece) {
+              continue;
+            }
+            const bodyLen = piece.body.length;
+            if (match.col < consumed + bodyLen) {
+              rowsWithinMatchLine = wrapped.length - 1 - r;
+              break;
+            }
+            consumed += bodyLen;
+          }
+        }
+        const target = rowsBelowMatchLine + rowsWithinMatchLine;
+        const desired = Math.max(0, target - Math.floor(visibleRows / 2));
+        const max = this.maxScrollOffset();
+        this.scrollOffset = Math.min(max, desired);
+      }
       scrollPageSize() {
         return Math.max(1, this.scrollbackVisibleRows() - 2);
       }
@@ -4110,8 +5151,8 @@ var init_screen = __esm({
           }
           if (usage) {
             const col = Math.max(1, w - usage.length + 1);
-            this.term.moveTo(col, 1);
-            this.term.dim(usage);
+            this.term.moveTo(col, 1).eraseLineAfter();
+            this.term.dim.noFormat(usage);
           }
         });
       }
@@ -4142,14 +5183,23 @@ var init_screen = __esm({
         const start = Math.max(0, end - visibleRows);
         const slice = wrapped.slice(start, end);
         const padTop = Math.max(0, visibleRows - slice.length);
+        const matchInfo = this.currentMatchInfo();
+        const activeLength = matchInfo?.length ?? 0;
         for (let i = 0; i < visibleRows; i++) {
           const row = top + i;
           const sliceIdx = i - padTop;
           const line = sliceIdx >= 0 ? slice[sliceIdx] : void 0;
-          const sig = formattedLineSig("sb", w, line);
+          const activeCol = this.activeMatchCol(line, matchInfo);
+          const sig = formattedLineSig(
+            "sb",
+            w,
+            line,
+            this.scrollbackHighlight,
+            activeCol
+          );
           this.paintRow(row, sig, () => {
             if (line) {
-              this.writeFormattedLine(line, w);
+              this.writeFormattedLine(line, w, activeCol, activeLength);
             }
           });
         }
@@ -4215,19 +5265,26 @@ var init_screen = __esm({
         const separatorRow = this.term.height - promptRows - BANNER_ROWS;
         const queuedBottom = separatorRow - 1;
         const queuedTop = queuedBottom - rows + 1;
+        const editingIndex = this.dispatcher.state().queueIndex;
         for (let i = 0; i < rows; i++) {
           const row = queuedTop + i;
           const text = this.queuedTexts[i];
           const isLast = i === rows - 1 && this.queuedTexts.length > MAX_QUEUED_ROWS;
           const overflow = this.queuedTexts.length - MAX_QUEUED_ROWS;
           const summary = text === void 0 ? "" : isLast ? `+ ${overflow + 1} more queued` : truncate(firstLine2(text), w - 4);
-          const sig = text === void 0 ? `queued|${w}|empty` : `queued|${w}|${isLast ? "ovf" : "row"}|${summary}`;
+          const editing = !isLast && i === editingIndex;
+          const sig = text === void 0 ? `queued|${w}|empty` : `queued|${w}|${editing ? "edit" : isLast ? "ovf" : "row"}|${summary}`;
           this.paintRow(row, sig, () => {
             if (text === void 0) {
               return;
             }
-            const display = ` \u23F3 ${summary}`;
-            const padded = display + " ".repeat(Math.max(0, w - display.length));
+            const rest = `\u23F3 ${summary}`;
+            const padded = rest + " ".repeat(Math.max(0, w - 1 - rest.length));
+            if (editing) {
+              this.term.bgBlue.brightYellow("\u25B8");
+            } else {
+              this.term.bgBlue(" ");
+            }
             this.term.bgBlue.brightWhite.noFormat(padded);
           });
         }
@@ -4342,7 +5399,9 @@ var init_screen = __esm({
         const row = this.term.height;
         const w = this.term.width;
         const elapsedStr = this.banner.status === "busy" && this.banner.elapsedMs !== void 0 && this.banner.elapsedMs >= 1e3 ? formatElapsed(this.banner.elapsedMs) : "";
-        const sig = `bnr|${w}|${this.banner.status}|${elapsedStr}|${this.banner.queued}|${this.scrollOffset}|${this.banner.planMode ? "1" : "0"}|${this.banner.hint}`;
+        const right = this.bannerRightContent();
+        const rightSig = right ? `${right.kind}|${right.text}` : "";
+        const sig = `bnr|${w}|${this.banner.status}|${elapsedStr}|${this.banner.queued}|${this.scrollOffset}|${this.banner.planMode ? "1" : "0"}|${this.banner.hint}|` + rightSig;
         this.paintRow(row, sig, () => {
           const dot = this.banner.status === "busy" ? "\u25CF" : "\u25CB";
           const planLabel = this.banner.planMode ? "plan: ON " : "plan: off";
@@ -4369,6 +5428,16 @@ var init_screen = __esm({
             this.term.dim(planLabel);
           }
           this.term(" \xB7 ").dim(this.banner.hint);
+          if (right) {
+            const visibleWidth = stringWidth(right.text);
+            const col = Math.max(1, w - visibleWidth + 1);
+            this.term.moveTo(col, row).eraseLineAfter();
+            if (right.kind === "search") {
+              this.term.brightCyan.noFormat(right.text);
+            } else {
+              this.term.brightYellow.noFormat(right.text);
+            }
+          }
         });
       }
       placeCursor() {
@@ -4384,6 +5453,11 @@ var init_screen = __esm({
           this.term.moveTo(2, top2);
           return;
         }
+        if (this.scrollbackSearch) {
+          this.term.hideCursor(true);
+          return;
+        }
+        this.term.hideCursor(false);
         const w = this.term.width;
         const room = Math.max(1, w - 2);
         const state = this.dispatcher.state();
@@ -4470,8 +5544,10 @@ var init_screen = __esm({
         }
         const prefix = line.prefix ?? "";
         const room = Math.max(1, width - prefix.length);
-        const chunks = line.ansi ? wrapAnsiBody(line.body, room) : wrap(line.body, room);
+        const stripMarkup = line.bodyStyle === "agent";
+        const chunks = line.ansi ? wrapAnsiBody(line.body, room) : wrap(line.body, room, { stripMarkup });
         const wrapped = [];
+        let scanPos = 0;
         for (let i = 0; i < chunks.length; i++) {
           const chunk = chunks[i] ?? "";
           const wrappedLine = {
@@ -4490,6 +5566,15 @@ var init_screen = __esm({
           if (line.ansi) {
             wrappedLine.ansi = true;
           }
+          if (id !== void 0 && chunk.length > 0) {
+            const found = line.body.indexOf(chunk, scanPos);
+            const colOffset = found === -1 ? scanPos : found;
+            this.wrapOrigin.set(wrappedLine, {
+              sourceLineId: id,
+              sourceColOffset: colOffset
+            });
+            scanPos = colOffset + chunk.length;
+          }
           wrapped.push(wrappedLine);
         }
         if (id !== void 0) {
@@ -4497,13 +5582,25 @@ var init_screen = __esm({
         }
         return wrapped;
       }
-      writeFormattedLine(line, width) {
+      writeFormattedLine(line, width, activeMatchCol = null, activeMatchLength = 0) {
         if (line.prefix) {
           writeStyled(this.term, line.prefix, line.prefixStyle ?? line.bodyStyle);
         }
         const remaining = Math.max(0, width - (line.prefix?.length ?? 0));
-        const bodyText = line.ansi ? line.body : truncate(line.body, remaining);
-        writeStyled(this.term, bodyText, line.bodyStyle);
+        const stripMarkup = line.bodyStyle === "agent";
+        const bodyText = line.ansi ? line.body : truncate(line.body, remaining, { stripMarkup });
+        if (this.scrollbackHighlight !== null && !line.ansi) {
+          writeBodyWithHighlight(
+            this.term,
+            bodyText,
+            line.bodyStyle,
+            this.scrollbackHighlight,
+            activeMatchCol,
+            activeMatchLength
+          );
+        } else {
+          writeStyled(this.term, bodyText, line.bodyStyle);
+        }
         if (line.fillRow) {
           const visible = line.ansi ? stringWidth(bodyText) : bodyText.length;
           const pad = remaining - visible;
@@ -4518,6 +5615,7 @@ var init_screen = __esm({
     };
     NON_ASCII = /[^\x20-\x7e]/;
     SEGMENTER = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+    TK_MARKUP_STYLE_CHAR = /[a-zA-Z+\-:_!#/]/;
     shortId = stripHydraSessionPrefix;
   }
 });
@@ -4533,8 +5631,25 @@ var init_input = __esm({
       col = 0;
       planMode = false;
       historyIndex = -1;
+      // Queue editing: when the user walks Up past row 0 with queued prompts
+      // present, the most-recently-queued item lands in the buffer and
+      // queueIndex tracks which slot of `queue` is being edited. Enter submits
+      // the edit (queue-edit) or, on an empty buffer, drops the slot
+      // (queue-remove). -1 means not editing a queue slot.
+      queueIndex = -1;
       savedDraft = null;
       history = [];
+      // Active reverse-incremental search over `history`. Set when ^r is
+      // pressed; cleared when the user accepts (Enter / typing / arrows)
+      // or cancels (ESC). `query` is the lowercased substring matched
+      // against history entries; `matchIndices` are history indices in
+      // newest→oldest order; `cursor` is the current index into that list.
+      // `savedDraft` snapshots the buffer/cursor at the moment search
+      // began so ESC can restore it.
+      historySearch = null;
+      // Waiting queue snapshot (excludes the in-flight head). Newest item lives
+      // at the end so Up walks the array right-to-left.
+      queue = [];
       turnRunning = false;
       // Single-slot kill ring. The most recent killed text (^U, ^K, ^W) lands
       // here so ^Y can yank it back. Standard readline keeps a stack; we
@@ -4550,7 +5665,9 @@ var init_input = __esm({
           row: this.row,
           col: this.col,
           planMode: this.planMode,
-          historyIndex: this.historyIndex
+          historyIndex: this.historyIndex,
+          queueIndex: this.queueIndex,
+          historySearchQuery: this.historySearch?.query ?? null
         };
       }
       setTurnRunning(running) {
@@ -4560,6 +5677,17 @@ var init_input = __esm({
         this.history = [...history];
         this.historyIndex = -1;
         this.savedDraft = null;
+        this.historySearch = null;
+      }
+      // Snapshot of the waiting queue (head excluded). Called by the app after
+      // every queue mutation so Up/Down can walk a fresh view. queueIndex is
+      // only invalidated when it falls outside the new bounds — staying in
+      // bounds preserves the user's edit if the queue grew or stayed put.
+      setQueue(queue) {
+        this.queue = [...queue];
+        if (this.queueIndex >= this.queue.length) {
+          this.queueIndex = -1;
+        }
       }
       // Replace the contents of the first row, leaving subsequent rows alone.
       // Used by slash-command completion: the partial /foo gets swapped for the
@@ -4570,7 +5698,52 @@ var init_input = __esm({
           this.col = text.length;
         }
       }
+      // Public seed for the buffer (used for Escape pre-fill). Treated like a
+      // fresh draft: nav state and any saved draft are cleared, cursor lands
+      // at the end so the user can edit immediately.
+      setBuffer(text) {
+        this.loadEntry(text);
+        this.historyIndex = -1;
+        this.queueIndex = -1;
+        this.savedDraft = null;
+        this.historySearch = null;
+      }
       feed(event) {
+        if (this.historySearch !== null) {
+          if (event.type === "char") {
+            return this.mutateHistorySearchQuery(
+              this.historySearch.query + event.ch.toLowerCase()
+            );
+          }
+          if (event.type === "paste") {
+            return this.mutateHistorySearchQuery(
+              this.historySearch.query + event.text.replace(/\n/g, " ").toLowerCase()
+            );
+          }
+          if (event.type === "key") {
+            if (event.name === "ctrl-r") {
+              return this.advanceHistorySearch();
+            }
+            if (event.name === "ctrl-s") {
+              this.retreatHistorySearch();
+              return [];
+            }
+            if (event.name === "escape") {
+              this.cancelHistorySearch();
+              return [];
+            }
+            if (event.name === "backspace") {
+              if (this.historySearch.query.length === 0) {
+                this.cancelHistorySearch();
+                return [];
+              }
+              return this.mutateHistorySearchQuery(
+                this.historySearch.query.slice(0, -1)
+              );
+            }
+            this.historySearch = null;
+          }
+        }
         if (event.type === "char") {
           this.insertChar(event.ch);
           return [];
@@ -4607,14 +5780,16 @@ var init_input = __esm({
           case "right":
             this.moveRight();
             return [];
-          case "home":
           case "ctrl-a":
             this.col = 0;
             return [];
-          case "end":
           case "ctrl-e":
             this.col = this.currentLine().length;
             return [];
+          case "home":
+            return this.handleHome();
+          case "end":
+            return this.handleEnd();
           case "ctrl-b":
             this.moveLeft();
             return [];
@@ -4637,11 +5812,19 @@ var init_input = __esm({
           case "ctrl-c":
             return this.handleCtrlC();
           case "ctrl-d":
-            return this.bufferIsEmpty() ? [{ type: "exit" }] : [];
+            if (this.bufferIsEmpty()) {
+              return [{ type: "exit" }];
+            }
+            this.deleteForward();
+            return [];
           case "ctrl-l":
             return [{ type: "redraw" }];
           case "ctrl-p":
             return [{ type: "switch-session" }];
+          case "ctrl-r":
+            return this.startHistorySearch();
+          case "ctrl-s":
+            return [];
           case "ctrl-u":
             this.killLine();
             return [];
@@ -4652,6 +5835,9 @@ var init_input = __esm({
             this.yank();
             return [];
           case "escape":
+            if (this.turnRunning) {
+              return [{ type: "cancel", prefill: true }];
+            }
             return [];
         }
       }
@@ -4672,7 +5858,9 @@ var init_input = __esm({
         this.row = 0;
         this.col = 0;
         this.historyIndex = -1;
+        this.queueIndex = -1;
         this.savedDraft = null;
+        this.historySearch = null;
       }
       insertChar(ch) {
         if (ch.length === 0) {
@@ -4805,50 +5993,92 @@ var init_input = __esm({
           this.col = 0;
         }
       }
-      // Up scrolls back through history when the cursor is on the first line of
-      // the buffer; otherwise it just moves the cursor up one line.
+      // Up walks the navigation stack from newest to oldest: pending queue
+      // items first (so the user can edit something they just enqueued),
+      // then prompt history. Cursor movement within a multi-line buffer
+      // takes priority when not already navigating.
       handleUp() {
         if (this.row > 0) {
           this.row -= 1;
           this.col = Math.min(this.col, this.currentLine().length);
           return [];
         }
-        if (this.history.length === 0) {
-          return [];
-        }
-        if (this.historyIndex === -1) {
+        if (this.queueIndex === -1 && this.historyIndex === -1) {
+          if (this.queue.length === 0 && this.history.length === 0) {
+            return [];
+          }
           this.savedDraft = {
             buffer: [...this.buffer],
             row: this.row,
             col: this.col
           };
+          if (this.queue.length > 0) {
+            this.queueIndex = this.queue.length - 1;
+            this.loadEntry(this.queue[this.queueIndex] ?? "");
+          } else {
+            this.historyIndex = this.history.length - 1;
+            this.loadEntry(this.history[this.historyIndex] ?? "");
+          }
+          return [];
+        }
+        if (this.queueIndex >= 0) {
+          if (this.queueIndex > 0) {
+            this.queueIndex -= 1;
+            this.loadEntry(this.queue[this.queueIndex] ?? "");
+            return [];
+          }
+          if (this.history.length === 0) {
+            return [];
+          }
+          this.queueIndex = -1;
           this.historyIndex = this.history.length - 1;
-        } else if (this.historyIndex > 0) {
-          this.historyIndex -= 1;
-        } else {
+          this.loadEntry(this.history[this.historyIndex] ?? "");
           return [];
         }
-        this.loadHistoryEntry(this.historyIndex);
+        if (this.historyIndex > 0) {
+          this.historyIndex -= 1;
+          this.loadEntry(this.history[this.historyIndex] ?? "");
+        }
         return [];
       }
-      // Down advances within history; when we walk off the end, restore the
-      // saved draft. When already on a multi-line buffer's middle row, just
-      // moves the cursor down.
+      // Down reverses the Up walk: history (older → newer), then queue
+      // (oldest → newest), then restore the original draft. Within a
+      // multi-line buffer, plain cursor movement still wins when no
+      // navigation is in progress.
       handleDown() {
-        if (this.row < this.buffer.length - 1 && this.historyIndex === -1) {
+        if (this.row < this.buffer.length - 1 && this.historyIndex === -1 && this.queueIndex === -1) {
           this.row += 1;
           this.col = Math.min(this.col, this.currentLine().length);
           return [];
         }
-        if (this.historyIndex === -1) {
+        if (this.historyIndex >= 0) {
+          if (this.historyIndex < this.history.length - 1) {
+            this.historyIndex += 1;
+            this.loadEntry(this.history[this.historyIndex] ?? "");
+            return [];
+          }
+          this.historyIndex = -1;
+          if (this.queue.length > 0) {
+            this.queueIndex = 0;
+            this.loadEntry(this.queue[this.queueIndex] ?? "");
+            return [];
+          }
+          this.restoreDraft();
           return [];
         }
-        if (this.historyIndex < this.history.length - 1) {
-          this.historyIndex += 1;
-          this.loadHistoryEntry(this.historyIndex);
+        if (this.queueIndex >= 0) {
+          if (this.queueIndex < this.queue.length - 1) {
+            this.queueIndex += 1;
+            this.loadEntry(this.queue[this.queueIndex] ?? "");
+            return [];
+          }
+          this.queueIndex = -1;
+          this.restoreDraft();
           return [];
         }
-        this.historyIndex = -1;
+        return [];
+      }
+      restoreDraft() {
         if (this.savedDraft) {
           this.buffer = [...this.savedDraft.buffer];
           this.row = this.savedDraft.row;
@@ -4857,11 +6087,146 @@ var init_input = __esm({
         } else {
           this.clearBuffer();
         }
+      }
+      // Engage reverse-incremental search over prompt history. Uses the
+      // current buffer text as the search query. With an empty buffer we
+      // enter search mode in an "empty query, no match shown" state — the
+      // banner indicator lights up, and as the user types we extend the
+      // query and load top matches. We deliberately do NOT auto-load the
+      // most recent entry on an empty ^R (that's a surprise — Up-arrow
+      // already walks history if that's what they wanted). With a
+      // non-empty query that has no history match, escalate straight to
+      // scrollback search so the typed term searches session output.
+      startHistorySearch() {
+        const query = this.bufferText().toLowerCase();
+        if (query.length === 0) {
+          this.historySearch = {
+            query: "",
+            matchIndices: [],
+            cursor: 0,
+            savedDraft: {
+              buffer: [...this.buffer],
+              row: this.row,
+              col: this.col
+            }
+          };
+          return [];
+        }
+        const matchIndices = this.findHistoryMatches(query);
+        if (matchIndices.length === 0) {
+          return [{ type: "escalate-search", query }];
+        }
+        this.historySearch = {
+          query,
+          matchIndices,
+          cursor: 0,
+          savedDraft: {
+            buffer: [...this.buffer],
+            row: this.row,
+            col: this.col
+          }
+        };
+        this.loadEntry(this.history[matchIndices[0]] ?? "");
+        return [];
+      }
+      // ^R advance. At the oldest match with a non-empty query, falls
+      // through to scrollback search (same escalate path as a never-
+      // matched startHistorySearch). With an empty query at the oldest
+      // match (i.e. the user walked all history with no filter), advance
+      // is a no-op so the buffer stays on the oldest entry.
+      advanceHistorySearch() {
+        if (this.historySearch === null) {
+          return [];
+        }
+        const search = this.historySearch;
+        const atOldest = search.cursor >= search.matchIndices.length - 1;
+        if (atOldest) {
+          if (search.query.length === 0) {
+            return [];
+          }
+          const query = search.query;
+          const draft = search.savedDraft;
+          this.historySearch = null;
+          this.buffer = [...draft.buffer];
+          this.row = draft.row;
+          this.col = draft.col;
+          return [{ type: "escalate-search", query }];
+        }
+        search.cursor += 1;
+        const idx = search.matchIndices[search.cursor];
+        this.loadEntry(this.history[idx] ?? "");
         return [];
       }
-      loadHistoryEntry(index) {
-        const entry = this.history[index] ?? "";
-        this.buffer = entry.split("\n");
+      // ^S retreat — walk toward newer matches. No-op at the newest match
+      // (no wrap, mirroring ^R no-wrap at the oldest).
+      retreatHistorySearch() {
+        if (this.historySearch === null) {
+          return;
+        }
+        if (this.historySearch.cursor === 0) {
+          return;
+        }
+        this.historySearch.cursor -= 1;
+        const idx = this.historySearch.matchIndices[this.historySearch.cursor];
+        this.loadEntry(this.history[idx] ?? "");
+      }
+      // Backspace / typing within search mode mutates the query and
+      // re-searches. When the new query is empty, restore the saved
+      // draft buffer (typically empty) and stay in search mode — the
+      // user can keep typing. When the new query has matches, load the
+      // top one. When the new query has no matches, escalate to scrollback
+      // search so the typed term applies there instead.
+      mutateHistorySearchQuery(newQuery) {
+        if (this.historySearch === null) {
+          return [];
+        }
+        if (newQuery.length === 0) {
+          this.historySearch.query = "";
+          this.historySearch.matchIndices = [];
+          this.historySearch.cursor = 0;
+          const draft = this.historySearch.savedDraft;
+          this.buffer = [...draft.buffer];
+          this.row = draft.row;
+          this.col = draft.col;
+          return [];
+        }
+        const matchIndices = this.findHistoryMatches(newQuery);
+        if (matchIndices.length === 0) {
+          const draft = this.historySearch.savedDraft;
+          this.historySearch = null;
+          this.buffer = [...draft.buffer];
+          this.row = draft.row;
+          this.col = draft.col;
+          return [{ type: "escalate-search", query: newQuery }];
+        }
+        this.historySearch.query = newQuery;
+        this.historySearch.matchIndices = matchIndices;
+        this.historySearch.cursor = 0;
+        this.loadEntry(this.history[matchIndices[0]] ?? "");
+        return [];
+      }
+      findHistoryMatches(query) {
+        const out = [];
+        for (let i = this.history.length - 1; i >= 0; i--) {
+          const entry = this.history[i] ?? "";
+          if (query.length === 0 || entry.toLowerCase().includes(query)) {
+            out.push(i);
+          }
+        }
+        return out;
+      }
+      cancelHistorySearch() {
+        if (this.historySearch === null) {
+          return;
+        }
+        const draft = this.historySearch.savedDraft;
+        this.historySearch = null;
+        this.buffer = [...draft.buffer];
+        this.row = draft.row;
+        this.col = draft.col;
+      }
+      loadEntry(text) {
+        this.buffer = text.split("\n");
         if (this.buffer.length === 0) {
           this.buffer = [""];
         }
@@ -4870,6 +6235,14 @@ var init_input = __esm({
       }
       send() {
         const text = this.bufferText();
+        if (this.queueIndex >= 0 && this.queueIndex < this.queue.length) {
+          const index = this.queueIndex;
+          this.clearBuffer();
+          if (text.trim().length === 0) {
+            return [{ type: "queue-remove", index }];
+          }
+          return [{ type: "queue-edit", index, text }];
+        }
         if (text.trim().length === 0) {
           return [];
         }
@@ -4877,25 +6250,105 @@ var init_input = __esm({
         this.clearBuffer();
         return [{ type: "send", text, planMode }];
       }
-      handleCtrlC() {
-        if (this.turnRunning) {
-          return [{ type: "cancel" }];
+      // Home: jump to the very start of the prompt buffer. If we're already
+      // there, fall through to scrolling the scrollback to its top.
+      handleHome() {
+        if (this.row !== 0 || this.col !== 0) {
+          this.row = 0;
+          this.col = 0;
+          return [];
+        }
+        return [{ type: "scroll-to-top" }];
+      }
+      // End: jump to the end of the last line of the prompt buffer. Already
+      // there → scroll the scrollback to the bottom (newest).
+      handleEnd() {
+        const lastRow = this.buffer.length - 1;
+        const lastCol = (this.buffer[lastRow] ?? "").length;
+        if (this.row !== lastRow || this.col !== lastCol) {
+          this.row = lastRow;
+          this.col = lastCol;
+          return [];
         }
+        return [{ type: "scroll-to-bottom" }];
+      }
+      handleCtrlC() {
         if (!this.bufferIsEmpty()) {
-          this.clearBuffer();
+          this.buffer = [""];
+          this.row = 0;
+          this.col = 0;
+          if (this.queueIndex === -1) {
+            this.historyIndex = -1;
+            this.savedDraft = null;
+          }
+          return [];
+        }
+        if (this.queueIndex >= 0) {
+          this.queueIndex = -1;
+          this.restoreDraft();
           return [];
         }
+        if (this.turnRunning) {
+          return [{ type: "cancel" }];
+        }
         return [{ type: "exit" }];
       }
     };
   }
 });
 
+// src/tui/completion.ts
+function longestCommonPrefix(names) {
+  if (names.length === 0) {
+    return "";
+  }
+  let prefix = names[0] ?? "";
+  for (let i = 1; i < names.length; i++) {
+    const n = names[i] ?? "";
+    let j = 0;
+    while (j < prefix.length && j < n.length && prefix[j] === n[j]) {
+      j += 1;
+    }
+    prefix = prefix.slice(0, j);
+    if (prefix.length === 0) {
+      break;
+    }
+  }
+  return prefix;
+}
+function computeTabCompletion(args) {
+  const { matches, firstLine: firstLine3 } = args;
+  if (matches.length === 0) {
+    return null;
+  }
+  const space = firstLine3.indexOf(" ");
+  const typedPrefix = space === -1 ? firstLine3 : firstLine3.slice(0, space);
+  const tail = space === -1 ? "" : firstLine3.slice(space);
+  if (matches.length === 1) {
+    const name = matches[0] ?? "";
+    const suffix = tail.startsWith(" ") ? "" : " ";
+    return name + suffix + tail;
+  }
+  const commonPrefix = longestCommonPrefix(matches);
+  if (commonPrefix.length <= typedPrefix.length) {
+    return null;
+  }
+  return commonPrefix + tail;
+}
+var init_completion = __esm({
+  "src/tui/completion.ts"() {
+    "use strict";
+  }
+});
+
 // src/tui/render-update.ts
 import stripAnsi from "strip-ansi";
 function sanitizeWireText(text) {
   return stripAnsi(text).replace(STRIP_CONTROLS, "");
 }
+function sanitizeSingleLine(text) {
+  return sanitizeWireText(text).replace(/[\n\t]+/g, " ").replace(/  +/g, " ").trim();
+}
 function mapUpdate(update) {
   if (!update || typeof update !== "object") {
     return null;
@@ -4939,7 +6392,7 @@ function mapUpdate(update) {
 }
 function mapSessionInfo(u) {
   const rawTitle = readString(u, "title");
-  const title = rawTitle !== void 0 ? sanitizeWireText(rawTitle) : void 0;
+  const title = rawTitle !== void 0 ? sanitizeSingleLine(rawTitle) : void 0;
   const meta = u._meta;
   let agentId;
   if (meta && typeof meta === "object" && !Array.isArray(meta)) {
@@ -4963,10 +6416,9 @@ function mapSessionInfo(u) {
   }
   return event;
 }
-function mapAvailableCommands(u) {
-  const list = u.availableCommands ?? u.commands;
+function normalizeAdvertisedCommands(list) {
   if (!Array.isArray(list)) {
-    return null;
+    return [];
   }
   const out = [];
   for (const raw of list) {
@@ -4978,13 +6430,20 @@ function mapAvailableCommands(u) {
       continue;
     }
     const rawName = c.name.startsWith("/") ? c.name : `/${c.name}`;
-    const cmd = { name: sanitizeWireText(rawName) };
+    const cmd = { name: sanitizeSingleLine(rawName) };
     if (typeof c.description === "string") {
-      cmd.description = sanitizeWireText(c.description);
+      cmd.description = sanitizeSingleLine(c.description);
     }
     out.push(cmd);
   }
-  return { kind: "available-commands", commands: out };
+  return out;
+}
+function mapAvailableCommands(u) {
+  const list = u.availableCommands ?? u.commands;
+  if (!Array.isArray(list)) {
+    return null;
+  }
+  return { kind: "available-commands", commands: normalizeAdvertisedCommands(list) };
 }
 function mapUsage(u) {
   const event = { kind: "usage-update" };
@@ -5046,7 +6505,7 @@ function mapToolCall(u) {
     return null;
   }
   const rawTitle = readString(u, "title") ?? readString(u, "name") ?? readString(u, "label") ?? "tool call";
-  const title = sanitizeWireText(rawTitle);
+  const title = sanitizeSingleLine(rawTitle);
   const status = readString(u, "status");
   const rawKind = readString(u, "kind");
   const event = { kind: "tool-call", toolCallId, title };
@@ -5064,7 +6523,7 @@ function mapToolCallUpdate(u) {
     return null;
   }
   const rawTitle = readString(u, "title");
-  const title = rawTitle !== void 0 ? sanitizeWireText(rawTitle) : void 0;
+  const title = rawTitle !== void 0 ? sanitizeSingleLine(rawTitle) : void 0;
   const status = readString(u, "status");
   const meaningful = title !== void 0 || status === "completed" || status === "failed" || status === "rejected" || status === "cancelled";
   if (!meaningful) {
@@ -5090,7 +6549,7 @@ function mapPlan(u) {
       continue;
     }
     const e = raw;
-    const content = typeof e.content === "string" ? sanitizeWireText(e.content) : void 0;
+    const content = typeof e.content === "string" ? sanitizeSingleLine(e.content) : void 0;
     if (!content) {
       continue;
     }
@@ -5110,14 +6569,14 @@ function mapMode(u) {
   if (!mode) {
     return null;
   }
-  return { kind: "mode-changed", mode: sanitizeWireText(mode) };
+  return { kind: "mode-changed", mode: sanitizeSingleLine(mode) };
 }
 function mapModel(u) {
   const model = readString(u, "currentModel") ?? readString(u, "model");
   if (!model) {
     return null;
   }
-  return { kind: "model-changed", model: sanitizeWireText(model) };
+  return { kind: "model-changed", model: sanitizeSingleLine(model) };
 }
 function mapTurnComplete(u) {
   const stopReason = readString(u, "stopReason");
@@ -5505,6 +6964,7 @@ import { nanoid as nanoid3 } from "nanoid";
 import termkit from "terminal-kit";
 async function runTuiApp(opts) {
   const config = await ensureConfig();
+  logMaxBytes = config.tui.logMaxBytes;
   await ensureDaemonReachable(config);
   const term = termkit.terminal;
   const exitHint = {};
@@ -5525,7 +6985,7 @@ async function runSession(term, config, opts, exitHint) {
     process.exit(0);
   }
   const launchLabel = ctx.sessionId === "__new__" ? "Starting new session\u2026" : "Resuming session\u2026";
-  term.cyan(launchLabel)("\n");
+  term.brightYellow(launchLabel)("\n");
   const protocol = config.daemon.tls ? "wss" : "ws";
   const wsUrl = `${protocol}://${config.daemon.host}:${config.daemon.port}/acp`;
   const subprotocols = ["acp.v1", `hydra-acp-token.${config.daemon.authToken}`];
@@ -5606,7 +7066,8 @@ async function runSession(term, config, opts, exitHint) {
     const { update } = params ?? {};
     const event = mapUpdate(update);
     debugLogUpdate(update, event);
-    if (event?.kind === "user-text") {
+    const rawTag = update?.sessionUpdate;
+    if (rawTag === "prompt_received") {
       adjustPendingTurns(1);
     } else if (event?.kind === "turn-complete") {
       adjustPendingTurns(-1);
@@ -5677,11 +7138,11 @@ async function runSession(term, config, opts, exitHint) {
     const rawOptions = Array.isArray(p.options) ? p.options : [];
     const options = rawOptions.map((o) => ({
       optionId: o.optionId,
-      name: sanitizeWireText(o.name ?? ""),
+      name: sanitizeSingleLine(o.name ?? ""),
       ...o.kind !== void 0 ? { kind: o.kind } : {}
     }));
     const rawTitle = p.toolCall?.title ?? p.toolCall?.name ?? "tool";
-    const title = sanitizeWireText(rawTitle);
+    const title = sanitizeSingleLine(rawTitle);
     const toolCallId = p.toolCall?.toolCallId;
     if (options.length === 0) {
       screen.appendLines([
@@ -5711,12 +7172,12 @@ async function runSession(term, config, opts, exitHint) {
   let agentInfoName;
   try {
     const initResult = await conn.request("initialize", {
-      protocolVersion: 1,
+      protocolVersion: ACP_PROTOCOL_VERSION,
       clientCapabilities: {
         fs: { readTextFile: false, writeTextFile: false },
         terminal: false
       },
-      clientInfo: { name: "hydra-acp-tui", version: "0.1.0" }
+      clientInfo: { name: "hydra-acp-tui", version: HYDRA_VERSION }
     });
     agentInfoName = initResult?.agentInfo?.name;
   } catch {
@@ -5759,15 +7220,13 @@ async function runSession(term, config, opts, exitHint) {
     initialMode = hydraMeta.currentMode;
     initialTurnStartedAt = hydraMeta.turnStartedAt;
     if (hydraMeta.availableCommands) {
-      initialCommands = hydraMeta.availableCommands.map(
-        (c) => c.description !== void 0 ? { name: c.name, description: c.description } : { name: c.name }
-      );
+      initialCommands = normalizeAdvertisedCommands(hydraMeta.availableCommands);
     }
   } else {
     const attached = await conn.request("session/attach", {
       sessionId: ctx.sessionId,
       historyPolicy: "full",
-      clientInfo: { name: "hydra-acp-tui", version: "0.1.0" }
+      clientInfo: { name: "hydra-acp-tui", version: HYDRA_VERSION }
     });
     resolvedSessionId = attached.sessionId;
     exitHint.sessionId = resolvedSessionId;
@@ -5786,9 +7245,7 @@ async function runSession(term, config, opts, exitHint) {
     initialMode = hydraMeta.currentMode;
     initialTurnStartedAt = hydraMeta.turnStartedAt;
     if (hydraMeta.availableCommands) {
-      initialCommands = hydraMeta.availableCommands.map(
-        (c) => c.description !== void 0 ? { name: c.name, description: c.description } : { name: c.name }
-      );
+      initialCommands = normalizeAdvertisedCommands(hydraMeta.availableCommands);
     }
   }
   const historyFile = paths.tuiHistoryFile(resolvedSessionId);
@@ -5799,11 +7256,13 @@ async function runSession(term, config, opts, exitHint) {
     dispatcher.setTurnRunning(true);
   }
   let turnInFlight = null;
+  let pendingPrefill = null;
   const screen = new Screen({
     term,
     dispatcher,
     repaintThrottleMs: config.tui.repaintThrottleMs,
     maxScrollbackLines: config.tui.maxScrollbackLines,
+    mouse: config.tui.mouse,
     onKey: (events) => {
       for (const ev of events) {
         if (pendingPermission && tryHandlePermissionKey(ev)) {
@@ -5812,6 +7271,9 @@ async function runSession(term, config, opts, exitHint) {
         if (exitConfirmation && tryHandleExitConfirmKey(ev)) {
           continue;
         }
+        if (tryHandleScrollbackSearchKey(ev)) {
+          continue;
+        }
         if (tryHandleCompletionKey(ev)) {
           continue;
         }
@@ -5821,6 +7283,9 @@ async function runSession(term, config, opts, exitHint) {
         }
       }
       refreshCompletions();
+      screen.setBannerSearchIndicator(
+        dispatcher.state().historySearchQuery
+      );
       screen.refreshPrompt();
     }
   });
@@ -5830,6 +7295,7 @@ async function runSession(term, config, opts, exitHint) {
     { name: "/quit", description: "Exit the TUI" },
     { name: "/clear", description: "Clear scrollback" },
     { name: "/sessions", description: "List sessions" },
+    { name: "/model", description: "Switch model: /model <model-id>" },
     { name: "/demo-plan", description: "Inject synthetic plan events (UI test)" },
     { name: "/demo-tool", description: "Inject a synthetic tool-call sequence (UI test)" }
   ];
@@ -5864,48 +7330,73 @@ async function runSession(term, config, opts, exitHint) {
     screen.setCompletions(currentCompletions());
   };
   const tryHandleCompletionKey = (ev) => {
-    if (ev.type !== "key") {
+    if (ev.type !== "key" || ev.name !== "tab") {
       return false;
     }
-    if (ev.name === "tab") {
-      const matches = currentCompletions();
-      const first = matches[0];
-      if (!first) {
-        return false;
-      }
-      const commonPrefix = longestCommonPrefix(matches.map((m) => m.name));
-      const buf = dispatcher.state().buffer;
-      const firstLine3 = buf[0] ?? "";
-      const space = firstLine3.indexOf(" ");
-      const typedPrefix = space === -1 ? firstLine3 : firstLine3.slice(0, space);
-      const tail = space === -1 ? "" : firstLine3.slice(space);
-      let next = commonPrefix;
-      if (commonPrefix.length <= typedPrefix.length || matches.length === 1) {
-        next = first.name + (tail.startsWith(" ") ? "" : " ");
-      }
-      dispatcher.replaceFirstLine(next + tail);
+    const matches = currentCompletions();
+    if (matches.length === 0) {
+      return false;
+    }
+    const firstLine3 = dispatcher.state().buffer[0] ?? "";
+    const next = computeTabCompletion({
+      matches: matches.map((m) => m.name),
+      firstLine: firstLine3
+    });
+    if (next === null) {
       return true;
     }
-    return false;
+    dispatcher.replaceFirstLine(next);
+    return true;
   };
-  function longestCommonPrefix(names) {
-    if (names.length === 0) {
-      return "";
-    }
-    let prefix = names[0] ?? "";
-    for (let i = 1; i < names.length; i++) {
-      const n = names[i] ?? "";
-      let j = 0;
-      while (j < prefix.length && j < n.length && prefix[j] === n[j]) {
-        j += 1;
+  const tryHandleScrollbackSearchKey = (ev) => {
+    if (!screen.isScrollbackSearchActive()) {
+      if (ev.type === "key" && ev.name === "ctrl-r" && screen.isScrolledBack()) {
+        screen.enterScrollbackSearch();
+        screen.updateScrollbackSearchTerm("");
+        return true;
       }
-      prefix = prefix.slice(0, j);
-      if (prefix.length === 0) {
-        break;
+      return false;
+    }
+    if (ev.type === "char") {
+      const term2 = screen.scrollbackSearchTerm() + ev.ch;
+      screen.updateScrollbackSearchTerm(term2);
+      return true;
+    }
+    if (ev.type === "paste") {
+      const term2 = screen.scrollbackSearchTerm() + ev.text.replace(/\n/g, " ");
+      screen.updateScrollbackSearchTerm(term2);
+      return true;
+    }
+    if (ev.type === "key") {
+      switch (ev.name) {
+        case "ctrl-r":
+          screen.advanceScrollbackSearch();
+          return true;
+        case "ctrl-s":
+          screen.retreatScrollbackSearch();
+          return true;
+        case "backspace": {
+          const term2 = screen.scrollbackSearchTerm();
+          if (term2.length === 0) {
+            screen.cancelScrollbackSearch();
+          } else {
+            screen.updateScrollbackSearchTerm(term2.slice(0, -1));
+          }
+          return true;
+        }
+        case "enter":
+          screen.acceptScrollbackSearch();
+          return true;
+        case "escape":
+        case "ctrl-c":
+          screen.cancelScrollbackSearch();
+          return true;
+        default:
+          return true;
       }
     }
-    return prefix;
-  }
+    return true;
+  };
   const tryHandlePermissionKey = (ev) => {
     if (!pendingPermission) {
       return false;
@@ -6112,22 +7603,45 @@ async function runSession(term, config, opts, exitHint) {
     }
     resume(nextOpts);
   };
+  const queueHeadOffset = () => workerActive ? 1 : 0;
   const handleEffect = (effect) => {
     switch (effect.type) {
       case "send":
         enqueuePrompt(effect.text, effect.planMode);
         return;
-      case "cancel":
+      case "queue-edit": {
+        const realIdx = effect.index + queueHeadOffset();
+        const existing = promptQueue[realIdx];
+        if (existing) {
+          promptQueue[realIdx] = { text: effect.text, planMode: existing.planMode };
+          refreshQueueDisplay();
+        }
+        return;
+      }
+      case "queue-remove": {
+        const realIdx = effect.index + queueHeadOffset();
+        if (realIdx >= 0 && realIdx < promptQueue.length) {
+          promptQueue.splice(realIdx, 1);
+          refreshQueueDisplay();
+        }
+        return;
+      }
+      case "cancel": {
+        if (effect.prefill && turnInFlight) {
+          const headOffset = workerActive ? 1 : 0;
+          const waitingEmpty = promptQueue.length <= headOffset;
+          const bufferEmpty = dispatcher.state().buffer.every((line) => line === "");
+          if (waitingEmpty && bufferEmpty) {
+            pendingPrefill = turnInFlight.text;
+          }
+        }
         if (turnInFlight) {
           turnInFlight.cancel();
         } else if (pendingTurns > 0) {
           cancelRemoteTurn();
         }
-        if (promptQueue.length > (workerActive ? 1 : 0)) {
-          promptQueue.length = workerActive ? 1 : 0;
-          refreshQueueDisplay();
-        }
         return;
+      }
       case "exit":
         void requestExit();
         return;
@@ -6140,6 +7654,12 @@ async function runSession(term, config, opts, exitHint) {
       case "redraw":
         screen.fullRedraw();
         return;
+      case "scroll-to-top":
+        screen.scrollToTop();
+        return;
+      case "scroll-to-bottom":
+        screen.scrollToBottom();
+        return;
       case "switch-session":
         void switchSession();
         return;
@@ -6147,6 +7667,10 @@ async function runSession(term, config, opts, exitHint) {
         toolsExpanded = !toolsExpanded;
         renderToolsBlock();
         return;
+      case "escalate-search":
+        screen.enterScrollbackSearch();
+        screen.updateScrollbackSearchTerm(effect.query);
+        return;
     }
   };
   const promptQueue = [];
@@ -6155,6 +7679,7 @@ async function runSession(term, config, opts, exitHint) {
     const waiting = promptQueue.slice(workerActive ? 1 : 0);
     screen.setQueuedPrompts(waiting.map((p) => p.text));
     screen.setBanner({ queued: waiting.length });
+    dispatcher.setQueue(waiting.map((p) => p.text));
   };
   const enqueuePrompt = (text, planMode) => {
     screen.scrollToBottom();
@@ -6191,6 +7716,7 @@ async function runSession(term, config, opts, exitHint) {
         toolCallOrder.length = 0;
         toolsBlockStartedAt = null;
         toolsBlockEndedAt = null;
+        toolsBlockStopReason = null;
         toolsExpanded = false;
         screen.clearScrollback();
         return true;
@@ -6283,6 +7809,40 @@ async function runSession(term, config, opts, exitHint) {
           }
         ]);
         return true;
+      case "/model": {
+        const arg = space === -1 ? "" : trimmed.slice(space + 1).trim();
+        if (arg === "") {
+          screen.appendLines([
+            {
+              prefix: "  ",
+              body: "Usage: /model <model-id>",
+              bodyStyle: "info"
+            }
+          ]);
+          return true;
+        }
+        conn.request("session/set_model", {
+          sessionId: resolvedSessionId,
+          modelId: arg
+        }).then(() => {
+          screen.appendLines([
+            {
+              prefix: "  ",
+              body: `model set to ${arg}`,
+              bodyStyle: "system"
+            }
+          ]);
+        }).catch((err) => {
+          screen.appendLines([
+            {
+              prefix: "  ",
+              body: `set_model failed: ${err.message}`,
+              bodyStyle: "tool-status-fail"
+            }
+          ]);
+        });
+        return true;
+      }
       default:
         return false;
     }
@@ -6302,6 +7862,15 @@ async function runSession(term, config, opts, exitHint) {
     } finally {
       workerActive = false;
       refreshQueueDisplay();
+      if (pendingPrefill !== null) {
+        const text = pendingPrefill;
+        pendingPrefill = null;
+        const bufferEmpty = dispatcher.state().buffer.every((line) => line === "");
+        if (bufferEmpty) {
+          dispatcher.setBuffer(text);
+          screen.refreshPrompt();
+        }
+      }
     }
   };
   const processPrompt = async (text, planMode) => {
@@ -6311,6 +7880,7 @@ async function runSession(term, config, opts, exitHint) {
     appendRender({ kind: "user-text", text });
     let cancelled = false;
     turnInFlight = {
+      text,
       cancel: () => {
         if (cancelled) {
           return;
@@ -6350,6 +7920,7 @@ async function runSession(term, config, opts, exitHint) {
   let toolsExpanded = false;
   let toolsBlockStartedAt = null;
   let toolsBlockEndedAt = null;
+  let toolsBlockStopReason = null;
   const TOOLS_COLLAPSED_LIMIT = 5;
   let agentBuffer = "";
   let agentKey = null;
@@ -6391,12 +7962,17 @@ async function runSession(term, config, opts, exitHint) {
     const inProgress = toolsBlockEndedAt === null;
     const end = toolsBlockEndedAt ?? Date.now();
     const elapsed = end - toolsBlockStartedAt;
+    const stoppedReason = !inProgress && toolsBlockStopReason !== null && toolsBlockStopReason !== "end_turn" ? toolsBlockStopReason : null;
     let summary;
     if (total === 0) {
-      summary = inProgress ? `thinking \xB7 ${formatElapsed(elapsed)}` : `thought \xB7 ${formatElapsed(elapsed)}`;
+      if (stoppedReason !== null) {
+        summary = `stopped (${stoppedReason}) \xB7 ${formatElapsed(elapsed)}`;
+      } else {
+        summary = inProgress ? `thinking \xB7 ${formatElapsed(elapsed)}` : `thought \xB7 ${formatElapsed(elapsed)}`;
+      }
     } else {
       const noun = total === 1 ? "tool" : "tools";
-      const timing = inProgress ? formatElapsed(elapsed) : `took ${formatElapsed(elapsed)}`;
+      const timing = stoppedReason !== null ? `stopped (${stoppedReason}) \xB7 ${formatElapsed(elapsed)}` : inProgress ? formatElapsed(elapsed) : `took ${formatElapsed(elapsed)}`;
       const parts = [`${total} ${noun}`, timing];
       if (inProgress) {
         if (hidden > 0) {
@@ -6407,12 +7983,15 @@ async function runSession(term, config, opts, exitHint) {
       }
       summary = parts.join(" \xB7 ");
     }
+    const pureThinking = total === 0 && inProgress;
+    const frozenStyle = stoppedReason !== null ? "tool-status-fail" : "tool";
+    const frozenBodyStyle = stoppedReason !== null ? "tool-status-fail" : "dim";
     const lines = [
       {
         prefix: "\u2692 ",
-        prefixStyle: "tool",
+        prefixStyle: pureThinking ? "tool-status-running" : frozenStyle,
         body: summary,
-        bodyStyle: "dim"
+        bodyStyle: pureThinking ? "tool-status-running" : frozenBodyStyle
       }
     ];
     for (const id of visibleIds) {
@@ -6426,6 +8005,7 @@ async function runSession(term, config, opts, exitHint) {
   const startToolsBlock = () => {
     toolsBlockStartedAt = Date.now();
     toolsBlockEndedAt = null;
+    toolsBlockStopReason = null;
     renderToolsBlock();
   };
   const recordToolCall = (id, title, status) => {
@@ -6450,6 +8030,7 @@ async function runSession(term, config, opts, exitHint) {
       if (toolsBlockStartedAt === null) {
         toolsBlockStartedAt = Date.now();
         toolsBlockEndedAt = null;
+        toolsBlockStopReason = null;
       }
       toolCallOrder.push(id);
     }
@@ -6551,6 +8132,7 @@ async function runSession(term, config, opts, exitHint) {
       screen.clearKey("plan");
       if (toolsBlockStartedAt !== null) {
         toolsBlockEndedAt = Date.now();
+        toolsBlockStopReason = event.stopReason ?? null;
         renderToolsBlock();
         screen.clearKey("tools");
       }
@@ -6558,6 +8140,7 @@ async function runSession(term, config, opts, exitHint) {
       toolCallOrder.length = 0;
       toolsBlockStartedAt = null;
       toolsBlockEndedAt = null;
+      toolsBlockStopReason = null;
       toolsExpanded = false;
       screen.ensureSeparator();
     }
@@ -6588,6 +8171,8 @@ async function runSession(term, config, opts, exitHint) {
       }, 1e3);
     }
     startToolsBlock();
+  } else if (initialTurnStartedAt === void 0 && pendingTurns > 0) {
+    adjustPendingTurns(-pendingTurns);
   }
   const resetInFlightUiState = () => {
     if (pendingPermission) {
@@ -6599,12 +8184,14 @@ async function runSession(term, config, opts, exitHint) {
     closeAgentText();
     if (toolsBlockStartedAt !== null) {
       toolsBlockEndedAt = Date.now();
+      toolsBlockStopReason = null;
       renderToolsBlock();
       screen.clearKey("tools");
       toolStates.clear();
       toolCallOrder.length = 0;
       toolsBlockStartedAt = null;
       toolsBlockEndedAt = null;
+      toolsBlockStopReason = null;
       toolsExpanded = false;
     }
     screen.clearKey("plan");
@@ -6622,12 +8209,12 @@ async function runSession(term, config, opts, exitHint) {
       id: `tui-reinit-${nanoid3()}`,
       method: "initialize",
       params: {
-        protocolVersion: 1,
+        protocolVersion: ACP_PROTOCOL_VERSION,
         clientCapabilities: {
           fs: { readTextFile: false, writeTextFile: false },
           terminal: false
         },
-        clientInfo: { name: "hydra-acp-tui", version: "0.1.0" }
+        clientInfo: { name: "hydra-acp-tui", version: HYDRA_VERSION }
       }
     };
     try {
@@ -6641,7 +8228,7 @@ async function runSession(term, config, opts, exitHint) {
       params: {
         sessionId: resolvedSessionId,
         historyPolicy: "none",
-        clientInfo: { name: "hydra-acp-tui", version: "0.1.0" },
+        clientInfo: { name: "hydra-acp-tui", version: HYDRA_VERSION },
         ...upstreamSessionId !== void 0 ? {
           _meta: {
             [HYDRA_META_KEY]: {
@@ -6765,15 +8352,15 @@ function writeDebugLine(payload) {
 }
 function rotateIfBig(target) {
   try {
-    const stat3 = statSync(target);
-    if (stat3.size < TUI_LOG_MAX_BYTES) {
+    const stat4 = statSync(target);
+    if (stat4.size < logMaxBytes) {
       return;
     }
     renameSync(target, `${target}.0`);
   } catch {
   }
 }
-var PLAN_PREFIX_TEXT, TUI_LOG_MAX_BYTES;
+var PLAN_PREFIX_TEXT, logMaxBytes;
 var init_app = __esm({
   "src/tui/app.ts"() {
     "use strict";
@@ -6784,15 +8371,17 @@ var init_app = __esm({
     init_daemon_bootstrap();
     init_session();
     init_paths();
+    init_hydra_version();
     init_history();
     init_discovery();
     init_picker();
     init_screen();
     init_input();
+    init_completion();
     init_render_update();
     init_format();
     PLAN_PREFIX_TEXT = "Plan mode is on. Outline what you would do without making any changes. Do not edit files, run shell commands, or otherwise execute side effects; produce a plan only.";
-    TUI_LOG_MAX_BYTES = 5 * 1024 * 1024;
+    logMaxBytes = 5 * 1024 * 1024;
   }
 });
 
@@ -6809,9 +8398,9 @@ var init_tui = __esm({
 });
 
 // src/cli.ts
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import { dirname as dirname4, resolve as resolve4 } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname6, resolve as resolve4 } from "path";
 
 // src/cli/parse-args.ts
 function parseArgs(argv) {
@@ -6875,35 +8464,28 @@ init_config();
 import * as fs2 from "fs/promises";
 async function runInit(flags) {
   await fs2.mkdir(paths.home(), { recursive: true });
-  let existing;
-  try {
-    existing = await loadConfig();
-  } catch {
-    existing = void 0;
-  }
-  if (!existing) {
-    const config = await writeMinimalInitConfig();
+  const existingToken = await loadAuthToken();
+  if (!existingToken) {
+    const token = generateAuthToken();
+    await writeAuthToken(token);
     process.stdout.write(
-      `Initialized ${paths.config()}
-Auth token: ${config.daemon.authToken}
+      `Initialized ${paths.authToken()}
+Auth token: ${token}
 `
     );
     return;
   }
   if (flagBool(flags, "rotate-token")) {
     const newToken = generateAuthToken();
-    await updateConfigField((raw) => {
-      const daemon = raw.daemon ??= {};
-      daemon.authToken = newToken;
-    });
+    await writeAuthToken(newToken);
     process.stdout.write(
-      `Rotated token in ${paths.config()}
+      `Rotated token in ${paths.authToken()}
 New token: ${newToken}
 `
     );
     return;
   }
-  process.stdout.write(`Config already exists at ${paths.config()}.
+  process.stdout.write(`Auth token already exists at ${paths.authToken()}.
 `);
   process.stdout.write("Pass --rotate-token to generate a new auth token.\n");
 }
@@ -6911,13 +8493,13 @@ New token: ${newToken}
 // src/cli/commands/daemon.ts
 init_paths();
 init_config();
-import * as fsp5 from "fs/promises";
+import * as fsp6 from "fs/promises";
 import { setTimeout as sleep2 } from "timers/promises";
 
 // src/daemon/server.ts
 init_config();
-import * as fs10 from "fs";
-import * as fsp3 from "fs/promises";
+import * as fs11 from "fs";
+import * as fsp4 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
 import pino from "pino";
@@ -7072,60 +8654,177 @@ function formatProgress(agentId, received, total, done = false) {
     const tag2 = done ? "downloaded" : "downloading";
     return `hydra-acp: ${tag2} ${agentId} ${rxMb}/${totalMb} MB (${pct}%)`;
   }
-  const tag = done ? "downloaded" : "downloading";
-  return `hydra-acp: ${tag} ${agentId} ${rxMb} MB`;
-}
-function inferArchiveName(url) {
-  const u = new URL(url);
-  const base = path2.posix.basename(u.pathname);
-  return base || "archive";
-}
-async function extract(archivePath, dest) {
-  const lower = archivePath.toLowerCase();
-  if (lower.endsWith(".tar.gz") || lower.endsWith(".tgz") || lower.endsWith(".tar")) {
-    await run("tar", ["-xf", archivePath, "-C", dest]);
-    return;
+  const tag = done ? "downloaded" : "downloading";
+  return `hydra-acp: ${tag} ${agentId} ${rxMb} MB`;
+}
+function inferArchiveName(url) {
+  const u = new URL(url);
+  const base = path2.posix.basename(u.pathname);
+  return base || "archive";
+}
+async function extract(archivePath, dest) {
+  const lower = archivePath.toLowerCase();
+  if (lower.endsWith(".tar.gz") || lower.endsWith(".tgz") || lower.endsWith(".tar")) {
+    await run("tar", ["-xf", archivePath, "-C", dest]);
+    return;
+  }
+  if (lower.endsWith(".zip")) {
+    if (await hasCommand("unzip")) {
+      await run("unzip", ["-q", archivePath, "-d", dest]);
+      return;
+    }
+    await run("tar", ["-xf", archivePath, "-C", dest]);
+    return;
+  }
+  throw new Error(`Unsupported archive format: ${archivePath}`);
+}
+function run(cmd, args) {
+  return new Promise((resolve5, reject) => {
+    const child = spawn(cmd, args, {
+      stdio: ["ignore", "ignore", "inherit"]
+    });
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      if (code === 0) {
+        resolve5();
+        return;
+      }
+      reject(
+        new Error(
+          `${cmd} ${args.join(" ")} exited with ${code !== null ? `code ${code}` : `signal ${signal}`}`
+        )
+      );
+    });
+  });
+}
+async function hasCommand(name) {
+  return new Promise((resolve5) => {
+    const finder = process.platform === "win32" ? "where" : "which";
+    const child = spawn(finder, [name], { stdio: "ignore" });
+    child.on("error", () => resolve5(false));
+    child.on("exit", (code) => resolve5(code === 0));
+  });
+}
+async function fileExists(p) {
+  try {
+    await fsp.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/npm-install.ts
+init_paths();
+import * as fsp2 from "fs/promises";
+import * as path3 from "path";
+import { spawn as spawn2 } from "child_process";
+var logSink2 = (msg) => {
+  process.stderr.write(msg + "\n");
+};
+function setNpmInstallLogger(log) {
+  logSink2 = log ?? ((msg) => process.stderr.write(msg + "\n"));
+}
+async function ensureNpmPackage(args) {
+  const platformKey = currentPlatformKey();
+  if (!platformKey) {
+    throw new Error(
+      `Agent ${args.agentId}: cannot determine platform key for ${process.platform}/${process.arch}`
+    );
+  }
+  const installDir = paths.agentNpmInstallDir(
+    args.agentId,
+    platformKey,
+    args.version
+  );
+  const binPath = path3.join(installDir, "node_modules", ".bin", args.bin);
+  if (await fileExists2(binPath)) {
+    return binPath;
+  }
+  await installInto({
+    agentId: args.agentId,
+    packageSpec: args.packageSpec,
+    installDir
+  });
+  if (!await fileExists2(binPath)) {
+    throw new Error(
+      `Agent ${args.agentId}: npm install of ${args.packageSpec} did not produce bin ${args.bin} (looked in ${installDir}/node_modules/.bin/)`
+    );
   }
-  if (lower.endsWith(".zip")) {
-    if (await hasCommand("unzip")) {
-      await run("unzip", ["-q", archivePath, "-d", dest]);
-      return;
+  return binPath;
+}
+async function installInto(args) {
+  await fsp2.mkdir(path3.dirname(args.installDir), { recursive: true });
+  const tempDir = await fsp2.mkdtemp(`${args.installDir}.partial-`);
+  try {
+    logSink2(
+      `hydra-acp: installing ${args.packageSpec} for ${args.agentId} into ${tempDir}`
+    );
+    await runNpmInstall({
+      packageSpec: args.packageSpec,
+      cwd: tempDir
+    });
+    try {
+      await fsp2.rename(tempDir, args.installDir);
+    } catch (err) {
+      const e = err;
+      if ((e.code === "EEXIST" || e.code === "ENOTEMPTY") && await fileExists2(args.installDir)) {
+        await fsp2.rm(tempDir, { recursive: true, force: true }).catch(
+          () => void 0
+        );
+        return;
+      }
+      throw err;
     }
-    await run("tar", ["-xf", archivePath, "-C", dest]);
-    return;
+    logSink2(`hydra-acp: installed ${args.agentId} to ${args.installDir}`);
+  } catch (err) {
+    await fsp2.rm(tempDir, { recursive: true, force: true }).catch(
+      () => void 0
+    );
+    throw err;
   }
-  throw new Error(`Unsupported archive format: ${archivePath}`);
 }
-function run(cmd, args) {
+function runNpmInstall(args) {
   return new Promise((resolve5, reject) => {
-    const child = spawn(cmd, args, {
-      stdio: ["ignore", "ignore", "inherit"]
+    const child = spawn2(
+      "npm",
+      ["install", "--no-audit", "--no-fund", "--silent", args.packageSpec],
+      {
+        cwd: args.cwd,
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    let stderrTail = "";
+    child.stdout?.on("data", (chunk) => {
+      void chunk;
+    });
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+      stderrTail = (stderrTail + chunk).slice(-4096);
+    });
+    child.on("error", (err) => {
+      const msg = err.code === "ENOENT" ? `npm not found on PATH (install Node.js / npm, or use a binary-distributed agent)` : err.message;
+      reject(new Error(msg));
     });
-    child.on("error", reject);
     child.on("exit", (code, signal) => {
       if (code === 0) {
         resolve5();
         return;
       }
+      const reason = code !== null ? `exit code ${code}` : `signal ${signal ?? "unknown"}`;
+      const tail = stderrTail.trim();
       reject(
         new Error(
-          `${cmd} ${args.join(" ")} exited with ${code !== null ? `code ${code}` : `signal ${signal}`}`
+          tail ? `npm install ${args.packageSpec} failed (${reason})
+stderr: ${tail}` : `npm install ${args.packageSpec} failed (${reason})`
         )
       );
     });
   });
 }
-async function hasCommand(name) {
-  return new Promise((resolve5) => {
-    const finder = process.platform === "win32" ? "where" : "which";
-    const child = spawn(finder, [name], { stdio: "ignore" });
-    child.on("error", () => resolve5(false));
-    child.on("exit", (code) => resolve5(code === 0));
-  });
-}
-async function fileExists(p) {
+async function fileExists2(p) {
   try {
-    await fsp.access(p);
+    await fsp2.access(p);
     return true;
   } catch {
     return false;
@@ -7135,6 +8834,10 @@ async function fileExists(p) {
 // src/core/registry.ts
 var NpxDistribution = z2.object({
   package: z2.string(),
+  // The bin to invoke after install. Defaults to the package basename
+  // (e.g. "claude-code" for "@anthropic-ai/claude-code"). Required when
+  // the package exposes a bin name that differs from its basename.
+  bin: z2.string().optional(),
   args: z2.array(z2.string()).optional(),
   env: z2.record(z2.string()).optional()
 });
@@ -7294,13 +8997,27 @@ function npxPackageBasename(agent) {
   const atIdx = afterSlash.lastIndexOf("@");
   return atIdx <= 0 ? afterSlash : afterSlash.slice(0, atIdx);
 }
-async function planSpawn(agent, extraArgs = []) {
+async function planSpawn(agent, callerArgs = []) {
   if (agent.distribution.npx) {
     const npx = agent.distribution.npx;
-    const args = ["-y", npx.package, ...npx.args ?? [], ...extraArgs];
+    const tail = callerArgs.length > 0 ? callerArgs : npx.args ?? [];
+    if (process.env.HYDRA_ACP_SKIP_NPM_PREFETCH) {
+      return {
+        command: "npx",
+        args: ["-y", npx.package, ...tail],
+        env: npx.env ?? {}
+      };
+    }
+    const bin = npx.bin ?? npxPackageBasename(agent) ?? npx.package;
+    const binPath = await ensureNpmPackage({
+      agentId: agent.id,
+      version: agent.version ?? "current",
+      packageSpec: npx.package,
+      bin
+    });
     return {
-      command: "npx",
-      args,
+      command: binPath,
+      args: tail,
       env: npx.env ?? {}
     };
   }
@@ -7316,30 +9033,27 @@ async function planSpawn(agent, extraArgs = []) {
       version: agent.version ?? "current",
       target
     });
+    const tail = callerArgs.length > 0 ? callerArgs : target.args ?? [];
     return {
       command: cmdPath,
-      args: [...target.args ?? [], ...extraArgs],
+      args: tail,
       env: target.env ?? {}
     };
   }
   if (agent.distribution.uvx) {
     const uvx = agent.distribution.uvx;
-    const args = [uvx.package, ...uvx.args ?? [], ...extraArgs];
+    const tail = callerArgs.length > 0 ? callerArgs : uvx.args ?? [];
     return {
       command: "uvx",
-      args,
+      args: [uvx.package, ...tail],
       env: uvx.env ?? {}
     };
   }
   throw new Error(`Agent ${agent.id} has no usable distribution method.`);
 }
 
-// src/core/session-manager.ts
-import * as fs8 from "fs/promises";
-import { customAlphabet as customAlphabet3 } from "nanoid";
-
 // src/core/agent-instance.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 
 // src/acp/framing.ts
 init_types();
@@ -7420,17 +9134,22 @@ function ndjsonStreamFromStdio(stdout, stdin) {
 
 // src/core/agent-instance.ts
 init_connection();
+var DEFAULT_STDERR_TAIL_BYTES = 4096;
 var AgentInstance = class _AgentInstance {
   agentId;
   cwd;
   connection;
   child;
   exited = false;
+  killed = false;
+  stderrTail = "";
+  stderrTailBytes;
   exitHandlers = [];
   constructor(opts, child) {
     this.agentId = opts.agentId;
     this.cwd = opts.cwd;
     this.child = child;
+    this.stderrTailBytes = opts.stderrTailBytes ?? DEFAULT_STDERR_TAIL_BYTES;
     if (!child.stdout || !child.stdin) {
       throw new Error("agent subprocess missing stdio");
     }
@@ -7438,22 +9157,36 @@ var AgentInstance = class _AgentInstance {
     this.connection = new JsonRpcConnection(stream);
     child.stderr?.setEncoding("utf8");
     child.stderr?.on("data", (chunk) => {
+      this.stderrTail = (this.stderrTail + chunk).slice(-this.stderrTailBytes);
       process.stderr.write(`[${opts.agentId}] ${chunk}`);
     });
+    child.on("error", (err) => {
+      const msg = this.formatFailure(err.message);
+      this.connection.fail(new Error(msg));
+    });
     child.on("exit", (code, signal) => {
       this.exited = true;
+      if (!this.killed) {
+        const reason = `agent ${opts.agentId} exited before responding (code=${code} signal=${signal})`;
+        this.connection.fail(new Error(this.formatFailure(reason)));
+      }
       for (const handler of this.exitHandlers) {
         handler(code, signal);
       }
     });
   }
+  formatFailure(reason) {
+    const tail = this.stderrTail.trim();
+    return tail ? `${reason}
+stderr: ${tail}` : reason;
+  }
   static spawn(opts) {
     const env = {
       ...process.env,
       ...opts.plan.env,
       ...opts.extraEnv ?? {}
     };
-    const child = spawn2(opts.plan.command, opts.plan.args, {
+    const child = spawn3(opts.plan.command, opts.plan.args, {
       cwd: opts.cwd,
       env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -7470,196 +9203,33 @@ var AgentInstance = class _AgentInstance {
     if (this.exited) {
       return;
     }
+    this.killed = true;
     await this.connection.close().catch(() => void 0);
     this.child.kill(signal);
   }
 };
 
 // src/core/session-manager.ts
+import * as fs9 from "fs/promises";
+import * as os2 from "os";
+import { customAlphabet as customAlphabet3 } from "nanoid";
 init_session();
-
-// src/core/session-store.ts
-init_paths();
-import * as fs5 from "fs/promises";
-import * as path3 from "path";
-import { customAlphabet as customAlphabet2 } from "nanoid";
-import { z as z4 } from "zod";
-var HYDRA_ID_ALPHABET2 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-var generateRawId = customAlphabet2(HYDRA_ID_ALPHABET2, 16);
-var HYDRA_LINEAGE_PREFIX = "hydra_lineage_";
-function generateLineageId() {
-  return `${HYDRA_LINEAGE_PREFIX}${generateRawId()}`;
-}
-var PersistedAgentCommand = z4.object({
-  name: z4.string(),
-  description: z4.string().optional()
-});
-var PersistedUsage = z4.object({
-  used: z4.number().optional(),
-  size: z4.number().optional(),
-  costAmount: z4.number().optional(),
-  costCurrency: z4.string().optional()
-});
-var SessionRecord = z4.object({
-  version: z4.literal(1),
-  sessionId: z4.string(),
-  // Optional for back-compat with records written before this field
-  // existed; mergeForPersistence generates one on next write so any
-  // touched session converges to having a lineageId. A record that
-  // never gets written again (truly cold and untouched) just won't
-  // participate in lineage-based dedup, which is correct — it was
-  // never exported, so no incoming bundle can claim its lineage.
-  lineageId: z4.string().optional(),
-  upstreamSessionId: z4.string(),
-  // When non-empty, marks a session that was created by import and is
-  // waiting for its first attach to bootstrap a fresh upstream agent
-  // and replay the imported history as a takeover transcript. The
-  // origin's local id at export time, kept for debuggability and as a
-  // breadcrumb in `sessions list` (informational, not used for routing).
-  importedFromSessionId: z4.string().optional(),
-  agentId: z4.string(),
-  cwd: z4.string(),
-  title: z4.string().optional(),
-  agentArgs: z4.array(z4.string()).optional(),
-  // Snapshot of "what is currently true about this session" carried in
-  // meta.json so a late-attaching or cold-resurrected client can be
-  // told via the attach response _meta without depending on history
-  // replay of a snapshot-shaped notification.
-  currentModel: z4.string().optional(),
-  currentMode: z4.string().optional(),
-  currentUsage: PersistedUsage.optional(),
-  agentCommands: z4.array(PersistedAgentCommand).optional(),
-  createdAt: z4.string(),
-  updatedAt: z4.string()
-});
-var SESSION_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
-function assertSafeId(id) {
-  if (!SESSION_ID_PATTERN.test(id)) {
-    throw new Error(`unsafe session id: ${id}`);
-  }
-}
-var SessionStore = class {
-  async write(record) {
-    assertSafeId(record.sessionId);
-    await fs5.mkdir(paths.sessionDir(record.sessionId), { recursive: true });
-    const full = { version: 1, ...record };
-    await fs5.writeFile(
-      paths.sessionFile(record.sessionId),
-      JSON.stringify(full, null, 2) + "\n",
-      { encoding: "utf8", mode: 384 }
-    );
-  }
-  async read(sessionId) {
-    if (!SESSION_ID_PATTERN.test(sessionId)) {
-      return void 0;
-    }
-    let raw;
-    try {
-      raw = await fs5.readFile(paths.sessionFile(sessionId), "utf8");
-    } catch (err) {
-      const e = err;
-      if (e.code === "ENOENT") {
-        return void 0;
-      }
-      throw err;
-    }
-    try {
-      return SessionRecord.parse(JSON.parse(raw));
-    } catch {
-      return void 0;
-    }
-  }
-  async delete(sessionId) {
-    if (!SESSION_ID_PATTERN.test(sessionId)) {
-      return;
-    }
-    try {
-      await fs5.unlink(paths.sessionFile(sessionId));
-    } catch (err) {
-      const e = err;
-      if (e.code !== "ENOENT") {
-        throw err;
-      }
-    }
-    try {
-      await fs5.rmdir(paths.sessionDir(sessionId));
-    } catch (err) {
-      const e = err;
-      if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
-        throw err;
-      }
-    }
-  }
-  // Find a persisted session by lineageId. Used by SessionManager.import
-  // to detect bundles that have already been imported (lineageId match)
-  // so we can either error out or, with replace:true, overwrite.
-  // Returns undefined if no record has that lineageId. Records that
-  // pre-date the lineageId field simply don't match — which is
-  // correct: they were never exported, so no incoming bundle can
-  // legitimately claim their lineage.
-  async findByLineageId(lineageId) {
-    if (lineageId.length === 0) {
-      return void 0;
-    }
-    const all = await this.list().catch(() => []);
-    for (const record of all) {
-      if (record.lineageId === lineageId) {
-        return record;
-      }
-    }
-    return void 0;
-  }
-  async list() {
-    let entries;
-    try {
-      entries = await fs5.readdir(paths.sessionsDir());
-    } catch (err) {
-      const e = err;
-      if (e.code === "ENOENT") {
-        return [];
-      }
-      throw err;
-    }
-    const records = [];
-    for (const entry of entries) {
-      const record = await this.read(entry);
-      if (record) {
-        records.push(record);
-      }
-    }
-    return records;
-  }
-};
-function recordFromMemorySession(args) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    sessionId: args.sessionId,
-    lineageId: args.lineageId,
-    upstreamSessionId: args.upstreamSessionId,
-    importedFromSessionId: args.importedFromSessionId,
-    agentId: args.agentId,
-    cwd: args.cwd,
-    title: args.title,
-    agentArgs: args.agentArgs,
-    currentModel: args.currentModel,
-    currentMode: args.currentMode,
-    currentUsage: args.currentUsage,
-    agentCommands: args.agentCommands,
-    createdAt: args.createdAt ?? now,
-    updatedAt: args.updatedAt ?? now
-  };
-}
+init_session_store();
 
 // src/core/history-store.ts
 init_paths();
 import * as fs6 from "fs/promises";
 var SESSION_ID_PATTERN2 = /^[A-Za-z0-9_-]+$/;
-var MAX_ENTRIES = 1e3;
+var DEFAULT_MAX_ENTRIES = 1e3;
 var HistoryStore = class {
   // Serialize writes per session id so appends and rewrites don't
   // interleave JSONL lines on disk. The chain swallows errors so one
   // failed append doesn't poison every subsequent write.
   writeQueues = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(options = {}) {
+    this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  }
   async append(sessionId, entry) {
     if (!SESSION_ID_PATTERN2.test(sessionId)) {
       return;
@@ -7761,8 +9331,8 @@ var HistoryStore = class {
         recordedAt: obj.recordedAt
       });
     }
-    if (out.length > MAX_ENTRIES) {
-      return out.slice(-MAX_ENTRIES);
+    if (out.length > this.maxEntries) {
+      return out.slice(-this.maxEntries);
     }
     return out;
   }
@@ -7807,6 +9377,7 @@ var HistoryStore = class {
 init_paths();
 init_history();
 init_types();
+init_hydra_version();
 var HYDRA_ID_ALPHABET3 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 var generateRawSessionId = customAlphabet3(HYDRA_ID_ALPHABET3, 16);
 var SessionManager = class {
@@ -7814,7 +9385,8 @@ var SessionManager = class {
     this.registry = registry;
     this.spawner = spawner ?? ((opts) => AgentInstance.spawn(opts));
     this.store = store ?? new SessionStore();
-    this.histories = new HistoryStore();
+    this.sessionHistoryMaxEntries = options.sessionHistoryMaxEntries ?? 1e3;
+    this.histories = new HistoryStore({ maxEntries: this.sessionHistoryMaxEntries });
     this.idleTimeoutMs = options.idleTimeoutMs ?? 0;
     this.defaultModels = options.defaultModels ?? {};
   }
@@ -7826,6 +9398,7 @@ var SessionManager = class {
   histories;
   idleTimeoutMs;
   defaultModels;
+  sessionHistoryMaxEntries;
   // Serialize meta.json read-modify-write operations per session id so
   // concurrent snapshot updates (e.g. an agent emitting model + mode
   // back-to-back) don't lose writes via interleaved reads.
@@ -7849,6 +9422,7 @@ var SessionManager = class {
       idleTimeoutMs: this.idleTimeoutMs,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       historyStore: this.histories,
+      historyMaxEntries: this.sessionHistoryMaxEntries,
       currentModel: fresh.initialModel
     });
     await this.attachManagerHooks(session);
@@ -7900,11 +9474,16 @@ var SessionManager = class {
       cwd: params.cwd,
       plan
     });
-    await agent.connection.request("initialize", {
-      protocolVersion: 1,
-      clientCapabilities: {},
-      clientInfo: { name: "hydra", version: "0.1.0" }
-    });
+    try {
+      await agent.connection.request("initialize", {
+        protocolVersion: ACP_PROTOCOL_VERSION,
+        clientCapabilities: {},
+        clientInfo: { name: "hydra", version: HYDRA_VERSION }
+      });
+    } catch (err) {
+      await agent.kill().catch(() => void 0);
+      throw err;
+    }
     let loadResult;
     try {
       loadResult = await agent.connection.request(
@@ -7916,10 +9495,12 @@ var SessionManager = class {
         }
       );
     } catch (err) {
-      await agent.kill().catch(() => void 0);
-      throw new Error(
-        `agent ${params.agentId} failed to load upstream session ${params.upstreamSessionId}: ${err.message}`
+      process.stderr.write(
+        `session/load failed for upstream ${params.upstreamSessionId} on ${params.agentId} (${err.message}); recovering via import-reseed
+`
       );
+      await agent.kill().catch(() => void 0);
+      return this.doResurrectFromImport(params);
     }
     const session = new Session({
       sessionId: params.hydraSessionId,
@@ -7933,6 +9514,7 @@ var SessionManager = class {
       idleTimeoutMs: this.idleTimeoutMs,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       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
@@ -7959,15 +9541,16 @@ var SessionManager = class {
   // so subsequent resurrects of this session use the normal session/load
   // path.
   async doResurrectFromImport(params) {
+    const cwd = await this.resolveImportCwd(params.cwd);
     const fresh = await this.bootstrapAgent({
       agentId: params.agentId,
-      cwd: params.cwd,
+      cwd,
       agentArgs: params.agentArgs,
       mcpServers: []
     });
     const session = new Session({
       sessionId: params.hydraSessionId,
-      cwd: params.cwd,
+      cwd,
       agentId: params.agentId,
       agent: fresh.agent,
       upstreamSessionId: fresh.upstreamSessionId,
@@ -7977,6 +9560,7 @@ var SessionManager = class {
       idleTimeoutMs: this.idleTimeoutMs,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       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,
@@ -7990,6 +9574,16 @@ var SessionManager = class {
     void session.seedFromImport().catch(() => void 0);
     return session;
   }
+  async resolveImportCwd(cwd) {
+    try {
+      const stat4 = await fs9.stat(cwd);
+      if (stat4.isDirectory()) {
+        return cwd;
+      }
+    } catch {
+    }
+    return os2.homedir();
+  }
   // Bootstrap a fresh agent process: registry resolve → spawn → initialize
   // → session/new. Shared by create() and the /hydra agent path so both
   // go through the same env / capabilities / error-handling.
@@ -8010,9 +9604,9 @@ var SessionManager = class {
     });
     try {
       await agent.connection.request("initialize", {
-        protocolVersion: 1,
+        protocolVersion: ACP_PROTOCOL_VERSION,
         clientCapabilities: {},
-        clientInfo: { name: "hydra", version: "0.1.0" }
+        clientInfo: { name: "hydra", version: HYDRA_VERSION }
       });
       const newResult = await agent.connection.request(
         "session/new",
@@ -8292,7 +9886,8 @@ var SessionManager = class {
       await this.writeImportedRecord({
         sessionId: existing.sessionId,
         bundle,
-        preservedCreatedAt: existing.createdAt
+        preservedCreatedAt: existing.createdAt,
+        cwd: opts.cwd
       });
       return {
         sessionId: existing.sessionId,
@@ -8301,7 +9896,11 @@ var SessionManager = class {
       };
     }
     const newId = `${HYDRA_SESSION_PREFIX}${generateRawSessionId()}`;
-    await this.writeImportedRecord({ sessionId: newId, bundle });
+    await this.writeImportedRecord({
+      sessionId: newId,
+      bundle,
+      cwd: opts.cwd
+    });
     return {
       sessionId: newId,
       importedFromSessionId: bundle.session.sessionId,
@@ -8331,7 +9930,7 @@ var SessionManager = class {
         upstreamSessionId: "",
         importedFromSessionId: args.bundle.session.sessionId,
         agentId: args.bundle.session.agentId,
-        cwd: args.bundle.session.cwd,
+        cwd: args.cwd ?? args.bundle.session.cwd,
         title: args.bundle.session.title,
         currentModel: args.bundle.session.currentModel,
         currentMode: args.bundle.session.currentMode,
@@ -8524,7 +10123,7 @@ function asString(value) {
 }
 async function loadPromptHistorySafely(sessionId) {
   try {
-    const raw = await fs8.readFile(paths.tuiHistoryFile(sessionId), "utf8");
+    const raw = await fs9.readFile(paths.tuiHistoryFile(sessionId), "utf8");
     const out = [];
     for (const line of raw.split("\n")) {
       if (line.length === 0) {
@@ -8545,7 +10144,7 @@ async function loadPromptHistorySafely(sessionId) {
 }
 async function historyMtimeIso(sessionId) {
   try {
-    const st = await fs8.stat(paths.historyFile(sessionId));
+    const st = await fs9.stat(paths.historyFile(sessionId));
     return new Date(st.mtimeMs).toISOString();
   } catch {
     return void 0;
@@ -8554,10 +10153,10 @@ async function historyMtimeIso(sessionId) {
 
 // src/core/extensions.ts
 init_paths();
-import { spawn as spawn3 } from "child_process";
-import * as fs9 from "fs";
-import * as fsp2 from "fs/promises";
-import * as path5 from "path";
+import { spawn as spawn4 } from "child_process";
+import * as fs10 from "fs";
+import * as fsp3 from "fs/promises";
+import * as path7 from "path";
 var RESTART_BASE_MS = 1e3;
 var RESTART_CAP_MS = 6e4;
 var STOP_GRACE_MS = 3e3;
@@ -8578,7 +10177,7 @@ var ExtensionManager = class {
     if (!this.context) {
       throw new Error("ExtensionManager: setContext must be called before start");
     }
-    await fsp2.mkdir(paths.extensionsDir(), { recursive: true });
+    await fsp3.mkdir(paths.extensionsDir(), { recursive: true });
     await this.reapOrphans();
     for (const entry of this.entries.values()) {
       if (!entry.config.enabled) {
@@ -8787,7 +10386,7 @@ var ExtensionManager = class {
   async reapOrphans() {
     let entries;
     try {
-      entries = await fsp2.readdir(paths.extensionsDir());
+      entries = await fsp3.readdir(paths.extensionsDir());
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -8799,10 +10398,10 @@ var ExtensionManager = class {
       if (!entry.endsWith(".pid")) {
         continue;
       }
-      const pidPath = path5.join(paths.extensionsDir(), entry);
+      const pidPath = path7.join(paths.extensionsDir(), entry);
       let pid;
       try {
-        const raw = await fsp2.readFile(pidPath, "utf8");
+        const raw = await fsp3.readFile(pidPath, "utf8");
         const parsed = Number.parseInt(raw.trim(), 10);
         if (Number.isInteger(parsed) && parsed > 0) {
           pid = parsed;
@@ -8825,7 +10424,7 @@ var ExtensionManager = class {
           }
         }
       }
-      await fsp2.unlink(pidPath).catch(() => void 0);
+      await fsp3.unlink(pidPath).catch(() => void 0);
     }
   }
   spawn(entry, attempt) {
@@ -8838,7 +10437,7 @@ var ExtensionManager = class {
     }
     const ext = entry.config;
     const command = ext.command.length > 0 ? ext.command : [ext.name];
-    const logStream = fs9.createWriteStream(paths.extensionLogFile(ext.name), {
+    const logStream = fs10.createWriteStream(paths.extensionLogFile(ext.name), {
       flags: "a"
     });
     logStream.write(
@@ -8866,7 +10465,7 @@ var ExtensionManager = class {
     const args = [...baseArgs, ...ext.args];
     let child;
     try {
-      child = spawn3(cmd, args, {
+      child = spawn4(cmd, args, {
         env,
         stdio: ["ignore", "pipe", "pipe"],
         detached: false
@@ -8888,7 +10487,7 @@ var ExtensionManager = class {
     }
     if (typeof child.pid === "number") {
       try {
-        fs9.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
+        fs10.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
 `, {
           encoding: "utf8",
           mode: 384
@@ -8913,7 +10512,7 @@ var ExtensionManager = class {
     });
     child.on("exit", (code, signal) => {
       try {
-        fs9.unlinkSync(paths.extensionPidFile(ext.name));
+        fs10.unlinkSync(paths.extensionPidFile(ext.name));
       } catch {
       }
       logStream.write(
@@ -8971,6 +10570,7 @@ function withCode2(err, code) {
 
 // src/daemon/server.ts
 init_paths();
+init_hydra_version();
 
 // src/daemon/auth.ts
 var BEARER_PREFIX = "Bearer ";
@@ -9026,78 +10626,10 @@ function constantTimeEqual(a, b) {
 
 // src/daemon/routes/sessions.ts
 init_config();
-import * as os2 from "os";
-
-// src/core/bundle.ts
-import { z as z5 } from "zod";
-var HistoryEntrySchema = z5.object({
-  method: z5.string(),
-  params: z5.unknown(),
-  recordedAt: z5.number()
-});
-var BundleSession = z5.object({
-  // The exporter's local id. Regenerated fresh on import (sessionId is
-  // the local namespace; lineageId is what survives across hops).
-  sessionId: z5.string(),
-  // Required on bundles — the export path backfills if the source
-  // record was written before lineageId existed.
-  lineageId: z5.string(),
-  agentId: z5.string(),
-  cwd: z5.string(),
-  title: z5.string().optional(),
-  currentModel: z5.string().optional(),
-  currentMode: z5.string().optional(),
-  currentUsage: PersistedUsage.optional(),
-  agentCommands: z5.array(PersistedAgentCommand).optional(),
-  createdAt: z5.string(),
-  updatedAt: z5.string()
-});
-var Bundle = z5.object({
-  version: z5.literal(1),
-  exportedAt: z5.string(),
-  exportedFrom: z5.object({
-    hydraVersion: z5.string(),
-    machine: z5.string()
-  }),
-  session: BundleSession,
-  history: z5.array(HistoryEntrySchema),
-  promptHistory: z5.array(z5.string()).optional()
-});
-function encodeBundle(params) {
-  const bundle = {
-    version: 1,
-    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    exportedFrom: {
-      hydraVersion: params.hydraVersion,
-      machine: params.machine
-    },
-    session: {
-      sessionId: params.record.sessionId,
-      lineageId: params.record.lineageId,
-      agentId: params.record.agentId,
-      cwd: params.record.cwd,
-      ...params.record.title !== void 0 ? { title: params.record.title } : {},
-      ...params.record.currentModel !== void 0 ? { currentModel: params.record.currentModel } : {},
-      ...params.record.currentMode !== void 0 ? { currentMode: params.record.currentMode } : {},
-      ...params.record.currentUsage !== void 0 ? { currentUsage: params.record.currentUsage } : {},
-      ...params.record.agentCommands !== void 0 ? { agentCommands: params.record.agentCommands } : {},
-      createdAt: params.record.createdAt,
-      updatedAt: params.record.updatedAt
-    },
-    history: params.history
-  };
-  if (params.promptHistory !== void 0) {
-    bundle.promptHistory = params.promptHistory;
-  }
-  return bundle;
-}
-function decodeBundle(raw) {
-  return Bundle.parse(raw);
-}
-
-// src/daemon/routes/sessions.ts
+init_bundle();
 init_types();
-var HYDRA_VERSION = "0.1.0";
+init_hydra_version();
+import * as os3 from "os";
 function registerSessionRoutes(app, manager, defaults) {
   app.get("/v1/sessions", async (request) => {
     const query = request.query;
@@ -9168,7 +10700,7 @@ function registerSessionRoutes(app, manager, defaults) {
       history: exported.history,
       promptHistory: exported.promptHistory.length > 0 ? exported.promptHistory : void 0,
       hydraVersion: HYDRA_VERSION,
-      machine: os2.hostname()
+      machine: os3.hostname()
     });
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     reply.header(
@@ -9183,6 +10715,14 @@ function registerSessionRoutes(app, manager, defaults) {
       reply.code(400).send({ error: "missing bundle" });
       return;
     }
+    let cwdOverride;
+    if (body.cwd !== void 0) {
+      if (typeof body.cwd !== "string" || body.cwd.length === 0) {
+        reply.code(400).send({ error: "cwd must be a non-empty string" });
+        return;
+      }
+      cwdOverride = body.cwd;
+    }
     let bundle;
     try {
       bundle = decodeBundle(body.bundle);
@@ -9195,7 +10735,8 @@ function registerSessionRoutes(app, manager, defaults) {
     }
     try {
       const result = await manager.importBundle(bundle, {
-        replace: body.replace === true
+        replace: body.replace === true,
+        ...cwdOverride !== void 0 ? { cwd: cwdOverride } : {}
       });
       reply.code(201).send(result);
     } catch (err) {
@@ -9436,8 +10977,7 @@ init_connection();
 init_ws_stream();
 init_types();
 import { nanoid as nanoid2 } from "nanoid";
-var HYDRA_VERSION2 = "0.1.0";
-var HYDRA_PROTOCOL_VERSION = 1;
+init_hydra_version();
 function registerAcpWsEndpoint(app, deps) {
   app.get("/acp", { websocket: true }, (socket, request) => {
     const token = tokenFromUpgradeRequest({
@@ -9700,8 +11240,8 @@ function buildResponseMeta(session) {
 }
 function buildInitializeResult() {
   return {
-    protocolVersion: HYDRA_PROTOCOL_VERSION,
-    agentInfo: { name: "hydra", version: HYDRA_VERSION2 },
+    protocolVersion: ACP_PROTOCOL_VERSION,
+    agentInfo: { name: "hydra", version: HYDRA_VERSION },
     agentCapabilities: {
       // hydra is a transparent proxy: prompt blocks and MCP server configs are
       // forwarded to the underlying agent unchanged. We claim the union of
@@ -9740,14 +11280,13 @@ function bindClientToSession(connection, session, state, clientInfo) {
 }
 
 // src/daemon/server.ts
-var HYDRA_VERSION3 = "0.1.0";
 async function startDaemon(config) {
   ensureLoopbackOrTls(config);
   const httpsOptions = config.daemon.tls ? {
-    key: await fsp3.readFile(config.daemon.tls.key),
-    cert: await fsp3.readFile(config.daemon.tls.cert)
+    key: await fsp4.readFile(config.daemon.tls.key),
+    cert: await fsp4.readFile(config.daemon.tls.cert)
   } : void 0;
-  await fsp3.mkdir(paths.home(), { recursive: true });
+  await fsp4.mkdir(paths.home(), { recursive: true });
   const { stream: logStream, fileStream } = await buildLogStream(
     config.daemon.logLevel
   );
@@ -9756,12 +11295,18 @@ async function startDaemon(config) {
       level: config.daemon.logLevel,
       stream: logStream
     },
-    https: httpsOptions ?? null
+    https: httpsOptions ?? null,
+    // Session bundles can be large (full history + tool output);
+    // the 1MB Fastify default rejects ordinary imports.
+    bodyLimit: 256 * 1024 * 1024
   });
   await app.register(websocketPlugin);
   setBinaryInstallLogger((msg) => {
     app.log.info(msg);
   });
+  setNpmInstallLogger((msg) => {
+    app.log.info(msg);
+  });
   const auth = bearerAuth({ config });
   app.addHook("onRequest", async (request, reply) => {
     if (request.routeOptions.config?.skipAuth) {
@@ -9773,12 +11318,14 @@ async function startDaemon(config) {
     await auth(request, reply);
   });
   const registry = new Registry(config);
-  const manager = new SessionManager(registry, void 0, void 0, {
+  const spawner = (opts) => AgentInstance.spawn({ ...opts, stderrTailBytes: config.daemon.agentStderrTailBytes });
+  const manager = new SessionManager(registry, spawner, void 0, {
     idleTimeoutMs: config.daemon.sessionIdleTimeoutSeconds * 1e3,
-    defaultModels: config.defaultModels
+    defaultModels: config.defaultModels,
+    sessionHistoryMaxEntries: config.daemon.sessionHistoryMaxEntries
   });
   const extensions = new ExtensionManager(extensionList(config));
-  registerHealthRoutes(app, HYDRA_VERSION3);
+  registerHealthRoutes(app, HYDRA_VERSION);
   registerSessionRoutes(app, manager, {
     agentId: config.defaultAgent,
     cwd: config.defaultCwd
@@ -9797,8 +11344,8 @@ async function startDaemon(config) {
   await app.listen({ host: config.daemon.host, port: config.daemon.port });
   const address = app.server.address();
   const boundPort = address && typeof address === "object" ? address.port : config.daemon.port;
-  await fsp3.mkdir(paths.home(), { recursive: true });
-  await fsp3.writeFile(
+  await fsp4.mkdir(paths.home(), { recursive: true });
+  await fsp4.writeFile(
     paths.pidFile(),
     JSON.stringify({
       pid: process.pid,
@@ -9824,9 +11371,10 @@ async function startDaemon(config) {
     await manager.closeAll();
     await manager.flushMetaWrites();
     setBinaryInstallLogger(null);
+    setNpmInstallLogger(null);
     await app.close();
     try {
-      fs10.unlinkSync(paths.pidFile());
+      fs11.unlinkSync(paths.pidFile());
     } catch {
     }
     try {
@@ -9865,13 +11413,13 @@ function ensureLoopbackOrTls(config) {
 init_daemon_bootstrap();
 
 // src/cli/commands/log-tail.ts
-import * as fs11 from "fs";
-import * as fsp4 from "fs/promises";
+import * as fs12 from "fs";
+import * as fsp5 from "fs/promises";
 async function runLogTail(logPath, argv, notFoundMessage) {
   const opts = parseLogTailFlags(argv);
-  let stat3;
+  let stat4;
   try {
-    stat3 = await fsp4.stat(logPath);
+    stat4 = await fsp5.stat(logPath);
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
@@ -9882,14 +11430,14 @@ async function runLogTail(logPath, argv, notFoundMessage) {
     }
     throw err;
   }
-  let position = await printTail(logPath, stat3.size, opts.tail);
+  let position = await printTail(logPath, stat4.size, opts.tail);
   if (!opts.follow) {
     return;
   }
   process.stdout.write(`-- following ${logPath} --
 `);
   let pending = false;
-  const watcher = fs11.watch(logPath, () => {
+  const watcher = fs12.watch(logPath, () => {
     if (pending) {
       return;
     }
@@ -9897,14 +11445,14 @@ async function runLogTail(logPath, argv, notFoundMessage) {
     setImmediate(async () => {
       pending = false;
       try {
-        const s = await fsp4.stat(logPath);
+        const s = await fsp5.stat(logPath);
         if (s.size <= position) {
           if (s.size < position) {
             position = s.size;
           }
           return;
         }
-        const fd = await fsp4.open(logPath, "r");
+        const fd = await fsp5.open(logPath, "r");
         try {
           const buf = Buffer.alloc(s.size - position);
           await fd.read(buf, 0, buf.length, position);
@@ -9931,7 +11479,7 @@ async function printTail(logPath, fileSize, lines) {
     return fileSize;
   }
   const CHUNK = 64 * 1024;
-  const fd = await fsp4.open(logPath, "r");
+  const fd = await fsp5.open(logPath, "r");
   try {
     let position = fileSize;
     let collected = "";
@@ -10100,7 +11648,7 @@ async function runDaemonStatus() {
 }
 async function readPidFile() {
   try {
-    const raw = await fsp5.readFile(paths.pidFile(), "utf8");
+    const raw = await fsp6.readFile(paths.pidFile(), "utf8");
     return JSON.parse(raw);
   } catch (err) {
     const e = err;
@@ -10125,7 +11673,7 @@ init_sessions();
 // src/cli/commands/extensions.ts
 init_config();
 init_paths();
-import * as fsp6 from "fs/promises";
+import * as fsp7 from "fs/promises";
 init_sessions();
 async function runExtensionsList() {
   const config = await loadConfig();
@@ -10321,11 +11869,11 @@ async function runExtensionsRemove(name) {
   }
 }
 async function readRawConfig() {
-  const raw = await fsp6.readFile(paths.config(), "utf8");
+  const raw = await fsp7.readFile(paths.config(), "utf8");
   return JSON.parse(raw);
 }
 async function writeRawConfig(raw) {
-  await fsp6.writeFile(
+  await fsp7.writeFile(
     paths.config(),
     JSON.stringify(raw, null, 2) + "\n",
     { encoding: "utf8", mode: 384 }
@@ -11090,8 +12638,8 @@ async function main() {
         await runSessionsKill(positional[2]);
         return;
       }
-      if (sub === "rm") {
-        await runSessionsRm(positional[2]);
+      if (sub === "remove") {
+        await runSessionsRemove(positional[2]);
         return;
       }
       if (sub === "export") {
@@ -11100,8 +12648,11 @@ async function main() {
         return;
       }
       if (sub === "import") {
+        const cwd = resolveOption(flags, "cwd");
         await runSessionsImport(positional[2], {
-          replace: flags.replace === true
+          replace: flags.replace === true,
+          info: flags.info === true,
+          ...cwd !== void 0 ? { cwd } : {}
         });
         return;
       }
@@ -11204,9 +12755,9 @@ async function dispatchTui(flags, base) {
 }
 function readVersion() {
   try {
-    const here = dirname4(fileURLToPath(import.meta.url));
+    const here = dirname6(fileURLToPath2(import.meta.url));
     const pkg = JSON.parse(
-      readFileSync(resolve4(here, "../package.json"), "utf8")
+      readFileSync2(resolve4(here, "../package.json"), "utf8")
     );
     return pkg.version ?? "unknown";
   } catch {
@@ -11233,11 +12784,11 @@ function printHelp() {
       "  hydra-acp daemon logs [-f] [-n N]  Tail or follow the daemon log",
       "  hydra-acp sessions [list] [--all]  List sessions (live + 20 most-recent cold; --all for everything)",
       "  hydra-acp sessions kill <id>       Demote a live session to cold (keeps the on-disk record)",
-      "  hydra-acp sessions rm <id>         Remove a session entirely (live or cold)",
+      "  hydra-acp sessions remove <id>     Remove a session entirely (live or cold)",
       "  hydra-acp sessions export <id> [--out <file>|.]",
       "                                     Write a session bundle to <file>, to a default-named file when --out=., or to stdout",
-      "  hydra-acp sessions import <file>|- [--replace]",
-      "                                     Import a bundle from <file> or stdin (-); --replace overwrites a lineage match (kills it if live)",
+      "  hydra-acp sessions import <file>|- [--replace] [--cwd <path>] [--info]",
+      "                                     Import a bundle from <file> or stdin (-); --replace overwrites a lineage match (kills it if live); --cwd overrides the bundle's recorded working directory; --info prints the bundle's meta without importing",
       "  hydra-acp extensions list                   List configured extensions and live state",
       "  hydra-acp extensions add <name> [opts]      Add an extension to config",
       "  hydra-acp extensions remove <name>          Remove an extension from config",