@hydra-acp/cli 0.1.7 → 0.1.9

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) {
@@ -45,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
@@ -149,6 +174,9 @@ async function loadConfig() {
   daemon.authToken = token;
   return HydraConfig.parse(raw);
 }
+async function loadConfigReadOnly() {
+  return HydraConfigReadOnly.parse(await readConfigFile());
+}
 async function ensureConfig() {
   if (!await loadAuthToken()) {
     const token = generateAuthToken();
@@ -181,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";
@@ -197,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),
@@ -220,7 +257,14 @@ var init_config = __esm({
       // 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)
+      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({
@@ -256,9 +300,14 @@ var init_config = __esm({
       tui: TuiConfig.default({
         repaintThrottleMs: 1e3,
         maxScrollbackLines: 1e4,
-        mouse: true
+        mouse: true,
+        logMaxBytes: 5 * 1024 * 1024,
+        cwdColumnMaxWidth: 24
       })
     });
+    HydraConfigReadOnly = HydraConfig.extend({
+      daemon: DaemonConfig.omit({ authToken: true })
+    });
   }
 });
 
@@ -332,21 +381,33 @@ 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,
       MethodNotFound: -32601,
       InvalidParams: -32602,
       InternalError: -32603,
+      // -32001…-32003 reserved for RFD #533 attach semantics:
+      //   -32001 Session not found
+      //   -32002 Not authorised to attach
+      //   -32003 Session does not support multi-client attach
+      // We emit -32001 (matching); the other two are reserved for spec
+      // alignment even though we don't currently emit them (we bearer-auth
+      // at WS upgrade time and always support multi-client attach).
       SessionNotFound: -32001,
-      PermissionDenied: -32002,
-      AlreadyAttached: -32003,
+      NotAuthorisedToAttach: -32002,
+      MultiClientNotSupported: -32003,
       AgentNotInstalled: -32005,
-      BundleAlreadyImported: -32010
+      // Hydra-internal codes — outside the RFD's reserved range so they
+      // can't collide with future spec assignments.
+      BundleAlreadyImported: -32010,
+      PermissionDenied: -32011,
+      AlreadyAttached: -32012
     };
     InitializeParams = z3.object({
       protocolVersion: z3.number().optional(),
@@ -356,7 +417,12 @@ var init_types = __esm({
         version: z3.string().optional()
       }).optional()
     });
-    HistoryPolicy = z3.enum(["full", "pending_only", "none"]);
+    HistoryPolicy = z3.enum([
+      "full",
+      "pending_only",
+      "none",
+      "after_message"
+    ]);
     SessionNewParams = z3.object({
       cwd: z3.string(),
       agentId: z3.string().optional(),
@@ -372,6 +438,18 @@ var init_types = __esm({
     SessionAttachParams = z3.object({
       sessionId: z3.string(),
       historyPolicy: HistoryPolicy.default("full"),
+      // Required when historyPolicy is "after_message"; ignored otherwise.
+      // The proxy replays history entries strictly after the entry whose
+      // messageId matches this value. If the id isn't found in the buffer,
+      // the response.historyPolicy field surfaces "full" so the caller
+      // knows we fell back. Per RFD #533.
+      afterMessageId: z3.string().optional(),
+      // Caller-assigned opaque id (e.g. a UUID). When provided, the proxy
+      // echoes it in resolvedBy/sentBy and lifecycle events so other
+      // clients can disambiguate multiple instances of the same
+      // clientInfo.name. When omitted, the proxy assigns one and returns
+      // it in the response. Per RFD #533.
+      clientId: z3.string().optional(),
       clientInfo: z3.object({
         name: z3.string(),
         version: z3.string().optional()
@@ -528,6 +606,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) {
@@ -651,6 +736,9 @@ var init_hydra_commands = __esm({
 
 // src/core/session.ts
 import { customAlphabet } from "nanoid";
+function generateMessageId() {
+  return `m_${generateHydraId()}`;
+}
 function stripHydraSessionPrefix(id) {
   return id.startsWith(HYDRA_SESSION_PREFIX) ? id.slice(HYDRA_SESSION_PREFIX.length) : id;
 }
@@ -715,6 +803,97 @@ function extractAdvertisedCommands(params) {
   }
   return out;
 }
+function ensureMessageIdOnUpdate(method, params) {
+  if (method !== "session/update" || !params || typeof params !== "object") {
+    return params;
+  }
+  const p = params;
+  if (!p.update || typeof p.update !== "object" || Array.isArray(p.update)) {
+    return params;
+  }
+  const u = p.update;
+  if (typeof u.messageId === "string") {
+    return params;
+  }
+  return {
+    ...params,
+    update: { ...p.update, messageId: generateMessageId() }
+  };
+}
+function findMessageIdIndex(history, target) {
+  for (let i = 0; i < history.length; i++) {
+    const entry = history[i];
+    if (!entry || entry.method !== "session/update") {
+      continue;
+    }
+    const params = entry.params;
+    if (params?.update?.messageId === target) {
+      return i;
+    }
+  }
+  return -1;
+}
+function extractToolCallId(params) {
+  if (!params || typeof params !== "object") {
+    return void 0;
+  }
+  const toolCall = params.toolCall;
+  if (!toolCall || typeof toolCall !== "object") {
+    return void 0;
+  }
+  const id = toolCall.toolCallId;
+  return typeof id === "string" ? id : void 0;
+}
+function buildPermissionResolvedUpdate(args) {
+  const outcome = extractOutcome(args.result);
+  const update = {
+    sessionUpdate: "permission_resolved"
+  };
+  if (args.toolCallId !== void 0) {
+    update.toolCallId = args.toolCallId;
+  }
+  if (outcome) {
+    update.outcome = outcome;
+    if (outcome.kind === "selected" && typeof outcome.optionId === "string") {
+      update.chosenOptionId = outcome.optionId;
+    }
+  }
+  update.resolvedBy = buildResolvedBy(args.resolver);
+  return update;
+}
+function extractOutcome(result) {
+  if (!result || typeof result !== "object") {
+    return void 0;
+  }
+  const raw = result.outcome;
+  if (!raw || typeof raw !== "object") {
+    return void 0;
+  }
+  const kind = raw.kind;
+  if (typeof kind !== "string") {
+    return void 0;
+  }
+  const out = { kind };
+  const optionId = raw.optionId;
+  if (typeof optionId === "string") {
+    out.optionId = optionId;
+  }
+  const reason = raw.reason;
+  if (typeof reason === "string") {
+    out.reason = reason;
+  }
+  return out;
+}
+function buildResolvedBy(client) {
+  const out = { clientId: client.clientId };
+  if (client.clientInfo?.name) {
+    out.name = client.clientInfo.name;
+  }
+  if (client.clientInfo?.version) {
+    out.version = client.clientInfo.version;
+  }
+  return out;
+}
 function extractPromptText(prompt) {
   if (typeof prompt === "string") {
     return prompt;
@@ -739,7 +918,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";
@@ -748,8 +927,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;
@@ -791,11 +969,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
@@ -852,6 +1032,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;
@@ -919,6 +1101,30 @@ var init_session = __esm({
       get attachedCount() {
         return this.clients.size;
       }
+      // Roster of currently-attached clients, optionally excluding one
+      // clientId. Used by the daemon to populate connectedClients on the
+      // session/attach response (per RFD #533) — the freshly-attaching
+      // client wants to see who else is on the session but not itself in
+      // the list.
+      connectedClients(excludeClientId) {
+        const out = [];
+        for (const client of this.clients.values()) {
+          if (excludeClientId && client.clientId === excludeClientId) {
+            continue;
+          }
+          const entry = {
+            clientId: client.clientId
+          };
+          if (client.clientInfo?.name) {
+            entry.name = client.clientInfo.name;
+          }
+          if (client.clientInfo?.version) {
+            entry.version = client.clientInfo.version;
+          }
+          out.push(entry);
+        }
+        return out;
+      }
       // Wall-clock when the in-flight agent turn began, or undefined when
       // idle. Tracked in-memory by broadcastPromptReceived/broadcastTurnComplete
       // so the daemon can hand a fresh attacher mid-turn the right elapsed
@@ -950,10 +1156,12 @@ var init_session = __esm({
         };
       }
       // Register a client and (asynchronously) load the replay slice it
-      // should receive. Validation errors throw synchronously so callers
-      // can rely on either the registration being in effect or having
-      // thrown; the disk-load is the only async work.
-      attach(client, historyPolicy) {
+      // should receive. Returns both the slice to replay and the actual
+      // historyPolicy applied (which may differ from the requested one
+      // when after_message falls back to full). Validation errors throw
+      // synchronously so callers can rely on either the registration being
+      // in effect or having thrown; the disk-load is the only async work.
+      attach(client, historyPolicy, opts = {}) {
         if (this.closed) {
           throw withCode(
             new Error("session is closed"),
@@ -969,9 +1177,20 @@ var init_session = __esm({
         this.clients.set(client.clientId, client);
         this.updatedAt = Date.now();
         if (historyPolicy === "none" || historyPolicy === "pending_only") {
-          return Promise.resolve([]);
+          return Promise.resolve({ entries: [], appliedPolicy: historyPolicy });
         }
-        return this.getHistorySnapshot();
+        return this.loadReplay(historyPolicy, opts);
+      }
+      async loadReplay(historyPolicy, opts) {
+        const all = await this.getHistorySnapshot();
+        if (historyPolicy === "after_message") {
+          const cutoff = opts.afterMessageId ? findMessageIdIndex(all, opts.afterMessageId) : -1;
+          if (cutoff < 0) {
+            return { entries: all, appliedPolicy: "full" };
+          }
+          return { entries: all.slice(cutoff + 1), appliedPolicy: "after_message" };
+        }
+        return { entries: all, appliedPolicy: "full" };
       }
       // Dispatch in-flight permission requests to a freshly-attached
       // client. Called by the daemon's WS handler *after* it finishes
@@ -983,8 +1202,39 @@ var init_session = __esm({
         }
       }
       detach(clientId) {
-        if (this.clients.delete(clientId)) {
-          this.updatedAt = Date.now();
+        const leaving = this.clients.get(clientId);
+        if (!leaving) {
+          return;
+        }
+        this.clients.delete(clientId);
+        this.updatedAt = Date.now();
+        this.broadcastClientDisconnected(leaving);
+      }
+      // Notify remaining attached clients that a peer just left, per
+      // RFD #533. Fires for both explicit session/detach and ws-close
+      // teardown (acp-ws calls Session.detach() in both paths). The
+      // notification is broadcast (not recorded) — peer presence is
+      // transient, not part of conversation history.
+      broadcastClientDisconnected(client) {
+        const info = {
+          clientId: client.clientId
+        };
+        if (client.clientInfo?.name) {
+          info.name = client.clientInfo.name;
+        }
+        if (client.clientInfo?.version) {
+          info.version = client.clientInfo.version;
+        }
+        const update = {
+          sessionUpdate: "client_disconnected",
+          client: info,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        for (const peer of this.clients.values()) {
+          void peer.connection.notify("session/update", {
+            sessionId: this.sessionId,
+            update
+          }).catch(() => void 0);
         }
       }
       async prompt(clientId, params) {
@@ -1037,6 +1287,7 @@ var init_session = __esm({
             sessionId: this.sessionId,
             update: {
               sessionUpdate: "prompt_received",
+              messageId: generateMessageId(),
               prompt: promptParams.prompt,
               sentBy
             }
@@ -1062,7 +1313,8 @@ var init_session = __esm({
       broadcastTurnComplete(originatorClientId, response) {
         const stopReason = response && typeof response === "object" && "stopReason" in response && typeof response.stopReason === "string" ? response.stopReason : void 0;
         const update = {
-          sessionUpdate: "turn_complete"
+          sessionUpdate: "turn_complete",
+          messageId: generateMessageId()
         };
         if (stopReason !== void 0) {
           update.stopReason = stopReason;
@@ -1679,10 +1931,11 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       recordAndBroadcast(method, params, excludeClientId) {
         const rewritten = this.rewriteForClient(params);
         const recordable = !isStateUpdate(method, rewritten);
+        const broadcast = recordable ? ensureMessageIdOnUpdate(method, rewritten) : rewritten;
         if (recordable) {
           const entry = {
             method,
-            params: rewritten,
+            params: broadcast,
             recordedAt: Date.now()
           };
           this.lastRecordedAt = entry.recordedAt;
@@ -1690,9 +1943,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
               );
             }
@@ -1710,7 +1963,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
           if (excludeClientId && client.clientId === excludeClientId) {
             continue;
           }
-          void client.connection.notify(method, rewritten).catch(() => void 0);
+          void client.connection.notify(method, broadcast).catch(() => void 0);
         }
       }
       async handlePermissionRequest(params) {
@@ -1722,11 +1975,13 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
           );
         }
         const clientParams = this.rewriteForClient(params);
+        const toolCallId = extractToolCallId(clientParams);
         return new Promise((resolve5, reject) => {
           let settled = false;
           const outbound = [];
           const entry = { addClient: sendTo };
           this.inFlightPermissions.add(entry);
+          const sessionId = this.sessionId;
           const settle = (fn) => {
             if (settled) {
               return;
@@ -1739,22 +1994,25 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
             if (settled) {
               return;
             }
-            const { id, response } = client.connection.requestWithId(
+            const response = client.connection.request(
               "session/request_permission",
               clientParams
             );
-            outbound.push({ client, id });
+            outbound.push({ client });
             void response.then((result) => {
               settle(() => {
+                const update = buildPermissionResolvedUpdate({
+                  toolCallId,
+                  result,
+                  resolver: client
+                });
                 for (const o of outbound) {
                   if (o.client.clientId === client.clientId) {
                     continue;
                   }
-                  void o.client.connection.notify("session/permission_resolved", {
-                    ...clientParams,
-                    requestId: o.id,
-                    resolvedBy: client.clientId,
-                    result
+                  void o.client.connection.notify("session/update", {
+                    sessionId,
+                    update
                   }).catch(() => void 0);
                 }
                 resolve5(result);
@@ -1809,9 +2067,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 {
@@ -1855,7 +2291,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" : "");
 }
@@ -1867,6 +2303,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 = [];
@@ -1945,7 +2488,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)) {
@@ -1972,7 +2515,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"],
     {
@@ -2020,8 +2563,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;
   }
@@ -2058,10 +2601,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) {
@@ -2077,6 +2620,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))
   };
 }
@@ -2125,7 +2669,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),
@@ -2134,20 +2678,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) {
@@ -2175,11 +2717,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",
@@ -2191,14 +2734,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);
@@ -2237,9 +2779,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(
@@ -2268,9 +2811,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();
@@ -2317,23 +2860,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 {
@@ -2343,6 +2903,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`, {
@@ -2351,7 +2916,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(() => ({}));
@@ -2374,6 +2943,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) {
@@ -2400,6 +3005,7 @@ var init_sessions = __esm({
   "src/cli/commands/sessions.ts"() {
     "use strict";
     init_config();
+    init_bundle();
     init_session_row();
   }
 });
@@ -2734,12 +3340,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;
@@ -2750,6 +3359,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);
@@ -2757,8 +3367,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()));
@@ -2766,6 +3376,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;
@@ -2828,6 +3456,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;
@@ -2894,8 +3529,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) {
@@ -2992,7 +3627,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);
@@ -3097,13 +3762,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;
@@ -3111,14 +3797,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 = [];
@@ -3130,9 +3816,24 @@ 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 (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) {
@@ -3180,6 +3881,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;
@@ -3242,6 +3971,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);
   }
@@ -3255,17 +3990,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 = [];
@@ -3290,32 +4088,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;
     }
@@ -3323,7 +4122,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);
@@ -3331,34 +4130,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) {
@@ -3376,6 +4184,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`;
@@ -3472,6 +4295,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":
@@ -3484,11 +4311,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;
@@ -3532,6 +4360,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
@@ -3549,10 +4383,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: "?" };
@@ -3615,6 +4469,10 @@ 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);
         if (this.mouseEnabled) {
@@ -3695,7 +4553,7 @@ var init_screen = __esm({
         this.streamingActive = false;
         this.lines.push(...lines);
         this.trackLines(lines);
-        this.adjustScrollForLineChange(lines.length);
+        this.adjustScrollForRowChange(this.wrappedRowsOfMany(lines));
         this.trimScrollback();
         this.scheduleRepaint();
       }
@@ -3703,19 +4561,40 @@ var init_screen = __esm({
         this.streamingActive = false;
         this.lines.push(line);
         this.trackLine(line);
-        this.adjustScrollForLineChange(1);
+        this.adjustScrollForRowChange(this.wrappedRowsOf(line));
         this.trimScrollback();
         this.scheduleRepaint();
       }
       // When scrolled away from the bottom, shift scrollOffset to keep the
       // user's visible window anchored on the same content as the lines
-      // array grows. Without this, every new line silently scrolls the view
-      // up by one row — the original bug the user reported.
-      adjustScrollForLineChange(delta) {
+      // array grows. `delta` is measured in WRAPPED ROWS — the same unit
+      // scrollOffset uses — so a single logical line that wraps to N rows
+      // contributes N, not 1. Counting logical lines here was the original
+      // bug: any wrapped append would slide the view up by N−1 rows.
+      adjustScrollForRowChange(delta) {
         if (this.scrollOffset > 0 && delta !== 0) {
           this.scrollOffset = Math.max(0, this.scrollOffset + delta);
         }
       }
+      // Wrapped-row count for a single line at the current terminal width.
+      // Reuses the wrap cache, and synchronises the cache's width with the
+      // current width so a resize that hasn't yet been picked up by
+      // drawScrollback can't return stale counts during an insert.
+      wrappedRowsOf(line) {
+        const w = this.term.width;
+        if (this.wrapCacheWidth !== w) {
+          this.wrapCache.clear();
+          this.wrapCacheWidth = w;
+        }
+        return this.wrapOne(line, w).length;
+      }
+      wrappedRowsOfMany(lines) {
+        let n = 0;
+        for (const line of lines) {
+          n += this.wrappedRowsOf(line);
+        }
+        return n;
+      }
       trackLine(line) {
         this.lineIds.set(line, this.nextLineId++);
       }
@@ -3765,12 +4644,14 @@ var init_screen = __esm({
         }
         const existing = this.keyedBlocks.get(key);
         let touchesEnd = false;
-        let scrollDelta = 0;
+        let rowDelta = 0;
         if (existing) {
           const oldEnd = existing.start + existing.count;
           touchesEnd = oldEnd >= this.lines.length;
+          const oldRows = this.wrappedRowsOfMany(
+            this.lines.slice(existing.start, oldEnd)
+          );
           const delta = newLines.length - existing.count;
-          scrollDelta = delta;
           const removed = this.lines.splice(
             existing.start,
             existing.count,
@@ -3788,20 +4669,21 @@ var init_screen = __esm({
               }
             }
           }
+          rowDelta = this.wrappedRowsOfMany(newLines) - oldRows;
         } else {
           touchesEnd = true;
-          scrollDelta = newLines.length;
           this.keyedBlocks.set(key, {
             start: this.lines.length,
             count: newLines.length
           });
           this.lines.push(...newLines);
           this.trackLines(newLines);
+          rowDelta = this.wrappedRowsOfMany(newLines);
         }
         if (touchesEnd) {
           this.streamingActive = false;
         }
-        this.adjustScrollForLineChange(scrollDelta);
+        this.adjustScrollForRowChange(rowDelta);
         this.trimScrollback();
         this.scheduleRepaint();
       }
@@ -3815,12 +4697,14 @@ var init_screen = __esm({
         }
         const fragments = text.split("\n");
         const [first, ...rest] = fragments;
-        let added = 0;
+        let rowDelta = 0;
         if (this.streamingActive && this.lines.length > 0) {
           const last = this.lines[this.lines.length - 1];
           if (last) {
+            const before = this.wrappedRowsOf(last);
             this.forgetLine(last);
             last.body += first ?? "";
+            rowDelta += this.wrappedRowsOf(last) - before;
           }
         } else {
           if (this.lines.length > 0) {
@@ -3830,7 +4714,7 @@ var init_screen = __esm({
               const sep = { body: "" };
               this.lines.push(sep);
               this.trackLine(sep);
-              added += 1;
+              rowDelta += this.wrappedRowsOf(sep);
             }
           }
           const initial = {
@@ -3843,7 +4727,7 @@ var init_screen = __esm({
           }
           this.lines.push(initial);
           this.trackLine(initial);
-          added += 1;
+          rowDelta += this.wrappedRowsOf(initial);
         }
         const continuationPrefix = " ".repeat(prefix.length);
         for (const piece of rest) {
@@ -3854,10 +4738,10 @@ var init_screen = __esm({
           };
           this.lines.push(cont);
           this.trackLine(cont);
-          added += 1;
+          rowDelta += this.wrappedRowsOf(cont);
         }
         this.streamingActive = true;
-        this.adjustScrollForLineChange(added);
+        this.adjustScrollForRowChange(rowDelta);
         this.trimScrollback();
         this.scheduleRepaint();
       }
@@ -3889,6 +4773,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();
@@ -3916,6 +4852,9 @@ var init_screen = __esm({
           return;
         }
         const touchesEnd = existing.start + existing.count >= this.lines.length;
+        const removedRows = this.wrappedRowsOfMany(
+          this.lines.slice(existing.start, existing.start + existing.count)
+        );
         const removed = this.lines.splice(existing.start, existing.count);
         for (const line of removed) {
           this.forgetLine(line);
@@ -3929,7 +4868,7 @@ var init_screen = __esm({
         if (touchesEnd) {
           this.streamingActive = false;
         }
-        this.adjustScrollForLineChange(-existing.count);
+        this.adjustScrollForRowChange(-removedRows);
         this.scheduleRepaint();
       }
       redraw() {
@@ -4014,7 +4953,7 @@ var init_screen = __esm({
         this.lines.push(sep);
         this.trackLine(sep);
         this.streamingActive = false;
-        this.adjustScrollForLineChange(1);
+        this.adjustScrollForRowChange(this.wrappedRowsOf(sep));
         this.trimScrollback();
         this.scheduleRepaint();
       }
@@ -4070,6 +5009,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) {
@@ -4079,6 +5021,9 @@ var init_screen = __esm({
         this.repaint();
       }
       scrollToBottom() {
+        if (this.scrollbackSearch !== null) {
+          this.acceptScrollbackSearch();
+        }
         if (this.scrollOffset === 0) {
           return;
         }
@@ -4086,6 +5031,9 @@ var init_screen = __esm({
         this.repaint();
       }
       scrollToTop() {
+        if (this.scrollbackSearch !== null) {
+          this.acceptScrollbackSearch();
+        }
         const max = this.maxScrollOffset();
         if (this.scrollOffset === max) {
           return;
@@ -4093,6 +5041,221 @@ var init_screen = __esm({
         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);
       }
@@ -4215,8 +5378,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);
           }
         });
       }
@@ -4247,14 +5410,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);
             }
           });
         }
@@ -4454,7 +5626,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";
@@ -4481,6 +5655,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() {
@@ -4496,6 +5680,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();
@@ -4582,8 +5771,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 = {
@@ -4602,6 +5793,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) {
@@ -4609,13 +5809,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;
@@ -4630,6 +5842,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;
   }
 });
@@ -4653,6 +5866,14 @@ var init_input = __esm({
       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 = [];
@@ -4672,7 +5893,8 @@ var init_input = __esm({
           col: this.col,
           planMode: this.planMode,
           historyIndex: this.historyIndex,
-          queueIndex: this.queueIndex
+          queueIndex: this.queueIndex,
+          historySearchQuery: this.historySearch?.query ?? null
         };
       }
       setTurnRunning(running) {
@@ -4682,6 +5904,7 @@ 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
@@ -4710,8 +5933,44 @@ var init_input = __esm({
         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 [];
@@ -4789,6 +6048,10 @@ var init_input = __esm({
             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 [];
@@ -4824,6 +6087,7 @@ var init_input = __esm({
         this.historyIndex = -1;
         this.queueIndex = -1;
         this.savedDraft = null;
+        this.historySearch = null;
       }
       insertChar(ch) {
         if (ch.length === 0) {
@@ -5051,6 +6315,143 @@ var init_input = __esm({
           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 [];
+      }
+      // ^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) {
@@ -5790,6 +7191,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 = {};
@@ -5810,7 +7212,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}`];
@@ -5897,13 +7299,25 @@ async function runSession(term, config, opts, exitHint) {
     } else if (event?.kind === "turn-complete") {
       adjustPendingTurns(-1);
     }
+    if (rawTag === "permission_resolved") {
+      handlePermissionResolved(update);
+      return;
+    }
     appendRender(event);
     maybeDismissPermissionByToolUpdate(update);
   });
-  conn.onNotification("session/permission_resolved", (params) => {
-    const p = params ?? {};
-    dismissPermissionExternally(p.toolCall?.toolCallId, p.result);
-  });
+  const handlePermissionResolved = (update) => {
+    const u = update ?? {};
+    const toolCallId = typeof u.toolCallId === "string" ? u.toolCallId : void 0;
+    let outcome;
+    if (u.outcome && typeof u.outcome === "object") {
+      outcome = u.outcome;
+    } else if (typeof u.chosenOptionId === "string") {
+      outcome = { kind: "selected", optionId: u.chosenOptionId };
+    }
+    const result = outcome ? { outcome } : void 0;
+    dismissPermissionExternally(toolCallId, result);
+  };
   let pendingPermission = null;
   const dismissPermissionExternally = (toolCallId, result) => {
     if (!pendingPermission) {
@@ -5997,12 +7411,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 {
@@ -6051,7 +7465,7 @@ async function runSession(term, config, opts, exitHint) {
     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;
@@ -6096,6 +7510,9 @@ async function runSession(term, config, opts, exitHint) {
         if (exitConfirmation && tryHandleExitConfirmKey(ev)) {
           continue;
         }
+        if (tryHandleScrollbackSearchKey(ev)) {
+          continue;
+        }
         if (tryHandleCompletionKey(ev)) {
           continue;
         }
@@ -6105,6 +7522,9 @@ async function runSession(term, config, opts, exitHint) {
         }
       }
       refreshCompletions();
+      screen.setBannerSearchIndicator(
+        dispatcher.state().historySearchQuery
+      );
       screen.refreshPrompt();
     }
   });
@@ -6167,6 +7587,55 @@ async function runSession(term, config, opts, exitHint) {
     dispatcher.replaceFirstLine(next);
     return true;
   };
+  const tryHandleScrollbackSearchKey = (ev) => {
+    if (!screen.isScrollbackSearchActive()) {
+      if (ev.type === "key" && ev.name === "ctrl-r" && screen.isScrolledBack()) {
+        screen.enterScrollbackSearch();
+        screen.updateScrollbackSearchTerm("");
+        return true;
+      }
+      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 true;
+  };
   const tryHandlePermissionKey = (ev) => {
     if (!pendingPermission) {
       return false;
@@ -6437,6 +7906,10 @@ async function runSession(term, config, opts, exitHint) {
         toolsExpanded = !toolsExpanded;
         renderToolsBlock();
         return;
+      case "escalate-search":
+        screen.enterScrollbackSearch();
+        screen.updateScrollbackSearchTerm(effect.query);
+        return;
     }
   };
   const promptQueue = [];
@@ -6482,6 +7955,7 @@ async function runSession(term, config, opts, exitHint) {
         toolCallOrder.length = 0;
         toolsBlockStartedAt = null;
         toolsBlockEndedAt = null;
+        toolsBlockStopReason = null;
         toolsExpanded = false;
         screen.clearScrollback();
         return true;
@@ -6685,6 +8159,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;
@@ -6726,12 +8201,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) {
@@ -6743,12 +8223,14 @@ 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: pureThinking ? "tool-status-running" : "tool",
+        prefixStyle: pureThinking ? "tool-status-running" : frozenStyle,
         body: summary,
-        bodyStyle: pureThinking ? "tool-status-running" : "dim"
+        bodyStyle: pureThinking ? "tool-status-running" : frozenBodyStyle
       }
     ];
     for (const id of visibleIds) {
@@ -6762,6 +8244,7 @@ async function runSession(term, config, opts, exitHint) {
   const startToolsBlock = () => {
     toolsBlockStartedAt = Date.now();
     toolsBlockEndedAt = null;
+    toolsBlockStopReason = null;
     renderToolsBlock();
   };
   const recordToolCall = (id, title, status) => {
@@ -6786,6 +8269,7 @@ async function runSession(term, config, opts, exitHint) {
       if (toolsBlockStartedAt === null) {
         toolsBlockStartedAt = Date.now();
         toolsBlockEndedAt = null;
+        toolsBlockStopReason = null;
       }
       toolCallOrder.push(id);
     }
@@ -6887,6 +8371,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");
       }
@@ -6894,6 +8379,7 @@ async function runSession(term, config, opts, exitHint) {
       toolCallOrder.length = 0;
       toolsBlockStartedAt = null;
       toolsBlockEndedAt = null;
+      toolsBlockStopReason = null;
       toolsExpanded = false;
       screen.ensureSeparator();
     }
@@ -6937,12 +8423,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");
@@ -6960,12 +8448,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 {
@@ -6979,7 +8467,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]: {
@@ -7103,15 +8591,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";
@@ -7122,6 +8610,7 @@ var init_app = __esm({
     init_daemon_bootstrap();
     init_session();
     init_paths();
+    init_hydra_version();
     init_history();
     init_discovery();
     init_picker();
@@ -7131,7 +8620,7 @@ var init_app = __esm({
     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;
   }
 });
 
@@ -7148,9 +8637,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) {
@@ -7243,13 +8732,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";
@@ -7433,31 +8922,148 @@ function run(cmd, args) {
     const child = spawn(cmd, args, {
       stdio: ["ignore", "ignore", "inherit"]
     });
-    child.on("error", reject);
+    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/)`
+    );
+  }
+  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;
+    }
+    logSink2(`hydra-acp: installed ${args.agentId} to ${args.installDir}`);
+  } catch (err) {
+    await fsp2.rm(tempDir, { recursive: true, force: true }).catch(
+      () => void 0
+    );
+    throw err;
+  }
+}
+function runNpmInstall(args) {
+  return new Promise((resolve5, reject) => {
+    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("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;
@@ -7467,6 +9073,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()
 });
@@ -7630,9 +9240,23 @@ async function planSpawn(agent, callerArgs = []) {
   if (agent.distribution.npx) {
     const npx = agent.distribution.npx;
     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: ["-y", npx.package, ...tail],
+      command: binPath,
+      args: tail,
       env: npx.env ?? {}
     };
   }
@@ -7667,12 +9291,8 @@ async function planSpawn(agent, callerArgs = []) {
   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();
@@ -7753,17 +9373,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");
     }
@@ -7771,22 +9396,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"]
@@ -7803,196 +9442,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;
@@ -8094,8 +9570,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;
   }
@@ -8140,6 +9616,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 {
@@ -8147,7 +9624,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 ?? {};
   }
@@ -8159,6 +9637,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.
@@ -8182,6 +9661,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);
@@ -8233,11 +9713,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(
@@ -8249,10 +9734,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,
@@ -8266,6 +9753,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
@@ -8292,15 +9780,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,
@@ -8310,6 +9799,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,
@@ -8323,6 +9813,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.
@@ -8343,9 +9843,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",
@@ -8625,7 +10125,8 @@ var SessionManager = class {
       await this.writeImportedRecord({
         sessionId: existing.sessionId,
         bundle,
-        preservedCreatedAt: existing.createdAt
+        preservedCreatedAt: existing.createdAt,
+        cwd: opts.cwd
       });
       return {
         sessionId: existing.sessionId,
@@ -8634,7 +10135,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,
@@ -8664,7 +10169,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,
@@ -8857,7 +10362,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) {
@@ -8878,7 +10383,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;
@@ -8887,10 +10392,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;
@@ -8911,7 +10416,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) {
@@ -9120,7 +10625,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") {
@@ -9132,10 +10637,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;
@@ -9158,7 +10663,7 @@ var ExtensionManager = class {
           }
         }
       }
-      await fsp2.unlink(pidPath).catch(() => void 0);
+      await fsp3.unlink(pidPath).catch(() => void 0);
     }
   }
   spawn(entry, attempt) {
@@ -9171,7 +10676,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(
@@ -9199,7 +10704,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
@@ -9221,7 +10726,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
@@ -9246,7 +10751,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(
@@ -9304,6 +10809,7 @@ function withCode2(err, code) {
 
 // src/daemon/server.ts
 init_paths();
+init_hydra_version();
 
 // src/daemon/auth.ts
 var BEARER_PREFIX = "Bearer ";
@@ -9359,78 +10865,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;
@@ -9501,12 +10939,12 @@ 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(
       "Content-Disposition",
-      `attachment; filename="hydra-${id}-${stamp}.hydra"`
+      `attachment; filename="${id}-${stamp}.hydra"`
     );
     reply.code(200).send(bundle);
   });
@@ -9516,6 +10954,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);
@@ -9528,7 +10974,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) {
@@ -9769,8 +11216,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({
@@ -9864,15 +11310,20 @@ function registerAcpWsEndpoint(app, deps) {
         connection,
         session,
         state,
-        params.clientInfo
+        params.clientInfo,
+        params.clientId
+      );
+      const { entries: replay, appliedPolicy } = await session.attach(
+        client,
+        params.historyPolicy,
+        { afterMessageId: params.afterMessageId }
       );
-      const replay = await session.attach(client, params.historyPolicy);
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
         clientId: client.clientId
       });
       app.log.info(
-        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} replayed=${replay.length}`
+        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} requestedPolicy=${params.historyPolicy} appliedPolicy=${appliedPolicy} replayed=${replay.length}`
       );
       for (const note of replay) {
         await connection.notify(note.method, note.params);
@@ -9880,6 +11331,13 @@ function registerAcpWsEndpoint(app, deps) {
       session.replayPendingPermissions(client);
       return {
         sessionId: session.sessionId,
+        clientId: client.clientId,
+        connectedClients: session.connectedClients(client.clientId),
+        // appliedPolicy surfaces whether after_message fell back to full
+        // (because afterMessageId wasn't found in history) — RFD #533
+        // says the response.historyPolicy should reflect what actually
+        // ran, not what was asked for.
+        historyPolicy: appliedPolicy,
         replayed: replay.length,
         _meta: buildResponseMeta(session)
       };
@@ -9895,7 +11353,7 @@ function registerAcpWsEndpoint(app, deps) {
       const session = deps.manager.get(params.sessionId);
       session?.detach(att.clientId);
       state.attached.delete(params.sessionId);
-      return { detached: true };
+      return { sessionId: params.sessionId, status: "detached" };
     });
     connection.onRequest("session/list", async (raw) => {
       const params = SessionListParams.parse(raw ?? {});
@@ -9968,7 +11426,7 @@ function registerAcpWsEndpoint(app, deps) {
         session = await deps.manager.resurrect(fromDisk);
       }
       const client = bindClientToSession(connection, session, state);
-      const replay = await session.attach(client, "pending_only");
+      const { entries: replay } = await session.attach(client, "pending_only");
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
         clientId: client.clientId
@@ -10033,8 +11491,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
@@ -10062,25 +11520,24 @@ function buildInitializeResult() {
     ]
   };
 }
-function bindClientToSession(connection, session, state, clientInfo) {
+function bindClientToSession(connection, session, state, clientInfo, callerClientId) {
   void state;
   void session;
   return {
-    clientId: `cli_${nanoid2(8)}`,
+    clientId: callerClientId ?? `cli_${nanoid2(8)}`,
     connection,
     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
   );
@@ -10089,12 +11546,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) {
@@ -10106,12 +11569,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
@@ -10130,8 +11595,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,
@@ -10157,9 +11622,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 {
@@ -10198,13 +11664,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") {
@@ -10215,14 +11681,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;
     }
@@ -10230,14 +11696,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);
@@ -10264,7 +11730,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 = "";
@@ -10433,7 +11899,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;
@@ -10458,7 +11924,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();
@@ -10654,11 +12120,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 }
@@ -11001,10 +12467,22 @@ var SessionTracker = class {
   contexts = /* @__PURE__ */ new Map();
   pending = /* @__PURE__ */ new Map();
   pendingPermissions = /* @__PURE__ */ new Map();
+  // Secondary index — same entries as `pendingPermissions`, keyed by the
+  // tool call id from the request_permission params. Used to correlate
+  // the daemon's `session/update`/`permission_resolved` events back to the
+  // pending downstream request, since per-recipient JSON-RPC ids are no
+  // longer carried on the wire.
+  pendingPermissionsByToolCall = /* @__PURE__ */ new Map();
+  // Most recent messageId observed on a session/update from the daemon
+  // (prompt_received / turn_complete), keyed by sessionId. Used by the
+  // reconnect-replay path to send historyPolicy:"after_message" with
+  // afterMessageId so the daemon only replays the delta we missed.
+  lastMessageIds = /* @__PURE__ */ new Map();
   observeFromClient(msg) {
     if (isResponse2(msg)) {
-      if (this.pendingPermissions.has(msg.id)) {
-        this.pendingPermissions.delete(msg.id);
+      const existing = this.pendingPermissions.get(msg.id);
+      if (existing) {
+        this.deletePendingPermission(existing);
       }
       return;
     }
@@ -11031,16 +12509,34 @@ var SessionTracker = class {
     }
   }
   observeFromServer(msg) {
+    if (!isRequest(msg) && !isResponse2(msg) && "method" in msg) {
+      if (msg.method === "session/update") {
+        const params = msg.params ?? {};
+        const sessionId2 = typeof params.sessionId === "string" ? params.sessionId : void 0;
+        const messageId = typeof params.update?.messageId === "string" ? params.update.messageId : void 0;
+        if (sessionId2 && messageId) {
+          this.lastMessageIds.set(sessionId2, messageId);
+        }
+      }
+      return;
+    }
     if (isRequest(msg)) {
       if (msg.method === "session/request_permission") {
         const params = msg.params ?? {};
         const sessionId2 = typeof params.sessionId === "string" ? params.sessionId : void 0;
         if (sessionId2) {
-          this.pendingPermissions.set(msg.id, {
+          const toolCall = params.toolCall;
+          const toolCallId = toolCall && typeof toolCall.toolCallId === "string" ? toolCall.toolCallId : void 0;
+          const entry = {
             requestId: msg.id,
             sessionId: sessionId2,
+            toolCallId,
             params
-          });
+          };
+          this.pendingPermissions.set(msg.id, entry);
+          if (toolCallId) {
+            this.pendingPermissionsByToolCall.set(toolCallId, entry);
+          }
         }
       }
       return;
@@ -11088,6 +12584,14 @@ var SessionTracker = class {
   }
   forget(sessionId) {
     this.contexts.delete(sessionId);
+    this.lastMessageIds.delete(sessionId);
+  }
+  // Latest messageId observed for `sessionId`, or undefined if we
+  // haven't seen one (no prompt_received/turn_complete has flowed
+  // through yet). Used by reconnect-replay to issue
+  // historyPolicy:"after_message" with afterMessageId.
+  lastMessageId(sessionId) {
+    return this.lastMessageIds.get(sessionId);
   }
   clearPending() {
     this.pending.clear();
@@ -11095,15 +12599,29 @@ var SessionTracker = class {
   takePendingPermissions() {
     const out = [...this.pendingPermissions.values()];
     this.pendingPermissions.clear();
+    this.pendingPermissionsByToolCall.clear();
     return out;
   }
   takePendingPermission(requestId) {
     const found = this.pendingPermissions.get(requestId);
     if (found) {
-      this.pendingPermissions.delete(requestId);
+      this.deletePendingPermission(found);
+    }
+    return found;
+  }
+  takePendingPermissionByToolCall(toolCallId) {
+    const found = this.pendingPermissionsByToolCall.get(toolCallId);
+    if (found) {
+      this.deletePendingPermission(found);
     }
     return found;
   }
+  deletePendingPermission(entry) {
+    this.pendingPermissions.delete(entry.requestId);
+    if (entry.toolCallId) {
+      this.pendingPermissionsByToolCall.delete(entry.toolCallId);
+    }
+  }
 };
 function isRequest(msg) {
   return "method" in msg && "id" in msg && msg.id !== void 0;
@@ -11139,7 +12657,7 @@ async function runShim(opts) {
 `
       );
       for (const ctx of contexts) {
-        await replayAttach(upstream, ctx);
+        await replayAttach(upstream, ctx, tracker.lastMessageId(ctx.sessionId));
       }
     }
   });
@@ -11198,25 +12716,47 @@ function wireShim({
   });
 }
 function maybeReplyToResolvedPermission(msg, tracker, downstream) {
-  if (!isPermissionResolvedNotification(msg)) {
+  const update = extractPermissionResolvedUpdate(msg);
+  if (!update) {
     return;
   }
-  const params = msg.params ?? {};
-  if (params.requestId === void 0) {
+  const toolCallId = typeof update.toolCallId === "string" ? update.toolCallId : void 0;
+  if (!toolCallId) {
     return;
   }
-  const pending = tracker.takePendingPermission(params.requestId);
+  const pending = tracker.takePendingPermissionByToolCall(toolCallId);
   if (!pending) {
     return;
   }
+  const outcome = reconstructOutcome(update);
   void downstream.send({
     jsonrpc: "2.0",
     id: pending.requestId,
-    result: params.result ?? null
+    result: outcome ? { outcome } : null
   }).catch(() => void 0);
 }
-function isPermissionResolvedNotification(msg) {
-  return "method" in msg && msg.method === "session/permission_resolved" && !("id" in msg && msg.id !== void 0);
+function extractPermissionResolvedUpdate(msg) {
+  if (!isSessionUpdateNotification(msg)) {
+    return void 0;
+  }
+  const params = msg.params ?? {};
+  const update = params.update;
+  if (!update || typeof update !== "object" || update.sessionUpdate !== "permission_resolved") {
+    return void 0;
+  }
+  return update;
+}
+function isSessionUpdateNotification(msg) {
+  return "method" in msg && msg.method === "session/update" && !("id" in msg && msg.id !== void 0);
+}
+function reconstructOutcome(update) {
+  if (update.outcome && typeof update.outcome === "object") {
+    return update.outcome;
+  }
+  if (typeof update.chosenOptionId === "string") {
+    return { kind: "selected", optionId: update.chosenOptionId };
+  }
+  return void 0;
 }
 async function cancelPendingPermissions(tracker, downstream) {
   const pendings = tracker.takePendingPermissions();
@@ -11228,21 +12768,26 @@ async function cancelPendingPermissions(tracker, downstream) {
 `
   );
   for (const pending of pendings) {
-    const params = {
-      ...pending.params,
-      resolvedBy: "hydra-acp",
-      result: {
-        outcome: { kind: "cancelled", reason: "daemon-disconnected" }
-      }
+    const sessionId = typeof pending.params.sessionId === "string" ? pending.params.sessionId : void 0;
+    if (!sessionId) {
+      continue;
+    }
+    const update = {
+      sessionUpdate: "permission_resolved",
+      outcome: { kind: "cancelled", reason: "daemon-disconnected" },
+      resolvedBy: { clientId: "hydra-acp" }
     };
+    if (pending.toolCallId) {
+      update.toolCallId = pending.toolCallId;
+    }
     await downstream.send({
       jsonrpc: "2.0",
-      method: "session/permission_resolved",
-      params
+      method: "session/update",
+      params: { sessionId, update }
     }).catch(() => void 0);
   }
 }
-async function replayAttach(stream, ctx) {
+async function replayAttach(stream, ctx, afterMessageId) {
   const resumeHints = {
     upstreamSessionId: ctx.upstreamSessionId,
     agentId: ctx.agentId,
@@ -11254,19 +12799,21 @@ async function replayAttach(stream, ctx) {
   if (ctx.agentArgs && ctx.agentArgs.length > 0) {
     resumeHints.agentArgs = ctx.agentArgs;
   }
+  const params = {
+    sessionId: ctx.sessionId,
+    _meta: { "hydra-acp": { resume: resumeHints } }
+  };
+  if (afterMessageId) {
+    params.historyPolicy = "after_message";
+    params.afterMessageId = afterMessageId;
+  } else {
+    params.historyPolicy = "pending_only";
+  }
   const request = {
     jsonrpc: "2.0",
     id: `resume-${ctx.sessionId}-${Date.now()}`,
     method: "session/attach",
-    params: {
-      sessionId: ctx.sessionId,
-      historyPolicy: "pending_only",
-      _meta: {
-        "hydra-acp": {
-          resume: resumeHints
-        }
-      }
-    }
+    params
   };
   try {
     const resp = await stream.request(request);
@@ -11423,8 +12970,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") {
@@ -11433,8 +12980,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;
       }
@@ -11537,9 +13087,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 {
@@ -11566,11 +13116,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",