@hydra-acp/cli 0.1.2 → 0.1.4

package/dist/cli.js

@@ -17,6 +17,11 @@ function hydraHome() {
   if (override && override.length > 0) {
     return path.resolve(override);
   }
+  if (process.env.VITEST) {
+    throw new Error(
+      "HYDRA_ACP_HOME is unset under VITEST; vitest.setup.ts must run first"
+    );
+  }
   return path.join(os.homedir(), ".hydra-acp");
 }
 var ROOT_ENV, paths;
@@ -43,7 +48,8 @@ var init_paths = __esm({
       extensionsDir: () => path.join(hydraHome(), "extensions"),
       extensionLogFile: (name) => path.join(hydraHome(), "extensions", `${name}.log`),
       extensionPidFile: (name) => path.join(hydraHome(), "extensions", `${name}.pid`),
-      tuiHistoryFile: () => path.join(hydraHome(), "tui-history")
+      tuiHistoryFile: (id) => path.join(hydraHome(), "sessions", id, "prompt-history"),
+      tuiLogFile: () => path.join(hydraHome(), "tui.log")
     };
   }
 });
@@ -83,8 +89,7 @@ async function ensureConfig() {
     if (e.code !== "ENOENT") {
       throw err;
     }
-    const config = defaultConfig();
-    await writeConfig(config);
+    const config = await writeMinimalInitConfig();
     process.stderr.write(
       `hydra-acp: initialized ${paths.config()} with a fresh auth token.
 `
@@ -93,9 +98,23 @@ async function ensureConfig() {
   }
   return loadConfig();
 }
-async function writeConfig(config) {
+async function writeMinimalInitConfig(authToken) {
+  const token = authToken ?? generateAuthToken();
+  const minimal = { daemon: { authToken: token } };
   await fs.mkdir(paths.home(), { recursive: true });
-  await fs.writeFile(paths.config(), JSON.stringify(config, null, 2) + "\n", {
+  await fs.writeFile(paths.config(), JSON.stringify(minimal, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+  return HydraConfig.parse(minimal);
+}
+async function updateConfigField(mutate) {
+  const path6 = paths.config();
+  const text = await fs.readFile(path6, "utf8");
+  const raw = JSON.parse(text);
+  mutate(raw);
+  HydraConfig.parse(raw);
+  await fs.writeFile(path6, JSON.stringify(raw, null, 2) + "\n", {
     encoding: "utf8",
     mode: 384
   });
@@ -109,13 +128,6 @@ function generateAuthToken() {
   }
   return `hydra_token_${hex}`;
 }
-function defaultConfig() {
-  return HydraConfig.parse({
-    daemon: {
-      authToken: generateAuthToken()
-    }
-  });
-}
 function expandHome(p) {
   if (p === "~" || p === "$HOME") {
     return homedir2();
@@ -144,7 +156,7 @@ 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(30)
+      sessionIdleTimeoutSeconds: z.number().int().nonnegative().default(3600)
     });
     RegistryConfig = z.object({
       url: z.string().url().default(REGISTRY_URL_DEFAULT),
@@ -157,7 +169,11 @@ var init_config = __esm({
       // /clear, ^L, resize — bypass this throttle. Default 1000 (1 Hz) keeps
       // CPU low during heavy streaming; bump to 250 for 4 Hz, 100 for ~10 Hz,
       // or 0 to disable throttling entirely.
-      repaintThrottleMs: z.number().int().nonnegative().default(1e3)
+      repaintThrottleMs: z.number().int().nonnegative().default(1e3),
+      // Cap on logical lines retained in the in-memory scrollback render
+      // buffer. Oldest lines are dropped on overflow. The on-disk session
+      // history is unaffected; this only bounds the TUI's local view buffer.
+      maxScrollbackLines: z.number().int().positive().default(1e4)
     });
     ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
     ExtensionBody = z.object({
@@ -182,7 +198,7 @@ var init_config = __esm({
       // recency and truncated to this count. `--all` overrides in the CLI.
       sessionListColdLimit: z.number().int().nonnegative().default(20),
       extensions: z.record(ExtensionName, ExtensionBody).default({}),
-      tui: TuiConfig.default({ repaintThrottleMs: 1e3 })
+      tui: TuiConfig.default({ repaintThrottleMs: 1e3, maxScrollbackLines: 1e4 })
     });
   }
 });
@@ -226,6 +242,9 @@ function extractHydraMeta(meta) {
   if (typeof obj.currentMode === "string") {
     out.currentMode = obj.currentMode;
   }
+  if (typeof obj.turnStartedAt === "number" && obj.turnStartedAt > 0) {
+    out.turnStartedAt = obj.turnStartedAt;
+  }
   if (Array.isArray(obj.availableCommands)) {
     const cmds = [];
     for (const raw of obj.availableCommands) {
@@ -264,7 +283,8 @@ var init_types = __esm({
       SessionNotFound: -32001,
       PermissionDenied: -32002,
       AlreadyAttached: -32003,
-      AgentNotInstalled: -32005
+      AgentNotInstalled: -32005,
+      BundleAlreadyImported: -32010
     };
     InitializeParams = z3.object({
       protocolVersion: z3.number().optional(),
@@ -388,9 +408,9 @@ var init_connection = __esm({
         }
         const id = nanoid();
         const message = { jsonrpc: "2.0", id, method, params };
-        const response = new Promise((resolve2, reject) => {
+        const response = new Promise((resolve4, reject) => {
           this.pending.set(id, {
-            resolve: (result) => resolve2(result),
+            resolve: (result) => resolve4(result),
             reject
           });
           this.stream.send(message).catch((err) => {
@@ -614,7 +634,7 @@ function firstLine(text, max) {
   }
   return void 0;
 }
-var HYDRA_ID_ALPHABET, generateHydraId, HYDRA_SESSION_PREFIX, Session, STATE_UPDATE_KINDS;
+var HYDRA_ID_ALPHABET, generateHydraId, HYDRA_SESSION_PREFIX, MAX_HISTORY_ENTRIES, COMPACT_EVERY, Session, STATE_UPDATE_KINDS;
 var init_session = __esm({
   "src/core/session.ts"() {
     "use strict";
@@ -623,6 +643,8 @@ 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;
     Session = class {
       sessionId;
       cwd;
@@ -642,8 +664,8 @@ var init_session = __esm({
       currentModel;
       currentMode;
       updatedAt;
+      createdAt;
       clients = /* @__PURE__ */ new Map();
-      history = [];
       historyStore;
       promptQueue = [];
       promptInFlight = false;
@@ -659,6 +681,15 @@ var init_session = __esm({
       // True once we've observed our first session/prompt; gates the
       // first-prompt-seeded title so subsequent prompts don't churn it.
       firstPromptSeeded = false;
+      // Wall-clock when the active prompt started, undefined when idle.
+      // 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
+      // we ask the history store to trim the file to the most recent
+      // MAX_HISTORY_ENTRIES. Keeps file growth bounded without per-append
+      // file-size checks.
+      appendCount = 0;
       // 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
@@ -673,6 +704,12 @@ var init_session = __esm({
       internalPromptCapture;
       idleTimeoutMs;
       idleTimer;
+      // Time of the last recordable broadcast (or session creation, if
+      // none yet). Drives the inactivity-based idle close; deliberately
+      // does NOT include snapshot state pings (model/mode/title/commands)
+      // or attach/detach, which would otherwise let passive observers
+      // and noisy state churn keep a quiet session alive forever.
+      lastRecordedAt;
       spawnReplacementAgent;
       agentChangeHandlers = [];
       // Last available_commands_update we observed from the agent. Stored
@@ -703,12 +740,15 @@ var init_session = __esm({
         }
         this.idleTimeoutMs = init.idleTimeoutMs ?? 0;
         this.spawnReplacementAgent = init.spawnReplacementAgent;
-        this.historyStore = init.historyStore;
-        if (init.seedHistory && init.seedHistory.length > 0) {
-          this.history = [...init.seedHistory];
+        if (init.firstPromptSeeded) {
+          this.firstPromptSeeded = true;
         }
+        this.historyStore = init.historyStore;
         this.updatedAt = Date.now();
+        this.createdAt = init.createdAt ?? this.updatedAt;
+        this.lastRecordedAt = this.updatedAt;
         this.wireAgent(this.agent);
+        this.scheduleIdleCheck();
       }
       broadcastMergedCommands() {
         const merged = [
@@ -767,12 +807,21 @@ var init_session = __esm({
       get attachedCount() {
         return this.clients.size;
       }
-      // Snapshot of the current in-memory replay history. Used by the
-      // HTTP history endpoint to deliver the "what's accumulated so far"
-      // prefix before optionally tailing with onBroadcast. Returns a copy
-      // so callers can't mutate our cache.
-      getHistorySnapshot() {
-        return [...this.history];
+      // 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
+      // time without scanning history.
+      get turnStartedAt() {
+        return this.promptStartedAt;
+      }
+      // Read the persisted history from disk. Returns [] if no history
+      // file exists (fresh session, never prompted). Used by attach() and
+      // the HTTP /history endpoint.
+      async getHistorySnapshot() {
+        if (!this.historyStore) {
+          return [];
+        }
+        return this.historyStore.load(this.sessionId).catch(() => []);
       }
       // Subscribe to recordable broadcast entries — fires once per entry
       // that lands in history (so snapshot-shaped session_info/model/mode/
@@ -788,6 +837,10 @@ 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) {
         if (this.closed) {
           throw withCode(
@@ -803,14 +856,10 @@ var init_session = __esm({
         }
         this.clients.set(client.clientId, client);
         this.updatedAt = Date.now();
-        this.cancelIdleTimer();
-        if (historyPolicy === "none") {
-          return [];
+        if (historyPolicy === "none" || historyPolicy === "pending_only") {
+          return Promise.resolve([]);
         }
-        if (historyPolicy === "pending_only") {
-          return [];
-        }
-        return [...this.history];
+        return this.getHistorySnapshot();
       }
       // Dispatch in-flight permission requests to a freshly-attached
       // client. Called by the daemon's WS handler *after* it finishes
@@ -824,7 +873,6 @@ var init_session = __esm({
       detach(clientId) {
         if (this.clients.delete(clientId)) {
           this.updatedAt = Date.now();
-          this.maybeStartIdleTimer();
         }
       }
       async prompt(clientId, params) {
@@ -844,13 +892,19 @@ var init_session = __esm({
         this.broadcastPromptReceived(client, params);
         this.maybeSeedTitleFromPrompt(params);
         return this.enqueuePrompt(async () => {
-          const response = await this.agent.connection.request(
-            "session/prompt",
-            {
-              ...params,
-              sessionId: this.upstreamSessionId
-            }
-          );
+          let response;
+          try {
+            response = await this.agent.connection.request(
+              "session/prompt",
+              {
+                ...params,
+                sessionId: this.upstreamSessionId
+              }
+            );
+          } catch (err) {
+            this.broadcastTurnComplete(client.clientId, { stopReason: "error" });
+            throw err;
+          }
           this.broadcastTurnComplete(client.clientId, response);
           return response;
         });
@@ -864,6 +918,7 @@ var init_session = __esm({
         if (client.clientInfo?.version) {
           sentBy.version = client.clientInfo.version;
         }
+        this.promptStartedAt = Date.now();
         this.recordAndBroadcast(
           "session/update",
           {
@@ -900,6 +955,7 @@ var init_session = __esm({
         if (stopReason !== void 0) {
           update.stopReason = stopReason;
         }
+        this.promptStartedAt = void 0;
         this.recordAndBroadcast(
           "session/update",
           {
@@ -938,6 +994,13 @@ var init_session = __esm({
           return;
         }
         this.cancelIdleTimer();
+        if (opts.regenTitle && this.firstPromptSeeded) {
+          const timeoutMs = opts.regenTitleTimeoutMs ?? 5e3;
+          await Promise.race([
+            this.runTitleRegen().catch(() => void 0),
+            new Promise((r) => setTimeout(r, timeoutMs).unref?.())
+          ]);
+        }
         await this.agent.kill().catch(() => void 0);
         this.markClosed({ deleteRecord: opts.deleteRecord ?? false });
       }
@@ -986,7 +1049,7 @@ var init_session = __esm({
         }
         const promptParams = params ?? {};
         const text = extractPromptText(promptParams.prompt);
-        const seed = firstLine(text, 80);
+        const seed = firstLine(text, 200);
         if (!seed) {
           return;
         }
@@ -1078,6 +1141,12 @@ var init_session = __esm({
       mergedAvailableCommands() {
         return [...hydraCommandsAsAdvertised(), ...this.agentAdvertisedCommands];
       }
+      // The agent's own advertised commands (not merged with hydra verbs).
+      // Used by SessionManager to persist into meta.json so cold resurrect
+      // can re-deliver via the attach response _meta.
+      agentOnlyAdvertisedCommands() {
+        return [...this.agentAdvertisedCommands];
+      }
       // Pick up an agent-emitted session_info_update and store its title
       // as our canonical record. The notification is also forwarded to
       // clients via the surrounding recordAndBroadcast call. Authoritative
@@ -1209,7 +1278,7 @@ var init_session = __esm({
         const spawnAgent = this.spawnReplacementAgent;
         return this.enqueuePrompt(async () => {
           const oldAgentId = this.agentId;
-          const transcript = this.buildSwitchTranscript(oldAgentId);
+          const transcript = await this.buildSwitchTranscript(oldAgentId);
           const fresh = await spawnAgent({
             agentId: newAgentId,
             cwd: this.cwd,
@@ -1241,15 +1310,20 @@ var init_session = __esm({
           return { stopReason: "end_turn" };
         });
       }
-      // Walk this.history (rewritten-for-clients notification cache) and
-      // produce a labeled transcript suitable for handing to a fresh agent.
-      // Includes user prompts, agent replies, and tool-call outcomes; skips
-      // hydra-synthesized markers (so multi-hop switches don't accumulate
-      // banners) and other update kinds we don't think the next agent
-      // benefits from re-seeing (plans, thoughts, mode/model/usage).
-      buildSwitchTranscript(prevAgentId) {
+      // Walk the persisted history and produce a labeled transcript suitable
+      // for handing to a fresh agent. Includes user prompts, agent replies,
+      // and tool-call outcomes; skips hydra-synthesized markers (so multi-hop
+      // switches don't accumulate banners) and other update kinds we don't
+      // think the next agent benefits from re-seeing (plans, thoughts,
+      // mode/model/usage).
+      //
+      // The header text defaults to the agent-swap framing; callers like
+      // seedFromImport pass a custom header when the new agent is taking
+      // over an imported session rather than swapping mid-conversation.
+      async buildSwitchTranscript(prevAgentId, headerOverride) {
         const lines = [];
-        for (const note of this.history) {
+        const history = await this.getHistorySnapshot();
+        for (const note of history) {
           if (note.method !== "session/update") {
             continue;
           }
@@ -1303,29 +1377,53 @@ var init_session = __esm({
         if (current) {
           coalesced.push(`<${current.speaker}>: ${current.text.trim()}`);
         }
+        const intro = headerOverride?.intro ?? `You are taking over this conversation from ${prevAgentId}. Below is the transcript so far.`;
+        const followup = headerOverride?.followup ?? `Each line is prefixed with its speaker. Continue from where ${prevAgentId} left off, responding to the user's most recent message.`;
         return [
-          `You are taking over this conversation from ${prevAgentId}. Below is the transcript so far.`,
-          `Each line is prefixed with its speaker. Continue from where ${prevAgentId} left off, responding to the user's most recent message.`,
+          intro,
+          followup,
           "",
           "--- begin transcript ---",
           ...coalesced,
           "--- end transcript ---"
         ].join("\n");
       }
+      // Replay the persisted history into a freshly-spawned agent so an
+      // imported session has context. Called by SessionManager.doResurrect
+      // on the first wake-up of a session whose meta.json has an empty
+      // upstreamSessionId (the import marker). Wrapped in enqueuePrompt so
+      // any user prompts arriving mid-seed queue behind it (mirrors the
+      // /hydra switch path so the agent isn't asked to respond to a user
+      // turn before it has absorbed the imported transcript). Best-effort:
+      // if the agent fails to absorb the transcript we still leave the
+      // session usable — the user just continues without context.
+      async seedFromImport() {
+        await this.enqueuePrompt(async () => {
+          const transcript = await this.buildSwitchTranscript(this.agentId, {
+            intro: "You are continuing a conversation that was imported from another hydra. Below is the transcript so far.",
+            followup: "Each line is prefixed with its speaker. Treat this as context for the next user message; do not re-respond to earlier turns."
+          });
+          if (!transcript) {
+            return void 0;
+          }
+          await this.runInternalPrompt(transcript).catch(() => void 0);
+          return void 0;
+        });
+      }
       // Tell every attached client (a) the agent identity has changed
-      // (session_info_update with an agentId field — clients that already
-      // listen for title updates pick this up; older clients ignore unknown
-      // fields harmlessly) and (b) drop a visible banner into the transcript
-      // so users see the switch rather than just suddenly getting answers
-      // from a different agent. Both updates carry _meta["hydra-acp"].synthetic
+      // (session_info_update carrying agentId inside _meta["hydra-acp"] —
+      // the ACP schema for session_info_update is just title/updatedAt/_meta,
+      // so non-hydra clients harmlessly ignore the extension; hydra-aware
+      // ones read it and relabel) and (b) drop a visible banner into the
+      // transcript so users see the switch rather than just suddenly getting
+      // answers from a different agent. Both updates carry synthetic=true
       // so a future /hydra switch's transcript builder filters them out.
       broadcastAgentSwitch(oldAgentId, newAgentId) {
         this.recordAndBroadcast("session/update", {
           sessionId: this.sessionId,
           update: {
             sessionUpdate: "session_info_update",
-            agentId: newAgentId,
-            _meta: { "hydra-acp": { synthetic: true } }
+            _meta: { "hydra-acp": { synthetic: true, agentId: newAgentId } }
           }
         });
         this.recordAndBroadcast("session/update", {
@@ -1356,21 +1454,55 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
           handler(opts);
         }
       }
-      maybeStartIdleTimer() {
-        if (this.closed || this.clients.size > 0 || this.idleTimeoutMs <= 0) {
+      // Last meaningful activity timestamp. Bumped only by recordable
+      // broadcasts in recordAndBroadcast — the same signal historyMtimeIso
+      // uses for the picker. Initialized at construction (and seeded from
+      // the newest entry on resurrect) so the inactivity window starts
+      // ticking from a sensible floor when there's no history yet.
+      get lastActivityAt() {
+        return this.lastRecordedAt;
+      }
+      // (Re-)arm the idle timer to fire when the inactivity window
+      // elapses past lastActivityAt. Called once at construction and after
+      // every recorded broadcast. The previous design gated on
+      // clients.size === 0; we drop that gate because extensions
+      // (slack/notifier/approver/browser) hold persistent attaches that
+      // would otherwise keep a quiet session alive forever.
+      scheduleIdleCheck() {
+        if (this.closed || this.idleTimeoutMs <= 0) {
           return;
         }
+        const dueAt = this.lastActivityAt + this.idleTimeoutMs;
+        this.armIdleTimer(Math.max(0, dueAt - Date.now()));
+      }
+      armIdleTimer(delay) {
         if (this.idleTimer) {
-          return;
+          clearTimeout(this.idleTimer);
         }
         this.idleTimer = setTimeout(() => {
           this.idleTimer = void 0;
-          void this.close({ deleteRecord: false }).catch(() => void 0);
-        }, this.idleTimeoutMs);
+          this.checkIdle();
+        }, delay);
         if (typeof this.idleTimer.unref === "function") {
           this.idleTimer.unref();
         }
       }
+      checkIdle() {
+        if (this.closed || this.idleTimeoutMs <= 0) {
+          return;
+        }
+        if (this.turnStartedAt !== void 0 || this.inFlightPermissions.size > 0) {
+          this.armIdleTimer(this.idleTimeoutMs);
+          return;
+        }
+        const idle = Date.now() - this.lastActivityAt;
+        if (idle < this.idleTimeoutMs) {
+          this.armIdleTimer(this.idleTimeoutMs - idle);
+          return;
+        }
+        const opts = this.firstPromptSeeded ? { deleteRecord: false, regenTitle: true } : { deleteRecord: true };
+        void this.close(opts).catch(() => void 0);
+      }
       cancelIdleTimer() {
         if (this.idleTimer) {
           clearTimeout(this.idleTimer);
@@ -1395,17 +1527,14 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
             params: rewritten,
             recordedAt: Date.now()
           };
-          this.history.push(entry);
-          let trimmed = false;
-          if (this.history.length > 1e3) {
-            this.history = this.history.slice(-500);
-            trimmed = true;
-          }
+          this.lastRecordedAt = entry.recordedAt;
+          this.appendCount += 1;
           if (this.historyStore) {
-            if (trimmed) {
-              void this.historyStore.rewrite(this.sessionId, [...this.history]).catch(() => void 0);
-            } else {
-              void this.historyStore.append(this.sessionId, entry).catch(
+            const store = this.historyStore;
+            void store.append(this.sessionId, entry).catch(() => void 0);
+            if (this.appendCount >= COMPACT_EVERY) {
+              this.appendCount = 0;
+              void store.compact(this.sessionId, MAX_HISTORY_ENTRIES).catch(
                 () => void 0
               );
             }
@@ -1416,6 +1545,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
             } catch {
             }
           }
+          this.scheduleIdleCheck();
         }
         this.updatedAt = Date.now();
         for (const client of this.clients.values()) {
@@ -1434,7 +1564,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
           );
         }
         const clientParams = this.rewriteForClient(params);
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve4, reject) => {
           let settled = false;
           const outbound = [];
           const entry = { addClient: sendTo };
@@ -1469,7 +1599,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
                     result
                   }).catch(() => void 0);
                 }
-                resolve2(result);
+                resolve4(result);
               });
             }).catch((err) => {
               settle(() => reject(err));
@@ -1481,11 +1611,11 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         });
       }
       async enqueuePrompt(task) {
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve4, reject) => {
           const run = async () => {
             try {
               const result = await task();
-              resolve2(result);
+              resolve4(result);
             } catch (err) {
               reject(err);
             }
@@ -1520,6 +1650,64 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
   }
 });
 
+// src/tui/history.ts
+import { promises as fs6 } from "fs";
+import * as path3 from "path";
+async function loadHistory(file) {
+  let text;
+  try {
+    text = await fs6.readFile(file, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return [];
+    }
+    throw err;
+  }
+  return parseHistory(text);
+}
+function parseHistory(text) {
+  const out = [];
+  for (const rawLine of text.split("\n")) {
+    if (rawLine.length === 0) {
+      continue;
+    }
+    try {
+      const decoded = JSON.parse(rawLine);
+      if (typeof decoded === "string") {
+        out.push(decoded);
+      }
+    } catch {
+    }
+  }
+  return out;
+}
+function appendEntry(history, entry) {
+  const trimmed = entry.replace(/\n+$/, "");
+  if (trimmed.length === 0) {
+    return history;
+  }
+  if (history.length > 0 && history[history.length - 1] === trimmed) {
+    return history;
+  }
+  const out = history.concat(trimmed);
+  if (out.length > HISTORY_CAP) {
+    return out.slice(out.length - HISTORY_CAP);
+  }
+  return out;
+}
+async function saveHistory(file, history) {
+  await fs6.mkdir(path3.dirname(file), { recursive: true });
+  const lines = history.map((entry) => JSON.stringify(entry));
+  await fs6.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
+}
+var HISTORY_CAP;
+var init_history = __esm({
+  "src/tui/history.ts"() {
+    "use strict";
+    HISTORY_CAP = 500;
+  }
+});
+
 // src/acp/ws-stream.ts
 function wsToMessageStream(ws) {
   const messageHandlers = [];
@@ -1565,13 +1753,13 @@ function wsToMessageStream(ws) {
         throw new Error("ws is closed");
       }
       const text = JSON.stringify(message);
-      await new Promise((resolve2, reject) => {
+      await new Promise((resolve4, reject) => {
         ws.send(text, (err) => {
           if (err) {
             reject(err);
             return;
           }
-          resolve2();
+          resolve4();
         });
       });
     },
@@ -1650,7 +1838,150 @@ var init_daemon_bootstrap = __esm({
   }
 });
 
+// src/cli/session-row.ts
+function toRow(s, now = Date.now()) {
+  return {
+    session: stripHydraSessionPrefix(s.sessionId),
+    upstream: s.upstreamSessionId ?? "-",
+    status: (s.status ?? "live").toUpperCase(),
+    clients: s.status === "cold" ? "-" : String(s.attachedClients),
+    agent: s.agentId ?? "?",
+    age: formatRelativeAge(s.updatedAt, now),
+    title: s.title ?? "-",
+    cwd: s.cwd
+  };
+}
+function computeWidths(rows) {
+  return {
+    session: maxLen(HEADER.session, rows.map((r) => r.session)),
+    upstream: maxLen(HEADER.upstream, rows.map((r) => r.upstream)),
+    status: maxLen(HEADER.status, rows.map((r) => r.status)),
+    clients: maxLen(HEADER.clients, rows.map((r) => r.clients)),
+    agent: maxLen(HEADER.agent, rows.map((r) => r.agent)),
+    age: maxLen(HEADER.age, rows.map((r) => r.age)),
+    title: maxLen(HEADER.title, rows.map((r) => r.title))
+  };
+}
+function formatRelativeAge(iso, now) {
+  if (!iso) {
+    return "?";
+  }
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) {
+    return "?";
+  }
+  const diff = Math.max(0, now - t);
+  const sec = Math.floor(diff / 1e3);
+  if (sec < 60) {
+    return "<1m";
+  }
+  const min = Math.floor(sec / 60);
+  if (min < 60) {
+    return `${min}m`;
+  }
+  const hr = Math.floor(min / 60);
+  if (hr < 24) {
+    return `${hr}h`;
+  }
+  const day = Math.floor(hr / 24);
+  if (day < 14) {
+    return `${day}d`;
+  }
+  const week = Math.floor(day / 7);
+  if (week < 9) {
+    return `${week}w`;
+  }
+  const month = Math.floor(day / 30);
+  if (month < 12) {
+    return `${month}mo`;
+  }
+  const year = Math.floor(day / 365);
+  return `${year}y`;
+}
+function maxLen(headerCell, values) {
+  let max = headerCell.length;
+  for (const v of values) {
+    if (v.length > max) {
+      max = v.length;
+    }
+  }
+  return max;
+}
+function formatRow(r, w, maxWidth) {
+  const fixed = [
+    r.session.padEnd(w.session),
+    r.upstream.padEnd(w.upstream),
+    r.status.padEnd(w.status),
+    r.clients.padStart(w.clients),
+    r.agent.padEnd(w.agent),
+    r.age.padStart(w.age)
+  ].join(SEP);
+  if (maxWidth === void 0) {
+    return [fixed, r.title.padEnd(w.title), r.cwd].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);
+}
+function truncateRight(s, max) {
+  if (max <= 0) {
+    return "";
+  }
+  if (s.length <= max) {
+    return s;
+  }
+  if (max === 1) {
+    return "\u2026";
+  }
+  return s.slice(0, max - 1) + "\u2026";
+}
+function truncateMiddle(s, max) {
+  if (max <= 0) {
+    return "";
+  }
+  if (s.length <= max) {
+    return s;
+  }
+  if (max === 1) {
+    return "\u2026";
+  }
+  const head = Math.ceil((max - 1) / 2);
+  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 init_session_row = __esm({
+  "src/cli/session-row.ts"() {
+    "use strict";
+    init_session();
+    HEADER = {
+      session: "SESSION",
+      upstream: "UPSTREAM",
+      status: "STATUS",
+      clients: "CLIENTS",
+      agent: "AGENT",
+      age: "AGE",
+      title: "TITLE",
+      cwd: "CWD"
+    };
+    SEP = "  ";
+    MIN_CWD = 8;
+    TITLE_MAX_WIDTH = 40;
+  }
+});
+
 // src/cli/commands/sessions.ts
+import * as fs11 from "fs/promises";
+import * as path5 from "path";
 async function runSessionsList(opts = {}) {
   const config = await loadConfig();
   const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
@@ -1685,44 +2016,13 @@ async function runSessionsList(opts = {}) {
     visible = [...sorted.slice(0, liveCount), ...coldSlice];
     truncated = hiddenCold;
   }
-  const rows = visible.map((s) => ({
-    session: stripHydraSessionPrefix(s.sessionId),
-    upstream: s.upstreamSessionId ?? "-",
-    status: (s.status ?? "live").toUpperCase(),
-    clients: s.status === "cold" ? "-" : String(s.attachedClients),
-    agent: s.agentId ?? "?",
-    title: s.title ?? "-",
-    cwd: s.cwd
-  }));
-  const header = {
-    session: "SESSION",
-    upstream: "UPSTREAM",
-    status: "STATUS",
-    clients: "CLIENTS",
-    agent: "AGENT",
-    title: "TITLE",
-    cwd: "CWD"
-  };
-  const widths = {
-    session: maxLen(header.session, rows.map((r) => r.session)),
-    upstream: maxLen(header.upstream, rows.map((r) => r.upstream)),
-    status: maxLen(header.status, rows.map((r) => r.status)),
-    clients: maxLen(header.clients, rows.map((r) => r.clients)),
-    agent: maxLen(header.agent, rows.map((r) => r.agent)),
-    title: maxLen(header.title, rows.map((r) => r.title))
-  };
-  const formatRow2 = (r) => [
-    r.session.padEnd(widths.session),
-    r.upstream.padEnd(widths.upstream),
-    r.status.padEnd(widths.status),
-    r.clients.padStart(widths.clients),
-    r.agent.padEnd(widths.agent),
-    r.title.padEnd(widths.title),
-    r.cwd
-  ].join("  ");
-  process.stdout.write(formatRow2(header) + "\n");
+  const now = Date.now();
+  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");
   for (const r of rows) {
-    process.stdout.write(formatRow2(r) + "\n");
+    process.stdout.write(formatRow(r, widths, maxWidth) + "\n");
   }
   if (truncated > 0) {
     process.stdout.write(
@@ -1732,15 +2032,6 @@ async function runSessionsList(opts = {}) {
     );
   }
 }
-function maxLen(headerCell, values) {
-  let max = headerCell.length;
-  for (const v of values) {
-    if (v.length > max) {
-      max = v.length;
-    }
-  }
-  return max;
-}
 async function runSessionsKill(id) {
   if (!id) {
     process.stderr.write("Usage: hydra-acp sessions kill <session-id>\n");
@@ -1748,6 +2039,25 @@ async function runSessionsKill(id) {
   }
   const config = await loadConfig();
   const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetch(`${baseUrl}/v1/sessions/${id}/kill`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${config.daemon.authToken}` }
+  });
+  if (!response.ok && response.status !== 204) {
+    process.stderr.write(`Daemon returned HTTP ${response.status}
+`);
+    process.exit(1);
+  }
+  process.stdout.write(`Killed ${id}
+`);
+}
+async function runSessionsRm(id) {
+  if (!id) {
+    process.stderr.write("Usage: hydra-acp sessions rm <session-id>\n");
+    process.exit(2);
+  }
+  const config = await loadConfig();
+  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
   const response = await fetch(`${baseUrl}/v1/sessions/${id}`, {
     method: "DELETE",
     headers: { Authorization: `Bearer ${config.daemon.authToken}` }
@@ -1757,9 +2067,114 @@ async function runSessionsKill(id) {
 `);
     process.exit(1);
   }
-  process.stdout.write(`Killed ${id}
+  process.stdout.write(`Removed ${id}
 `);
 }
+async function runSessionsExport(id, outPath) {
+  if (!id) {
+    process.stderr.write(
+      "Usage: hydra-acp sessions export <session-id> [--out <file>]\n"
+    );
+    process.exit(2);
+  }
+  const config = await loadConfig();
+  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetch(
+    `${baseUrl}/v1/sessions/${encodeURIComponent(id)}/export`,
+    {
+      headers: { Authorization: `Bearer ${config.daemon.authToken}` }
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    process.stderr.write(`Daemon returned HTTP ${response.status}: ${text}
+`);
+    process.exit(1);
+  }
+  const body = await response.text();
+  if (!outPath) {
+    process.stdout.write(body);
+    if (!body.endsWith("\n")) {
+      process.stdout.write("\n");
+    }
+    return;
+  }
+  const resolved = outPath === "." ? deriveFilenameFrom(response, id) : outPath;
+  await fs11.mkdir(path5.dirname(path5.resolve(resolved)), { recursive: true });
+  await fs11.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"
+    );
+    process.exit(2);
+  }
+  let body;
+  if (file === "-") {
+    body = await readStdin();
+  } else {
+    body = await fs11.readFile(file, "utf8");
+  }
+  let bundle;
+  try {
+    bundle = JSON.parse(body);
+  } catch (err) {
+    process.stderr.write(`Failed to parse bundle: ${err.message}
+`);
+    process.exit(1);
+  }
+  const config = await loadConfig();
+  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetch(`${baseUrl}/v1/sessions/import`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.daemon.authToken}`
+    },
+    body: JSON.stringify({ bundle, replace: opts.replace === true })
+  });
+  if (response.status === 409) {
+    const detail = await response.json().catch(() => ({}));
+    process.stderr.write(
+      `Bundle already imported as ${detail.existingSessionId ?? "unknown"}. Use --replace to overwrite.
+`
+    );
+    process.exit(1);
+  }
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    process.stderr.write(`Daemon returned HTTP ${response.status}: ${text}
+`);
+    process.exit(1);
+  }
+  const result = await response.json();
+  process.stdout.write(
+    result.replaced ? `Replaced ${result.sessionId} (from ${result.importedFromSessionId})
+` : `Imported as ${result.sessionId} (from ${result.importedFromSessionId})
+`
+  );
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function deriveFilenameFrom(response, id) {
+  const cd = response.headers.get("content-disposition");
+  if (cd) {
+    const match = cd.match(/filename="([^"]+)"/);
+    if (match) {
+      return match[1];
+    }
+  }
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return `hydra-${id}-${stamp}.hydra`;
+}
 function httpBase(host, port, tls) {
   const protocol = tls ? "https" : "http";
   return `${protocol}://${host}:${port}`;
@@ -1768,7 +2183,7 @@ var init_sessions = __esm({
   "src/cli/commands/sessions.ts"() {
     "use strict";
     init_config();
-    init_session();
+    init_session_row();
   }
 });
 
@@ -1779,11 +2194,11 @@ function isResponse(msg) {
   return !("method" in msg) && "id" in msg && msg.id !== void 0;
 }
 async function openWs(url, subprotocols) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const ws = new WebSocket(url, subprotocols);
     const onOpen = () => {
       ws.off("error", onError);
-      resolve2(wsToMessageStream(ws));
+      resolve4(wsToMessageStream(ws));
     };
     const onError = (err) => {
       ws.off("open", onOpen);
@@ -1854,8 +2269,8 @@ var init_resilient_ws = __esm({
           throw new Error("resilient ws stream not connected");
         }
         const id = message.id;
-        const promise = new Promise((resolve2, reject) => {
-          this.pendingRequests.set(id, { resolve: resolve2, reject });
+        const promise = new Promise((resolve4, reject) => {
+          this.pendingRequests.set(id, { resolve: resolve4, reject });
         });
         try {
           await this.current.send(message);
@@ -1883,8 +2298,8 @@ var init_resilient_ws = __esm({
             this.bindStream(stream);
             const wasFirst = this.firstConnect;
             this.firstConnect = false;
-            this.connectGate = new Promise((resolve2) => {
-              this.releaseConnectGate = resolve2;
+            this.connectGate = new Promise((resolve4) => {
+              this.releaseConnectGate = resolve4;
             });
             try {
               if (this.opts.onConnect) {
@@ -2007,64 +2422,6 @@ var init_resilient_ws = __esm({
   }
 });
 
-// src/tui/history.ts
-import { promises as fs9 } from "fs";
-import * as path4 from "path";
-async function loadHistory(file) {
-  let text;
-  try {
-    text = await fs9.readFile(file, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      return [];
-    }
-    throw err;
-  }
-  return parseHistory(text);
-}
-function parseHistory(text) {
-  const out = [];
-  for (const rawLine of text.split("\n")) {
-    if (rawLine.length === 0) {
-      continue;
-    }
-    try {
-      const decoded = JSON.parse(rawLine);
-      if (typeof decoded === "string") {
-        out.push(decoded);
-      }
-    } catch {
-    }
-  }
-  return out;
-}
-function appendEntry(history, entry) {
-  const trimmed = entry.replace(/\n+$/, "");
-  if (trimmed.length === 0) {
-    return history;
-  }
-  if (history.length > 0 && history[history.length - 1] === trimmed) {
-    return history;
-  }
-  const out = history.concat(trimmed);
-  if (out.length > HISTORY_CAP) {
-    return out.slice(out.length - HISTORY_CAP);
-  }
-  return out;
-}
-async function saveHistory(file, history) {
-  await fs9.mkdir(path4.dirname(file), { recursive: true });
-  const lines = history.map((entry) => JSON.stringify(entry));
-  await fs9.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
-}
-var HISTORY_CAP;
-var init_history = __esm({
-  "src/tui/history.ts"() {
-    "use strict";
-    HISTORY_CAP = 500;
-  }
-});
-
 // src/tui/discovery.ts
 async function listSessions(config, opts = {}, fetchImpl = fetch) {
   const base = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
@@ -2096,6 +2453,26 @@ async function listSessions(config, opts = {}, fetchImpl = fetch) {
     title: s.title
   }));
 }
+async function killSession(config, id, fetchImpl = fetch) {
+  const base = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetchImpl(`${base}/v1/sessions/${id}/kill`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${config.daemon.authToken}` }
+  });
+  if (!response.ok && response.status !== 204 && response.status !== 404) {
+    throw new Error(`daemon returned HTTP ${response.status}`);
+  }
+}
+async function deleteSession(config, id, fetchImpl = fetch) {
+  const base = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetchImpl(`${base}/v1/sessions/${id}`, {
+    method: "DELETE",
+    headers: { Authorization: `Bearer ${config.daemon.authToken}` }
+  });
+  if (!response.ok && response.status !== 204 && response.status !== 404) {
+    throw new Error(`daemon returned HTTP ${response.status}`);
+  }
+}
 function pickMostRecent(sessions, cwd) {
   const matching = sessions.filter((s) => s.cwd === cwd);
   if (matching.length === 0) {
@@ -2123,147 +2500,406 @@ async function pickSession(term, opts) {
   if (opts.sessions.length === 0) {
     return { kind: "new" };
   }
-  const score = (s) => {
-    if (s.status !== "live") {
-      return 0;
+  const sortSessions = (sessions) => {
+    const score = (s) => {
+      if (s.status !== "live") {
+        return 0;
+      }
+      return s.cwd === opts.cwd ? 2 : 1;
+    };
+    return [...sessions].sort((a, b) => {
+      const tier = score(b) - score(a);
+      if (tier !== 0) {
+        return tier;
+      }
+      return b.updatedAt.localeCompare(a.updatedAt);
+    });
+  };
+  let visible = sortSessions(opts.sessions);
+  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 mode = "normal";
+  let pendingAction = null;
+  let transientStatus = null;
+  let termHeight = readTermHeight(term);
+  let termWidth = readTermWidth(term);
+  let viewportSize = 0;
+  let newSessionLabel = "";
+  let headerLine = "";
+  let sessionLines = [];
+  let startRow = 1;
+  const computeLayout = () => {
+    termHeight = readTermHeight(term);
+    termWidth = readTermWidth(term);
+    const maxViewportRows = Math.max(3, termHeight - 6);
+    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));
+  };
+  const rebuildRows = () => {
+    rows = visible.map((s) => toRow(s, Date.now()));
+    widths = computeWidths(rows);
+    total = 1 + visible.length;
+    computeLayout();
+  };
+  const adjustScroll = () => {
+    if (selectedIdx === 0) {
+      return;
+    }
+    const sessionIdx = selectedIdx - 1;
+    if (sessionIdx < scrollOffset) {
+      scrollOffset = sessionIdx;
+    } else if (sessionIdx >= scrollOffset + viewportSize) {
+      scrollOffset = sessionIdx - viewportSize + 1;
+    } else if (scrollOffset + viewportSize > visible.length) {
+      scrollOffset = Math.max(0, visible.length - viewportSize);
     }
-    return s.cwd === opts.cwd ? 2 : 1;
   };
-  const sorted = [...opts.sessions].sort((a, b) => {
-    const tier = score(b) - score(a);
-    if (tier !== 0) {
-      return tier;
+  const paintNewItem = () => {
+    if (selectedIdx === 0) {
+      term.brightWhite.bgBlue.noFormat(`\u276F ${newSessionLabel}`);
+    } else {
+      term.noFormat(`  ${newSessionLabel}`);
     }
-    return b.updatedAt.localeCompare(a.updatedAt);
+  };
+  const paintSessionRow = (sessionIdx) => {
+    const label = sessionLines[sessionIdx] ?? "";
+    if (selectedIdx === sessionIdx + 1) {
+      term.brightWhite.bgBlue.noFormat(`\u276F ${label}`);
+    } else {
+      term.noFormat(`  ${label}`);
+    }
+  };
+  const formatIndicator = () => {
+    const above = scrollOffset;
+    const below = Math.max(0, visible.length - scrollOffset - viewportSize);
+    if (above === 0 && below === 0) {
+      return "";
+    }
+    const parts = [];
+    if (above > 0) {
+      parts.push(`\u2191 ${above} above`);
+    }
+    if (below > 0) {
+      parts.push(`\u2193 ${below} below`);
+    }
+    return `  ${parts.join(" \xB7 ")}`;
+  };
+  const shortId2 = (sessionId) => stripHydraSessionPrefix(sessionId);
+  const paintIndicator = () => {
+    term.moveTo(1, indicatorRow()).eraseLineAfter();
+    if (mode === "confirm-kill" && pendingAction) {
+      term.brightYellow.noFormat(`  kill ${shortId2(pendingAction.sessionId)}? [y/N]`);
+      return;
+    }
+    if (mode === "confirm-delete" && pendingAction) {
+      term.brightRed.noFormat(`  delete ${shortId2(pendingAction.sessionId)}? [y/N]`);
+      return;
+    }
+    if (mode === "busy" && pendingAction) {
+      term.dim.noFormat(`  working on ${shortId2(pendingAction.sessionId)}\u2026`);
+      return;
+    }
+    if (transientStatus !== null) {
+      term.dim.noFormat(`  ${transientStatus}`);
+      return;
+    }
+    term.dim.noFormat(formatIndicator());
+  };
+  const indicatorRow = () => startRow + 3 + viewportSize;
+  const sessionRow = (sessionIdx) => startRow + 3 + (sessionIdx - scrollOffset);
+  const renderFromScratch = () => {
+    computeLayout();
+    adjustScroll();
+    startRow = 1;
+    term.moveTo(1, 1).eraseDisplayBelow();
+    paintNewItem();
+    term("\n\n");
+    term.dim.noFormat(`  ${headerLine}`)("\n");
+    for (let v = 0; v < viewportSize; v++) {
+      paintSessionRow(scrollOffset + v);
+      term("\n");
+    }
+    paintIndicator();
+    term("\n");
+  };
+  const repaintNewItem = () => {
+    term.moveTo(1, startRow).eraseLineAfter();
+    paintNewItem();
+  };
+  const repaintSessionRow = (sessionIdx) => {
+    if (sessionIdx < scrollOffset || sessionIdx >= scrollOffset + viewportSize) {
+      return;
+    }
+    term.moveTo(1, sessionRow(sessionIdx)).eraseLineAfter();
+    paintSessionRow(sessionIdx);
+  };
+  const repaintViewport = () => {
+    for (let v = 0; v < viewportSize; v++) {
+      const row = startRow + 3 + v;
+      term.moveTo(1, row).eraseLineAfter();
+      const sessionIdx = scrollOffset + v;
+      if (sessionIdx < visible.length) {
+        paintSessionRow(sessionIdx);
+      }
+    }
+    paintIndicator();
+  };
+  renderFromScratch();
+  term.hideCursor();
+  return await new Promise((resolve4) => {
+    let resolved = false;
+    const onResize = () => {
+      if (resolved) {
+        return;
+      }
+      renderFromScratch();
+    };
+    const cleanup = () => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      term.off("key", onKey);
+      term.off("resize", onResize);
+      term.grabInput(false);
+      term.hideCursor(false);
+      term.moveTo(1, indicatorRow() + 1);
+      term("\n");
+    };
+    const refresh = async (preferredId) => {
+      try {
+        const next = await listSessions(opts.config);
+        visible = sortSessions(next);
+        rebuildRows();
+        if (preferredId !== void 0) {
+          const idx = visible.findIndex((s) => s.sessionId === preferredId);
+          if (idx >= 0) {
+            selectedIdx = idx + 1;
+          }
+        }
+        if (selectedIdx > total - 1) {
+          selectedIdx = Math.max(0, total - 1);
+        }
+        if (scrollOffset + viewportSize > visible.length) {
+          scrollOffset = Math.max(0, visible.length - viewportSize);
+        }
+        adjustScroll();
+        renderFromScratch();
+      } catch (err) {
+        transientStatus = `refresh failed: ${err.message}`;
+        renderFromScratch();
+      }
+    };
+    const performAction = async (kind) => {
+      if (!pendingAction) {
+        return;
+      }
+      const target = pendingAction;
+      mode = "busy";
+      paintIndicator();
+      try {
+        if (kind === "kill") {
+          await killSession(opts.config, target.sessionId);
+        } else {
+          await deleteSession(opts.config, target.sessionId);
+        }
+        mode = "normal";
+        pendingAction = null;
+        await refresh(kind === "kill" ? target.sessionId : void 0);
+      } catch (err) {
+        mode = "normal";
+        pendingAction = null;
+        transientStatus = `${kind} failed: ${err.message}`;
+        paintIndicator();
+      }
+    };
+    const move = (delta) => {
+      const next = Math.min(total - 1, Math.max(0, selectedIdx + delta));
+      if (next === selectedIdx) {
+        return;
+      }
+      const old = selectedIdx;
+      const oldScroll = scrollOffset;
+      selectedIdx = next;
+      adjustScroll();
+      if (scrollOffset !== oldScroll) {
+        repaintViewport();
+        if (old === 0 || selectedIdx === 0) {
+          repaintNewItem();
+        }
+        return;
+      }
+      if (old === 0) {
+        repaintNewItem();
+      } else {
+        repaintSessionRow(old - 1);
+      }
+      if (selectedIdx === 0) {
+        repaintNewItem();
+      } else {
+        repaintSessionRow(selectedIdx - 1);
+      }
+    };
+    const clearTransient = () => {
+      if (transientStatus === null) {
+        return false;
+      }
+      transientStatus = null;
+      paintIndicator();
+      return true;
+    };
+    const onKey = (name, _matches, data) => {
+      if (mode === "busy") {
+        return;
+      }
+      if (mode === "confirm-kill" || mode === "confirm-delete") {
+        if (data?.isCharacter && (name === "y" || name === "Y")) {
+          const kind = mode === "confirm-kill" ? "kill" : "delete";
+          void performAction(kind);
+          return;
+        }
+        if (name === "ESCAPE" || name === "CTRL_C" || name === "ENTER" || name === "KP_ENTER" || data?.isCharacter && (name === "n" || name === "N")) {
+          mode = "normal";
+          pendingAction = null;
+          paintIndicator();
+          return;
+        }
+        return;
+      }
+      clearTransient();
+      if (data?.isCharacter) {
+        if (name === "r" || name === "R") {
+          const currentId = selectedIdx > 0 ? visible[selectedIdx - 1]?.sessionId : void 0;
+          void refresh(currentId);
+          return;
+        }
+        if ((name === "k" || name === "K") && selectedIdx > 0) {
+          const session = visible[selectedIdx - 1];
+          if (!session) {
+            return;
+          }
+          pendingAction = {
+            sessionId: session.sessionId,
+            cwd: session.cwd,
+            status: session.status
+          };
+          mode = "confirm-kill";
+          paintIndicator();
+          return;
+        }
+        if ((name === "d" || name === "D") && selectedIdx > 0) {
+          const session = visible[selectedIdx - 1];
+          if (!session) {
+            return;
+          }
+          if (session.status === "live") {
+            transientStatus = "session is live \u2014 press k to kill it first";
+            paintIndicator();
+            return;
+          }
+          pendingAction = {
+            sessionId: session.sessionId,
+            cwd: session.cwd,
+            status: session.status
+          };
+          mode = "confirm-delete";
+          paintIndicator();
+          return;
+        }
+        return;
+      }
+      switch (name) {
+        case "UP":
+        case "SHIFT_TAB":
+          move(-1);
+          return;
+        case "DOWN":
+        case "TAB":
+          move(1);
+          return;
+        case "PAGE_UP":
+          move(-viewportSize);
+          return;
+        case "PAGE_DOWN":
+          move(viewportSize);
+          return;
+        case "HOME":
+          move(-total);
+          return;
+        case "END":
+          move(total);
+          return;
+        case "ENTER":
+        case "KP_ENTER": {
+          cleanup();
+          if (selectedIdx === 0) {
+            resolve4({ kind: "new" });
+            return;
+          }
+          const session = visible[selectedIdx - 1];
+          if (!session) {
+            resolve4({ kind: "abort" });
+            return;
+          }
+          const result = {
+            kind: "attach",
+            sessionId: session.sessionId
+          };
+          if (session.agentId !== void 0) {
+            result.agentId = session.agentId;
+          }
+          resolve4(result);
+          return;
+        }
+        case "ESCAPE":
+        case "CTRL_C":
+          cleanup();
+          resolve4({ kind: "abort" });
+          return;
+      }
+    };
+    term.grabInput({});
+    term.on("key", onKey);
+    term.on("resize", onResize);
   });
-  const liveCount = sorted.filter((s) => s.status !== "cold").length;
-  const coldSlice = sorted.slice(liveCount, liveCount + opts.coldLimit);
-  const hiddenCold = sorted.length - liveCount - coldSlice.length;
-  const visible = [...sorted.slice(0, liveCount), ...coldSlice];
-  const rows = visible.map(toRow);
-  const widths = computeWidths(rows);
-  const newSessionLabel = `+ New session in ${opts.cwd}`;
-  const items = [newSessionLabel, ...rows.map((r) => formatRow(r, widths))];
-  term("\n");
-  term.bold("Select a session")("\n");
-  if (hiddenCold > 0) {
-    term.dim(`(${hiddenCold} older cold session${hiddenCold === 1 ? "" : "s"} hidden; use \`hydra-acp sessions --all\` to view)
-`);
-  }
-  term.dim(formatRow(HEADER, widths))("\n");
-  const onCtrlC = (name) => {
-    if (name === "CTRL_C") {
-      term.grabInput(false);
-      term("\n");
-      process.exit(130);
-    }
-  };
-  term.on("key", onCtrlC);
-  let response;
-  try {
-    response = await term.singleColumnMenu(items, {
-      cancelable: true,
-      exitOnUnexpectedKey: false,
-      selectedIndex: 0,
-      style: term.brightWhite,
-      selectedStyle: term.brightWhite.bgBlue,
-      keyBindings: {
-        ENTER: "submit",
-        KP_ENTER: "submit",
-        UP: "previous",
-        DOWN: "next",
-        TAB: "next",
-        SHIFT_TAB: "previous",
-        HOME: "first",
-        END: "last",
-        ESCAPE: "cancel",
-        CTRL_C: "cancel"
-      }
-    }).promise;
-  } finally {
-    term.off("key", onCtrlC);
-  }
-  term("\n");
-  if (response.canceled || response.selectedIndex === void 0) {
-    return { kind: "abort" };
-  }
-  if (response.selectedIndex === 0) {
-    return { kind: "new" };
-  }
-  const session = visible[response.selectedIndex - 1];
-  if (!session) {
-    return { kind: "abort" };
-  }
-  const result = {
-    kind: "attach",
-    sessionId: session.sessionId
-  };
-  if (session.agentId !== void 0) {
-    result.agentId = session.agentId;
-  }
-  return result;
-}
-function toRow(s) {
-  return {
-    session: stripHydraSessionPrefix(s.sessionId),
-    upstream: s.upstreamSessionId ?? "-",
-    status: s.status.toUpperCase(),
-    clients: s.status === "cold" ? "-" : String(s.attachedClients),
-    agent: s.agentId ?? "?",
-    title: s.title ?? "-",
-    cwd: s.cwd
-  };
 }
-function computeWidths(rows) {
-  return {
-    session: maxLen4(HEADER.session, rows.map((r) => r.session)),
-    upstream: maxLen4(HEADER.upstream, rows.map((r) => r.upstream)),
-    status: maxLen4(HEADER.status, rows.map((r) => r.status)),
-    clients: maxLen4(HEADER.clients, rows.map((r) => r.clients)),
-    agent: maxLen4(HEADER.agent, rows.map((r) => r.agent)),
-    title: maxLen4(HEADER.title, rows.map((r) => r.title))
-  };
+function readTermHeight(term) {
+  return term.height ?? 24;
 }
-function maxLen4(headerCell, values) {
-  let max = headerCell.length;
-  for (const v of values) {
-    if (v.length > max) {
-      max = v.length;
-    }
-  }
-  return max;
+function readTermWidth(term) {
+  return term.width ?? 80;
 }
-function formatRow(r, w) {
-  return [
-    r.session.padEnd(w.session),
-    r.upstream.padEnd(w.upstream),
-    r.status.padEnd(w.status),
-    r.clients.padStart(w.clients),
-    r.agent.padEnd(w.agent),
-    r.title.padEnd(w.title),
-    r.cwd
-  ].join("  ");
+function formatNewSessionLabel(cwd, maxWidth) {
+  const prefix = "+ New session in ";
+  const budget = Math.max(1, maxWidth - prefix.length);
+  return prefix + truncateMiddle(cwd, budget);
 }
-var HEADER;
+var ROW_PREFIX_WIDTH;
 var init_picker = __esm({
   "src/tui/picker.ts"() {
     "use strict";
+    init_session_row();
     init_session();
-    HEADER = {
-      session: "SESSION",
-      upstream: "UPSTREAM",
-      status: "STATUS",
-      clients: "CLIENTS",
-      agent: "AGENT",
-      title: "TITLE",
-      cwd: "CWD"
-    };
+    init_discovery();
+    ROW_PREFIX_WIDTH = 2;
   }
 });
 
 // src/tui/screen.ts
 import stringWidth from "string-width";
 import wrapAnsi from "wrap-ansi";
+function formattedLineSig(zone, width, line) {
+  if (!line) {
+    return `${zone}|${width}|empty`;
+  }
+  return `${zone}|${width}|${line.prefix ?? ""}|${line.prefixStyle ?? ""}|${line.body}|${line.bodyStyle ?? ""}|${line.ansi ? "1" : "0"}|${line.fillRow ? "1" : "0"}`;
+}
 function computePromptVisualRows(buffer, room) {
   const rows = [];
   for (let i = 0; i < buffer.length; i++) {
@@ -2348,16 +2984,16 @@ function writeStyled(term, text, style) {
       term.bold.red.noFormat(text);
       return;
     case "tool-status-pending":
-      term.dim.yellow.noFormat(text);
+      term.dim.noFormat(text);
       return;
     case "tool-status-running":
-      term.bold.yellow.noFormat(text);
+      term.brightYellow.noFormat(text);
       return;
     case "tool-status-cancelled":
       term.dim.noFormat(text);
       return;
     case "plan":
-      term.magenta.noFormat(text);
+      term.brightYellow.noFormat(text);
       return;
     case "plan-done":
       term.green.noFormat(text);
@@ -2406,6 +3042,12 @@ function wrap(text, width) {
   if (text.length === 0) {
     return [""];
   }
+  if (!NON_ASCII.test(text)) {
+    return wrapAscii(text, width);
+  }
+  return wrapVisible(text, width);
+}
+function wrapAscii(text, width) {
   const out = [];
   let remaining = text;
   while (remaining.length > width) {
@@ -2428,14 +3070,78 @@ function wrap(text, width) {
   out.push(remaining);
   return out;
 }
+function wrapVisible(text, width) {
+  const out = [];
+  const graphemes = [];
+  for (const { segment } of SEGMENTER.segment(text)) {
+    graphemes.push({ seg: segment, w: stringWidth(segment) });
+  }
+  let i = 0;
+  while (i < graphemes.length) {
+    let chunk = "";
+    let chunkW = 0;
+    let lastSpaceI = -1;
+    let chunkAtLastSpace = "";
+    while (i < graphemes.length) {
+      const g = graphemes[i];
+      if (chunkW + g.w > width) {
+        break;
+      }
+      if (g.seg === " ") {
+        lastSpaceI = i;
+        chunkAtLastSpace = chunk;
+      }
+      chunk += g.seg;
+      chunkW += g.w;
+      i += 1;
+    }
+    if (i >= graphemes.length) {
+      out.push(chunk);
+      break;
+    }
+    if (lastSpaceI >= 0) {
+      out.push(chunkAtLastSpace);
+      i = lastSpaceI + 1;
+    } else if (chunk.length === 0) {
+      out.push(graphemes[i].seg);
+      i += 1;
+    } else {
+      out.push(chunk);
+    }
+  }
+  return out;
+}
 function truncate(text, max) {
-  if (text.length <= max) {
+  if (max <= 0) {
+    return "";
+  }
+  if (text.length <= max && !NON_ASCII.test(text)) {
+    return text;
+  }
+  const visible = stringWidth(text);
+  if (visible <= max) {
     return text;
   }
   if (max <= 1) {
-    return text.slice(0, max);
+    return takeByWidth(text, max);
   }
-  return text.slice(0, max - 1) + "\u2026";
+  return takeByWidth(text, max - 1) + "\u2026";
+}
+function takeByWidth(text, budget) {
+  if (budget <= 0) {
+    return "";
+  }
+  let out = "";
+  let used = 0;
+  for (const { segment } of SEGMENTER.segment(text)) {
+    const w = stringWidth(segment);
+    if (used + w > budget) {
+      break;
+    }
+    out += segment;
+    used += w;
+  }
+  return out;
 }
 function firstLine2(text) {
   const idx = text.indexOf("\n");
@@ -2542,13 +3248,15 @@ function mapKeyName(name) {
       return "ctrl-u";
     case "CTRL_W":
       return "ctrl-w";
+    case "CTRL_Y":
+      return "ctrl-y";
     case "ESCAPE":
       return "escape";
     default:
       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, Screen, 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, shortId;
 var init_screen = __esm({
   "src/tui/screen.ts"() {
     "use strict";
@@ -2562,6 +3270,7 @@ var init_screen = __esm({
     MAX_COMPLETION_ROWS = 6;
     CONFIRM_PROMPT_ROWS = 2;
     DEFAULT_CONTENT_REPAINT_THROTTLE_MS = 1e3;
+    DEFAULT_MAX_SCROLLBACK_LINES = 1e4;
     Screen = class {
       term;
       dispatcher;
@@ -2582,6 +3291,27 @@ var init_screen = __esm({
       lastRepaintAt = 0;
       throttledRepaintTimer = null;
       contentRepaintThrottleMs;
+      maxScrollbackLines;
+      // Wrap memoization: each FormattedLine that lands in this.lines gets a
+      // monotonic id assigned via trackLine(); wrapCache holds the pre-wrapped
+      // FormattedLine[] for that id at wrapCacheWidth. Width changes flush the
+      // whole cache; in-place body mutation (streaming) and splices invalidate
+      // affected ids. Result: steady-state repaints only wrap newly-appended
+      // lines, not the entire history.
+      nextLineId = 1;
+      lineIds = /* @__PURE__ */ new WeakMap();
+      wrapCache = /* @__PURE__ */ new Map();
+      wrapCacheWidth = 0;
+      // 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
+      // signature matches the previous frame. Eliminates flicker during
+      // the 1Hz busy-tick: only rows whose content actually changed
+      // (banner elapsed, tools-block summary) get re-emitted instead of
+      // every visible row. Cleared on dimension change.
+      lastFrameRows = /* @__PURE__ */ new Map();
+      lastFrameW = 0;
+      lastFrameH = 0;
       permissionPrompt = null;
       confirmPrompt = null;
       completions = [];
@@ -2596,6 +3326,7 @@ var init_screen = __esm({
         queued: 0
       };
       header = { agent: "?", cwd: "?", sessionId: "?" };
+      lastWindowTitle = null;
       resizeHandler;
       keyHandler;
       mouseHandler;
@@ -2616,6 +3347,7 @@ var init_screen = __esm({
         this.dispatcher = opts.dispatcher;
         this.onKey = opts.onKey;
         this.contentRepaintThrottleMs = opts.repaintThrottleMs ?? DEFAULT_CONTENT_REPAINT_THROTTLE_MS;
+        this.maxScrollbackLines = opts.maxScrollbackLines ?? DEFAULT_MAX_SCROLLBACK_LINES;
         this.resizeHandler = () => this.repaint();
         this.keyHandler = (name, _matches, data) => this.handleKey(name, data);
         this.mouseHandler = (name) => this.handleMouse(name);
@@ -2627,6 +3359,11 @@ var init_screen = __esm({
         }
         this.started = true;
         this.term.fullscreen(true);
+        this.lastFrameRows.clear();
+        this.lastFrameW = 0;
+        this.lastFrameH = 0;
+        this.lastWindowTitle = null;
+        process.stdout.write("\x1B[?7l");
         this.term.grabInput({ mouse: "button" });
         this.term.hideCursor(false);
         this.term.on("key", this.keyHandler);
@@ -2646,6 +3383,7 @@ var init_screen = __esm({
         this.term.off("resize", this.resizeHandler);
         this.term.grabInput(false);
         this.term.hideCursor(false);
+        process.stdout.write("\x1B[?7h");
         this.term.fullscreen(false);
         this.term("\n");
       }
@@ -2716,13 +3454,17 @@ var init_screen = __esm({
         }
         this.streamingActive = false;
         this.lines.push(...lines);
+        this.trackLines(lines);
         this.adjustScrollForLineChange(lines.length);
+        this.trimScrollback();
         this.scheduleRepaint();
       }
       appendLine(line) {
         this.streamingActive = false;
         this.lines.push(line);
+        this.trackLine(line);
         this.adjustScrollForLineChange(1);
+        this.trimScrollback();
         this.scheduleRepaint();
       }
       // When scrolled away from the bottom, shift scrollOffset to keep the
@@ -2734,6 +3476,40 @@ var init_screen = __esm({
           this.scrollOffset = Math.max(0, this.scrollOffset + delta);
         }
       }
+      trackLine(line) {
+        this.lineIds.set(line, this.nextLineId++);
+      }
+      trackLines(lines) {
+        for (const line of lines) {
+          this.trackLine(line);
+        }
+      }
+      forgetLine(line) {
+        const id = this.lineIds.get(line);
+        if (id !== void 0) {
+          this.wrapCache.delete(id);
+        }
+      }
+      // Drop oldest lines once scrollback exceeds the configured cap. Removes
+      // their wrap-cache entries and shifts keyedBlocks indices in sync;
+      // blocks whose lines fully fell off the head are dropped (a later
+      // upsert for that key will start a fresh block at the bottom).
+      trimScrollback() {
+        const overflow = this.lines.length - this.maxScrollbackLines;
+        if (overflow <= 0) {
+          return;
+        }
+        const removed = this.lines.splice(0, overflow);
+        for (const line of removed) {
+          this.forgetLine(line);
+        }
+        for (const [key, range] of [...this.keyedBlocks.entries()]) {
+          range.start -= overflow;
+          if (range.start < 0) {
+            this.keyedBlocks.delete(key);
+          }
+        }
+      }
       // Append-or-replace a single-line block keyed by `key`. Thin wrapper
       // around upsertLines for the common one-row case (tool calls).
       upsertLine(key, line) {
@@ -2755,7 +3531,15 @@ var init_screen = __esm({
           touchesEnd = oldEnd >= this.lines.length;
           const delta = newLines.length - existing.count;
           scrollDelta = delta;
-          this.lines.splice(existing.start, existing.count, ...newLines);
+          const removed = this.lines.splice(
+            existing.start,
+            existing.count,
+            ...newLines
+          );
+          for (const line of removed) {
+            this.forgetLine(line);
+          }
+          this.trackLines(newLines);
           existing.count = newLines.length;
           if (delta !== 0) {
             for (const [k, range] of this.keyedBlocks) {
@@ -2772,11 +3556,13 @@ var init_screen = __esm({
             count: newLines.length
           });
           this.lines.push(...newLines);
+          this.trackLines(newLines);
         }
         if (touchesEnd) {
           this.streamingActive = false;
         }
         this.adjustScrollForLineChange(scrollDelta);
+        this.trimScrollback();
         this.scheduleRepaint();
       }
       // Append fragments of a streaming message (e.g. agent_message_chunk). The
@@ -2793,6 +3579,7 @@ var init_screen = __esm({
         if (this.streamingActive && this.lines.length > 0) {
           const last = this.lines[this.lines.length - 1];
           if (last) {
+            this.forgetLine(last);
             last.body += first ?? "";
           }
         } else {
@@ -2800,7 +3587,9 @@ var init_screen = __esm({
             const last = this.lines[this.lines.length - 1];
             const isBlank = last && last.body === "" && (!last.prefix || last.prefix === "");
             if (!isBlank) {
-              this.lines.push({ body: "" });
+              const sep = { body: "" };
+              this.lines.push(sep);
+              this.trackLine(sep);
               added += 1;
             }
           }
@@ -2813,25 +3602,48 @@ var init_screen = __esm({
             initial.prefixStyle = prefixStyle;
           }
           this.lines.push(initial);
+          this.trackLine(initial);
           added += 1;
         }
         const continuationPrefix = " ".repeat(prefix.length);
         for (const piece of rest) {
-          this.lines.push({
+          const cont = {
             prefix: continuationPrefix,
             body: piece,
             bodyStyle
-          });
+          };
+          this.lines.push(cont);
+          this.trackLine(cont);
           added += 1;
         }
         this.streamingActive = true;
         this.adjustScrollForLineChange(added);
+        this.trimScrollback();
         this.scheduleRepaint();
       }
       setHeader(header) {
         this.header = { ...this.header, ...header };
+        this.syncWindowTitle();
         this.repaint();
       }
+      // Push the current session title (or short session id, as fallback) to
+      // the host terminal via OSC 2. Supported by xterm/foot/iTerm2/Alacritty/
+      // most modern emulators; ignored harmlessly elsewhere.
+      syncWindowTitle() {
+        const title = this.header.title?.trim();
+        const fallback = shortId(this.header.sessionId) || "hydra";
+        const raw = title && title.length > 0 ? title : fallback;
+        const clean = raw.replace(/[\x00-\x1f\x7f]/g, "").slice(0, 200);
+        if (clean === this.lastWindowTitle) {
+          return;
+        }
+        this.lastWindowTitle = clean;
+        process.stdout.write(`\x1B]2;${clean}\x1B\\`);
+      }
+      clearWindowTitle() {
+        this.lastWindowTitle = null;
+        process.stdout.write("\x1B]2;\x1B\\");
+      }
       setBanner(banner) {
         this.banner = { ...this.banner, ...banner };
         this.drawBanner();
@@ -2840,6 +3652,8 @@ var init_screen = __esm({
       clearScrollback() {
         this.lines = [];
         this.keyedBlocks.clear();
+        this.wrapCache.clear();
+        this.wrapCacheWidth = 0;
         this.streamingActive = false;
         this.scrollOffset = 0;
         this.repaint();
@@ -2862,7 +3676,10 @@ var init_screen = __esm({
           return;
         }
         const touchesEnd = existing.start + existing.count >= this.lines.length;
-        this.lines.splice(existing.start, existing.count);
+        const removed = this.lines.splice(existing.start, existing.count);
+        for (const line of removed) {
+          this.forgetLine(line);
+        }
         this.keyedBlocks.delete(key);
         for (const [, range] of this.keyedBlocks) {
           if (range.start > existing.start) {
@@ -2878,6 +3695,22 @@ var init_screen = __esm({
       redraw() {
         this.repaint();
       }
+      // Forced clean-slate repaint. Drops the per-row signature cache, the
+      // window-title cache, the wrap cache, and clears the terminal before
+      // painting. Wired to ^L so the user can recover when something has
+      // corrupted the visible state and the per-row sig check otherwise
+      // short-circuits the re-emit.
+      fullRedraw() {
+        this.lastFrameRows.clear();
+        this.lastFrameW = 0;
+        this.lastFrameH = 0;
+        this.lastWindowTitle = null;
+        this.wrapCache.clear();
+        this.wrapCacheWidth = 0;
+        process.stdout.write("\x1B[?7l");
+        this.term.clear();
+        this.repaint();
+      }
       // While paused, append* methods buffer state but don't repaint. Calls are
       // counter-based so they nest safely. Resume triggers exactly one repaint
       // if any was requested while paused.
@@ -2936,9 +3769,12 @@ var init_screen = __esm({
         if (last && last.body === "" && (last.prefix === void 0 || last.prefix === "")) {
           return;
         }
-        this.lines.push({ body: "" });
+        const sep = { body: "" };
+        this.lines.push(sep);
+        this.trackLine(sep);
         this.streamingActive = false;
         this.adjustScrollForLineChange(1);
+        this.trimScrollback();
         this.scheduleRepaint();
       }
       // The dispatcher is the source of truth for prompt state. If the prompt
@@ -3010,9 +3846,11 @@ var init_screen = __esm({
         return Math.max(0, bottom - top + 1);
       }
       maxScrollOffset() {
-        const wrapped = this.wrapLines(this.lines, this.term.width);
-        const visible = this.scrollbackVisibleRows();
-        return Math.max(0, wrapped.length - visible);
+        const { rows } = this.wrapTail(
+          this.term.width,
+          Number.POSITIVE_INFINITY
+        );
+        return Math.max(0, rows.length - this.scrollbackVisibleRows());
       }
       // Used by content mutators to coalesce rapid updates. Repaints fire
       // at most once per contentRepaintThrottleMs; if a paint happened
@@ -3045,6 +3883,22 @@ var init_screen = __esm({
           this.repaint();
         }, this.contentRepaintThrottleMs - elapsed);
       }
+      // Funnel for every row that any drawX method renders. Skips emitting
+      // moveTo+eraseLineAfter+paint when the row's signature matches the
+      // previous frame's. The signature must capture everything that affects
+      // visible output for that row (width, FormattedLine fields, banner
+      // state, etc.) so identical sigs guarantee identical bytes.
+      paintRow(row, signature, paint) {
+        if (row < 1 || row > this.term.height) {
+          return;
+        }
+        if (this.lastFrameRows.get(row) === signature) {
+          return;
+        }
+        this.lastFrameRows.set(row, signature);
+        this.term.moveTo(1, row).eraseLineAfter();
+        paint();
+      }
       repaint() {
         if (this.repaintPaused > 0) {
           this.repaintPending = true;
@@ -3060,6 +3914,11 @@ var init_screen = __esm({
         if (w < 20 || h < 8) {
           return;
         }
+        if (w !== this.lastFrameW || h !== this.lastFrameH) {
+          this.lastFrameRows.clear();
+          this.lastFrameW = w;
+          this.lastFrameH = h;
+        }
         this.drawHeader();
         this.drawSeparator(HEADER_ROWS);
         this.drawScrollback();
@@ -3075,38 +3934,40 @@ var init_screen = __esm({
       }
       drawHeader() {
         const w = this.term.width;
-        this.term.moveTo(1, 1).eraseLineAfter();
         const usage = formatUsage(this.header.usage);
         const sid = shortId(this.header.sessionId);
         const title = this.header.title?.trim();
-        const fixed = "hydra \xB7 ".length + this.header.agent.length + " \xB7 ".length + " \xB7 ".length + sid.length + (title ? " \xB7 ".length : 0) + (usage ? usage.length + 3 : 0);
-        const variableRoom = Math.max(8, w - fixed);
-        let cwdRoom;
-        let titleRoom;
-        if (title) {
-          const cwdCap = Math.max(8, Math.floor(variableRoom / 2));
-          cwdRoom = Math.min(this.header.cwd.length, cwdCap);
-          titleRoom = Math.max(8, variableRoom - cwdRoom);
-        } else {
-          titleRoom = 0;
-          cwdRoom = variableRoom;
-        }
-        this.term.bold("hydra")(" \xB7 ").cyan(this.header.agent)(" \xB7 ").dim(truncate(this.header.cwd, cwdRoom))(" \xB7 ").yellow(sid);
-        if (title) {
-          this.term(" \xB7 ").bold(truncate(title, titleRoom));
-        }
-        if (usage) {
-          const col = Math.max(1, w - usage.length + 1);
-          this.term.moveTo(col, 1);
-          this.term.dim(usage);
-        }
+        const sig = `hdr|${w}|${this.header.agent}|${this.header.cwd}|${sid}|${title ?? ""}|${usage ?? ""}`;
+        this.paintRow(1, sig, () => {
+          const fixed = "hydra \xB7 ".length + this.header.agent.length + " \xB7 ".length + " \xB7 ".length + sid.length + (title ? " \xB7 ".length : 0) + (usage ? usage.length + 3 : 0);
+          const variableRoom = Math.max(8, w - fixed);
+          let cwdRoom;
+          let titleRoom;
+          if (title) {
+            const cwdMin = Math.min(this.header.cwd.length, 12);
+            const titleCap = Math.max(8, variableRoom - cwdMin);
+            titleRoom = Math.min(title.length, titleCap);
+            cwdRoom = Math.max(8, variableRoom - titleRoom);
+          } else {
+            titleRoom = 0;
+            cwdRoom = variableRoom;
+          }
+          this.term.bold("hydra")(" \xB7 ").cyan.noFormat(this.header.agent)(" \xB7 ").dim.noFormat(truncate(this.header.cwd, cwdRoom))(" \xB7 ").yellow(sid);
+          if (title) {
+            this.term(" \xB7 ").bold.noFormat(truncate(title, titleRoom));
+          }
+          if (usage) {
+            const col = Math.max(1, w - usage.length + 1);
+            this.term.moveTo(col, 1);
+            this.term.dim(usage);
+          }
+        });
       }
       drawSeparator(row) {
-        if (row < 1 || row > this.term.height) {
-          return;
-        }
-        this.term.moveTo(1, row).eraseLineAfter();
-        this.term.dim("\u2500".repeat(this.term.width));
+        const w = this.term.width;
+        this.paintRow(row, `sep|${w}`, () => {
+          this.term.dim("\u2500".repeat(w));
+        });
       }
       drawScrollback() {
         const w = this.term.width;
@@ -3115,21 +3976,30 @@ var init_screen = __esm({
         if (visibleRows <= 0) {
           return;
         }
-        const wrapped = this.wrapLines(this.lines, w);
-        const max = Math.max(0, wrapped.length - visibleRows);
-        if (this.scrollOffset > max) {
-          this.scrollOffset = max;
+        const { rows: wrapped, exhausted } = this.wrapTail(
+          w,
+          visibleRows + this.scrollOffset
+        );
+        if (exhausted) {
+          const max = Math.max(0, wrapped.length - visibleRows);
+          if (this.scrollOffset > max) {
+            this.scrollOffset = max;
+          }
         }
         const end = wrapped.length - this.scrollOffset;
         const start = Math.max(0, end - visibleRows);
         const slice = wrapped.slice(start, end);
+        const padTop = Math.max(0, visibleRows - slice.length);
         for (let i = 0; i < visibleRows; i++) {
           const row = top + i;
-          this.term.moveTo(1, row).eraseLineAfter();
-          const line = slice[i];
-          if (line) {
-            this.writeFormattedLine(line, w);
-          }
+          const sliceIdx = i - padTop;
+          const line = sliceIdx >= 0 ? slice[sliceIdx] : void 0;
+          const sig = formattedLineSig("sb", w, line);
+          this.paintRow(row, sig, () => {
+            if (line) {
+              this.writeFormattedLine(line, w);
+            }
+          });
         }
       }
       queuedRows() {
@@ -3160,26 +4030,27 @@ var init_screen = __esm({
         }
         for (let i = 0; i < rows; i++) {
           const row = completionTop + i;
-          this.term.moveTo(1, row).eraseLineAfter();
           const item = this.completions[i];
-          if (!item) {
-            continue;
-          }
           const isLast = i === rows - 1 && this.completions.length > MAX_COMPLETION_ROWS;
-          if (isLast) {
-            this.term.dim(
-              `  + ${this.completions.length - MAX_COMPLETION_ROWS + 1} more match(es)`
-            );
-            continue;
-          }
-          const namePadded = item.name.padEnd(nameWidth);
-          const desc = item.description ?? "";
-          const remaining = w - namePadded.length - 4;
-          const truncated = remaining > 0 ? truncate(desc, remaining) : "";
-          this.term("  ").brightCyan(namePadded);
-          if (truncated.length > 0) {
-            this.term("  ").dim(truncated);
-          }
+          const overflow = this.completions.length - MAX_COMPLETION_ROWS + 1;
+          const sig = item ? isLast ? `comp|${w}|overflow|${overflow}` : `comp|${w}|${nameWidth}|${item.name}|${item.description ?? ""}` : `comp|${w}|empty`;
+          this.paintRow(row, sig, () => {
+            if (!item) {
+              return;
+            }
+            if (isLast) {
+              this.term.dim(`  + ${overflow} more match(es)`);
+              return;
+            }
+            const namePadded = item.name.padEnd(nameWidth);
+            const desc = item.description ?? "";
+            const remaining = w - namePadded.length - 4;
+            const truncated = remaining > 0 ? truncate(desc, remaining) : "";
+            this.term("  ").brightCyan(namePadded);
+            if (truncated.length > 0) {
+              this.term("  ").dim(truncated);
+            }
+          });
         }
       }
       drawQueuedZone() {
@@ -3194,17 +4065,19 @@ var init_screen = __esm({
         const queuedTop = queuedBottom - rows + 1;
         for (let i = 0; i < rows; i++) {
           const row = queuedTop + i;
-          this.term.moveTo(1, row).eraseLineAfter();
           const text = this.queuedTexts[i];
-          if (text === void 0) {
-            continue;
-          }
           const isLast = i === rows - 1 && this.queuedTexts.length > MAX_QUEUED_ROWS;
           const overflow = this.queuedTexts.length - MAX_QUEUED_ROWS;
-          const summary = isLast ? `+ ${overflow + 1} more queued` : truncate(firstLine2(text), w - 4);
-          const display = ` \u23F3 ${summary}`;
-          const padded = display + " ".repeat(Math.max(0, w - display.length));
-          this.term.bgBlue.brightWhite.noFormat(padded);
+          const summary = text === void 0 ? "" : isLast ? `+ ${overflow + 1} more queued` : truncate(firstLine2(text), w - 4);
+          const sig = text === void 0 ? `queued|${w}|empty` : `queued|${w}|${isLast ? "ovf" : "row"}|${summary}`;
+          this.paintRow(row, sig, () => {
+            if (text === void 0) {
+              return;
+            }
+            const display = ` \u23F3 ${summary}`;
+            const padded = display + " ".repeat(Math.max(0, w - display.length));
+            this.term.bgBlue.brightWhite.noFormat(padded);
+          });
         }
       }
       drawPrompt() {
@@ -3225,19 +4098,30 @@ var init_screen = __esm({
         for (let i = 0; i < layout.rendered; i++) {
           const vr = visualRows[layout.windowStart + i];
           const row = top + i;
-          this.term.moveTo(1, row).eraseLineAfter();
-          if (!vr) {
-            continue;
-          }
-          if (vr.bufferIdx === 0 && vr.startCol === 0) {
-            this.term.brightWhite("> ");
-          } else if (vr.startCol === 0) {
-            this.term.dim("\xB7 ");
-          } else {
-            this.term("  ");
+          let gutter = "wrap";
+          let slice = "";
+          if (vr) {
+            if (vr.bufferIdx === 0 && vr.startCol === 0) {
+              gutter = "first";
+            } else if (vr.startCol === 0) {
+              gutter = "newline";
+            }
+            slice = (state.buffer[vr.bufferIdx] ?? "").slice(vr.startCol, vr.endCol);
           }
-          const line = state.buffer[vr.bufferIdx] ?? "";
-          this.term.noFormat(line.slice(vr.startCol, vr.endCol));
+          const sig = vr ? `prompt|${this.term.width}|${gutter}|${slice}` : `prompt|${this.term.width}|empty`;
+          this.paintRow(row, sig, () => {
+            if (!vr) {
+              return;
+            }
+            if (gutter === "first") {
+              this.term.brightWhite("> ");
+            } else if (gutter === "newline") {
+              this.term.dim("\xB7 ");
+            } else {
+              this.term("  ");
+            }
+            this.term.noFormat(slice);
+          });
         }
       }
       drawConfirmPrompt() {
@@ -3247,10 +4131,12 @@ var init_screen = __esm({
         }
         const w = this.term.width;
         const top = this.term.height - CONFIRM_PROMPT_ROWS - BANNER_ROWS + 1;
-        this.term.moveTo(1, top).eraseLineAfter();
-        this.term.brightYellow(` ? ${truncate(spec.question, w - 4)}`);
-        this.term.moveTo(1, top + 1).eraseLineAfter();
-        this.term.dim(` ${truncate(spec.hint, w - 2)}`);
+        this.paintRow(top, `confirm|q|${w}|${spec.question}`, () => {
+          this.term.brightYellow(` ? ${truncate(spec.question, w - 4)}`);
+        });
+        this.paintRow(top + 1, `confirm|h|${w}|${spec.hint}`, () => {
+          this.term.dim(` ${truncate(spec.hint, w - 2)}`);
+        });
       }
       drawPermissionPrompt() {
         const spec = this.permissionPrompt;
@@ -3261,21 +4147,20 @@ var init_screen = __esm({
         const rows = this.permissionRows();
         const top = this.term.height - rows - BANNER_ROWS + 1;
         let row = top;
-        const writeRow = (paint) => {
+        const writeRow = (sig, paint) => {
           if (row >= top + rows) {
             return;
           }
-          this.term.moveTo(1, row).eraseLineAfter();
-          paint();
+          this.paintRow(row, sig, paint);
           row += 1;
         };
-        writeRow(() => {
+        writeRow(`perm|t|${w}|${spec.title}`, () => {
           this.term.brightYellow(` \u{1F512} ${truncate(spec.title, w - 5)}`);
         });
-        writeRow(() => {
+        writeRow(`perm|sub|${w}`, () => {
           this.term.dim(" This action requires approval");
         });
-        writeRow(() => {
+        writeRow(`perm|q|${w}`, () => {
           this.term(" Do you want to proceed?");
         });
         for (let i = 0; i < spec.options.length; i++) {
@@ -3289,7 +4174,7 @@ var init_screen = __esm({
           const isSel = i === spec.selectedIndex;
           const marker = isSel ? "\u276F" : " ";
           const body = ` ${marker} ${i + 1}. ${truncate(opt.label, w - 8)}`;
-          writeRow(() => {
+          writeRow(`perm|o|${w}|${i}|${isSel ? "1" : "0"}|${opt.label}`, () => {
             if (isSel) {
               this.term.brightCyan(body);
             } else {
@@ -3297,38 +4182,42 @@ var init_screen = __esm({
             }
           });
         }
-        writeRow(() => {
+        writeRow(`perm|hint|${w}`, () => {
           this.term.dim(" \u2191/\u2193 choose \xB7 Enter submit \xB7 Esc cancel \xB7 1\u20139 quick-pick");
         });
       }
       drawBanner() {
         const row = this.term.height;
-        this.term.moveTo(1, row).eraseLineAfter();
-        const dot = this.banner.status === "running" ? "\u25CF" : "\u25CB";
-        const planLabel = this.banner.planMode ? "plan: ON " : "plan: off";
-        if (this.banner.status === "running") {
-          this.term.brightYellow(`${dot} ${this.banner.status}`);
-          if (this.banner.elapsedMs !== void 0 && this.banner.elapsedMs >= 1e3) {
-            this.term(" ").dim(formatElapsed(this.banner.elapsedMs));
+        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}`;
+        this.paintRow(row, sig, () => {
+          const dot = this.banner.status === "busy" ? "\u25CF" : "\u25CB";
+          const planLabel = this.banner.planMode ? "plan: ON " : "plan: off";
+          if (this.banner.status === "busy") {
+            this.term.brightYellow(`${dot} ${this.banner.status}`);
+            if (elapsedStr) {
+              this.term(" ").dim(elapsedStr);
+            }
+          } else if (this.banner.status === "disconnected") {
+            this.term.brightRed(`${dot} ${this.banner.status}`);
+          } else {
+            this.term.brightGreen(`${dot} ${this.banner.status}`);
           }
-        } else if (this.banner.status === "disconnected") {
-          this.term.brightRed(`${dot} ${this.banner.status}`);
-        } else {
-          this.term.brightGreen(`${dot} ${this.banner.status}`);
-        }
-        if (this.banner.queued > 0) {
-          this.term(" \xB7 ").brightYellow(`${this.banner.queued} queued`);
-        }
-        if (this.scrollOffset > 0) {
-          this.term(" \xB7 ").brightCyan(`\u2191 ${this.scrollOffset}`);
-        }
-        this.term(" \xB7 ");
-        if (this.banner.planMode) {
-          this.term.brightMagenta(planLabel);
-        } else {
-          this.term.dim(planLabel);
-        }
-        this.term(" \xB7 ").dim(this.banner.hint);
+          if (this.banner.queued > 0) {
+            this.term(" \xB7 ").brightYellow(`${this.banner.queued} queued`);
+          }
+          if (this.scrollOffset > 0) {
+            this.term(" \xB7 ").brightCyan(`\u2191 ${this.scrollOffset}`);
+          }
+          this.term(" \xB7 ");
+          if (this.banner.planMode) {
+            this.term.brightYellow(planLabel);
+          } else {
+            this.term.dim(planLabel);
+          }
+          this.term(" \xB7 ").dim(this.banner.hint);
+        });
       }
       placeCursor() {
         if (this.permissionPrompt) {
@@ -3378,37 +4267,83 @@ var init_screen = __esm({
           4 + this.permissionPrompt.options.length
         );
       }
-      wrapLines(lines, width) {
+      // Walk this.lines from the tail, accumulating wrapped rows via the
+      // wrap cache, until we have at least `needed` rows or run out. Returns
+      // the collected rows in original (top-down) order plus an `exhausted`
+      // flag that's true iff we reached the head of this.lines. The hot path
+      // (drawScrollback) only ever asks for `visibleRows + scrollOffset`
+      // rows, so a 10k-line scrollback costs ~50 cache hits per repaint
+      // instead of 10k. With `needed = Infinity` this walks everything and
+      // doubles as a total-row counter for maxScrollOffset.
+      wrapTail(width, needed) {
         if (width <= 4) {
-          return lines;
+          const take = Math.min(needed, this.lines.length);
+          return {
+            rows: this.lines.slice(this.lines.length - take),
+            exhausted: needed >= this.lines.length
+          };
         }
-        const out = [];
-        for (const line of lines) {
-          const prefix = line.prefix ?? "";
-          const room = Math.max(1, width - prefix.length);
-          const chunks = line.ansi ? wrapAnsiBody(line.body, room) : wrap(line.body, room);
-          for (let i = 0; i < chunks.length; i++) {
-            const chunk = chunks[i] ?? "";
-            const wrappedLine = {
-              prefix: i === 0 ? line.prefix : " ".repeat(prefix.length),
-              body: chunk
-            };
-            if (line.prefixStyle !== void 0) {
-              wrappedLine.prefixStyle = line.prefixStyle;
-            }
-            if (line.bodyStyle !== void 0) {
-              wrappedLine.bodyStyle = line.bodyStyle;
-            }
-            if (line.fillRow) {
-              wrappedLine.fillRow = true;
-            }
-            if (line.ansi) {
-              wrappedLine.ansi = true;
-            }
-            out.push(wrappedLine);
+        if (this.wrapCacheWidth !== width) {
+          this.wrapCache.clear();
+          this.wrapCacheWidth = width;
+        }
+        if (needed <= 0 || this.lines.length === 0) {
+          return { rows: [], exhausted: true };
+        }
+        const batches = [];
+        let total = 0;
+        let stoppedAt = 0;
+        for (let i = this.lines.length - 1; i >= 0; i--) {
+          const wrapped = this.wrapOne(this.lines[i], width);
+          batches.push(wrapped);
+          total += wrapped.length;
+          stoppedAt = i;
+          if (total >= needed) {
+            break;
+          }
+        }
+        const rows = [];
+        for (let i = batches.length - 1; i >= 0; i--) {
+          rows.push(...batches[i]);
+        }
+        return { rows, exhausted: stoppedAt === 0 };
+      }
+      wrapOne(line, width) {
+        const id = this.lineIds.get(line);
+        if (id !== void 0) {
+          const cached = this.wrapCache.get(id);
+          if (cached) {
+            return cached;
+          }
+        }
+        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 wrapped = [];
+        for (let i = 0; i < chunks.length; i++) {
+          const chunk = chunks[i] ?? "";
+          const wrappedLine = {
+            prefix: i === 0 ? line.prefix : " ".repeat(prefix.length),
+            body: chunk
+          };
+          if (line.prefixStyle !== void 0) {
+            wrappedLine.prefixStyle = line.prefixStyle;
           }
+          if (line.bodyStyle !== void 0) {
+            wrappedLine.bodyStyle = line.bodyStyle;
+          }
+          if (line.fillRow) {
+            wrappedLine.fillRow = true;
+          }
+          if (line.ansi) {
+            wrappedLine.ansi = true;
+          }
+          wrapped.push(wrappedLine);
+        }
+        if (id !== void 0) {
+          this.wrapCache.set(id, wrapped);
         }
-        return out;
+        return wrapped;
       }
       writeFormattedLine(line, width) {
         if (line.prefix) {
@@ -3429,6 +4364,8 @@ var init_screen = __esm({
         }
       }
     };
+    NON_ASCII = /[^\x20-\x7e]/;
+    SEGMENTER = new Intl.Segmenter(void 0, { granularity: "grapheme" });
     shortId = stripHydraSessionPrefix;
   }
 });
@@ -3447,6 +4384,10 @@ var init_input = __esm({
       savedDraft = null;
       history = [];
       turnRunning = false;
+      // Single-slot kill ring. The most recent killed text (^U, ^K, ^W) lands
+      // here so ^Y can yank it back. Standard readline keeps a stack; we
+      // only keep one slot because that's what 99% of yank uses look like.
+      killBuffer = "";
       constructor(opts = {}) {
         this.history = [...opts.history ?? []];
         this.planMode = opts.planMode ?? false;
@@ -3555,6 +4496,9 @@ var init_input = __esm({
           case "ctrl-w":
             this.killWord();
             return [];
+          case "ctrl-y":
+            this.yank();
+            return [];
           case "escape":
             return [];
         }
@@ -3648,11 +4592,19 @@ var init_input = __esm({
       }
       killLine() {
         const line = this.currentLine();
+        const killed = line.slice(0, this.col);
+        if (killed.length > 0) {
+          this.killBuffer = killed;
+        }
         this.setCurrentLine(line.slice(this.col));
         this.col = 0;
       }
       killToEnd() {
         const line = this.currentLine();
+        const killed = line.slice(this.col);
+        if (killed.length > 0) {
+          this.killBuffer = killed;
+        }
         this.setCurrentLine(line.slice(0, this.col));
       }
       killWord() {
@@ -3668,9 +4620,19 @@ var init_input = __esm({
         while (i > 0 && !/\s/.test(line[i - 1] ?? "")) {
           i -= 1;
         }
+        const killed = line.slice(i, this.col);
+        if (killed.length > 0) {
+          this.killBuffer = killed;
+        }
         this.setCurrentLine(line.slice(0, i) + line.slice(this.col));
         this.col = i;
       }
+      yank() {
+        if (this.killBuffer.length === 0) {
+          return;
+        }
+        this.insertText(this.killBuffer);
+      }
       moveLeft() {
         if (this.col > 0) {
           this.col -= 1;
@@ -3821,10 +4783,28 @@ function mapUpdate(update) {
 }
 function mapSessionInfo(u) {
   const title = readString(u, "title");
-  if (title === void 0) {
+  const meta = u._meta;
+  let agentId;
+  if (meta && typeof meta === "object" && !Array.isArray(meta)) {
+    const ns = meta["hydra-acp"];
+    if (ns && typeof ns === "object" && !Array.isArray(ns)) {
+      const candidate = ns.agentId;
+      if (typeof candidate === "string") {
+        agentId = candidate;
+      }
+    }
+  }
+  if (title === void 0 && agentId === void 0) {
     return null;
   }
-  return { kind: "session-info", title };
+  const event = { kind: "session-info" };
+  if (title !== void 0) {
+    event.title = title;
+  }
+  if (agentId !== void 0) {
+    event.agentId = agentId;
+  }
+  return event;
 }
 function mapAvailableCommands(u) {
   const list = u.availableCommands ?? u.commands;
@@ -4228,8 +5208,9 @@ function formatToolLine(state) {
     title = `${initial} \xB7 ${latest}`;
   }
   return {
-    prefix: "  ",
-    body: `${toolStatusIcon(state.status)} ${title}`,
+    prefix: `  ${toolStatusIcon(state.status)} `,
+    prefixStyle: toolIconStyle(state.status),
+    body: title,
     bodyStyle: toolStatusStyle(state.status)
   };
 }
@@ -4254,6 +5235,22 @@ function toolStatusIcon(status) {
       return "\u25D0";
   }
 }
+function toolIconStyle(status) {
+  switch (status) {
+    case "completed":
+    case "succeeded":
+    case "ok":
+      return "tool-status-ok";
+    case "failed":
+    case "error":
+    case "rejected":
+      return "tool-status-fail";
+    case "cancelled":
+      return "tool-status-cancelled";
+    default:
+      return "tool-status-running";
+  }
+}
 function formatPlan(event) {
   if (event.entries.length === 0) {
     return [
@@ -4333,23 +5330,32 @@ var init_format = __esm({
 });
 
 // src/tui/app.ts
+import { appendFileSync, statSync, renameSync } from "fs";
 import { nanoid as nanoid3 } from "nanoid";
 import termkit from "terminal-kit";
 async function runTuiApp(opts) {
   const config = await ensureConfig();
   await ensureDaemonReachable(config);
   const term = termkit.terminal;
+  const exitHint = {};
   let nextOpts = opts;
   while (nextOpts !== null) {
-    nextOpts = await runSession(term, config, nextOpts);
+    nextOpts = await runSession(term, config, nextOpts, exitHint);
+  }
+  if (exitHint.sessionId) {
+    const short = stripHydraSessionPrefix(exitHint.sessionId);
+    process.stdout.write(`To resume: hydra-acp tui --resume ${short}
+`);
   }
 }
-async function runSession(term, config, opts) {
+async function runSession(term, config, opts, exitHint) {
   const ctx = await resolveSession(term, config, opts);
   if (!ctx) {
     term.grabInput(false);
     process.exit(0);
   }
+  const launchLabel = ctx.sessionId === "__new__" ? "Starting new session\u2026" : "Resuming session\u2026";
+  term.cyan(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}`];
@@ -4396,8 +5402,9 @@ async function runSession(term, config, opts) {
     const screenReady = typeof screenRef !== "undefined" && screenRef !== null;
     if (before === 0 && pendingTurns > 0) {
       sessionBusySince = Date.now();
+      dispatcherRef?.setTurnRunning(true);
       if (screenReady) {
-        screenRef.setBanner({ status: "running", elapsedMs: 0 });
+        screenRef.setBanner({ status: "busy", elapsedMs: 0 });
       }
       if (sessionElapsedTimer === null && screenReady) {
         sessionElapsedTimer = setInterval(() => {
@@ -4406,10 +5413,11 @@ async function runSession(term, config, opts) {
           }
           screenRef.setBanner({ elapsedMs: Date.now() - sessionBusySince });
           renderToolsBlock();
-        }, 5e3);
+        }, 1e3);
       }
     } else if (before > 0 && pendingTurns === 0) {
       sessionBusySince = null;
+      dispatcherRef?.setTurnRunning(false);
       if (sessionElapsedTimer !== null) {
         clearInterval(sessionElapsedTimer);
         sessionElapsedTimer = null;
@@ -4423,9 +5431,11 @@ async function runSession(term, config, opts) {
     }
   };
   let screenRef = null;
+  let dispatcherRef = null;
   conn.onNotification("session/update", (params) => {
     const { update } = params ?? {};
     const event = mapUpdate(update);
+    debugLogUpdate(update, event);
     if (event?.kind === "user-text") {
       adjustPendingTurns(1);
     } else if (event?.kind === "turn-complete") {
@@ -4446,10 +5456,10 @@ async function runSession(term, config, opts) {
     if (pendingPermission.toolCallId && toolCallId && pendingPermission.toolCallId !== toolCallId) {
       return;
     }
-    const resolve2 = pendingPermission.resolve;
+    const resolve4 = pendingPermission.resolve;
     pendingPermission = null;
     screen.setPermissionPrompt(null);
-    resolve2(result ?? { outcome: { outcome: "cancelled" } });
+    resolve4(result ?? { outcome: { outcome: "cancelled" } });
   };
   const maybeDismissPermissionByToolUpdate = (update) => {
     if (!pendingPermission?.toolCallId) {
@@ -4482,14 +5492,14 @@ async function runSession(term, config, opts) {
     if (!pendingPermission) {
       return;
     }
-    const { options, resolve: resolve2 } = pendingPermission;
+    const { options, resolve: resolve4 } = pendingPermission;
     pendingPermission = null;
     screen.setPermissionPrompt(null);
     if (optionId === null) {
-      resolve2({ outcome: { outcome: "cancelled" } });
+      resolve4({ outcome: { outcome: "cancelled" } });
       return;
     }
-    resolve2({ outcome: { outcome: "selected", optionId } });
+    resolve4({ outcome: { outcome: "selected", optionId } });
     void options;
   };
   conn.onRequest("session/request_permission", async (params) => {
@@ -4507,12 +5517,12 @@ async function runSession(term, config, opts) {
       ]);
       return { outcome: { outcome: "cancelled" } };
     }
-    return new Promise((resolve2) => {
+    return new Promise((resolve4) => {
       pendingPermission = {
         title,
         options,
         selectedIndex: 0,
-        resolve: resolve2,
+        resolve: resolve4,
         toolCallId
       };
       refreshPermissionPrompt();
@@ -4542,6 +5552,7 @@ async function runSession(term, config, opts) {
   let initialModel;
   let initialMode;
   let initialCommands;
+  let initialTurnStartedAt;
   if (ctx.sessionId === "__new__") {
     const created = await conn.request("session/new", {
       cwd: ctx.cwd,
@@ -4549,6 +5560,7 @@ async function runSession(term, config, opts) {
       ...opts.name ? { _meta: { [HYDRA_META_KEY]: { name: opts.name } } } : {}
     });
     resolvedSessionId = created.sessionId;
+    exitHint.sessionId = resolvedSessionId;
     const hydraMeta = extractHydraMeta(created._meta ?? void 0);
     upstreamSessionId = hydraMeta.upstreamSessionId;
     if (hydraMeta.agentId) {
@@ -4562,6 +5574,7 @@ async function runSession(term, config, opts) {
     }
     initialModel = hydraMeta.currentModel;
     initialMode = hydraMeta.currentMode;
+    initialTurnStartedAt = hydraMeta.turnStartedAt;
     if (hydraMeta.availableCommands) {
       initialCommands = hydraMeta.availableCommands.map(
         (c) => c.description !== void 0 ? { name: c.name, description: c.description } : { name: c.name }
@@ -4574,6 +5587,7 @@ async function runSession(term, config, opts) {
       clientInfo: { name: "hydra-acp-tui", version: "0.1.0" }
     });
     resolvedSessionId = attached.sessionId;
+    exitHint.sessionId = resolvedSessionId;
     const hydraMeta = extractHydraMeta(attached._meta ?? void 0);
     upstreamSessionId = hydraMeta.upstreamSessionId;
     if (hydraMeta.agentId) {
@@ -4587,20 +5601,26 @@ async function runSession(term, config, opts) {
     }
     initialModel = hydraMeta.currentModel;
     initialMode = hydraMeta.currentMode;
+    initialTurnStartedAt = hydraMeta.turnStartedAt;
     if (hydraMeta.availableCommands) {
       initialCommands = hydraMeta.availableCommands.map(
         (c) => c.description !== void 0 ? { name: c.name, description: c.description } : { name: c.name }
       );
     }
   }
-  const historyFile = paths.tuiHistoryFile();
+  const historyFile = paths.tuiHistoryFile(resolvedSessionId);
   let history = await loadHistory(historyFile).catch(() => []);
   const dispatcher = new InputDispatcher({ history });
+  dispatcherRef = dispatcher;
+  if (pendingTurns > 0) {
+    dispatcher.setTurnRunning(true);
+  }
   let turnInFlight = null;
   const screen = new Screen({
     term,
     dispatcher,
     repaintThrottleMs: config.tui.repaintThrottleMs,
+    maxScrollbackLines: config.tui.maxScrollbackLines,
     onKey: (events) => {
       for (const ev of events) {
         if (pendingPermission && tryHandlePermissionKey(ev)) {
@@ -4764,14 +5784,21 @@ async function runSession(term, config, opts) {
     screen.appendLines(formatEvent({ kind: "model-changed", model: initialModel }));
   }
   let finishSession = null;
-  const sessionDone = new Promise((resolve2) => {
-    finishSession = resolve2;
+  const sessionDone = new Promise((resolve4) => {
+    finishSession = resolve4;
   });
+  const cancelRemoteTurn = () => {
+    conn.notify("session/cancel", { sessionId: resolvedSessionId }).catch(() => void 0);
+  };
   const sigintHandler = () => {
     if (turnInFlight) {
       turnInFlight.cancel();
       return;
     }
+    if (pendingTurns > 0) {
+      cancelRemoteTurn();
+      return;
+    }
     void requestExit();
   };
   let exitConfirmation = null;
@@ -4846,6 +5873,7 @@ async function runSession(term, config, opts) {
   };
   const teardown = () => {
     process.off("SIGINT", sigintHandler);
+    screen.clearWindowTitle();
     screen.stop();
     saveHistory(historyFile, history).catch(() => void 0);
     void stream.close().catch(() => void 0);
@@ -4861,22 +5889,32 @@ async function runSession(term, config, opts) {
     }
   };
   const switchSession = async () => {
-    const resume = finishSession;
-    if (!resume) {
+    if (!finishSession) {
       return;
     }
-    finishSession = null;
-    teardown();
+    const pendingDraft = dispatcher.state().buffer.join("\n");
+    if (pendingDraft.replace(/\s+$/, "").length > 0) {
+      history = appendEntry(history, pendingDraft);
+      dispatcher.setHistory(history);
+    }
+    screen.pauseRepaint();
+    screen.stop();
+    saveHistory(historyFile, history).catch(() => void 0);
     const sessions = await listSessions(config);
     const choice = await pickSession(term, {
       cwd: resolvedCwd,
       sessions,
-      coldLimit: config.sessionListColdLimit
+      config
     });
     if (choice.kind === "abort") {
-      resume({ ...opts, sessionId: resolvedSessionId, cwd: resolvedCwd });
+      screen.start();
+      screen.resumeRepaint();
       return;
     }
+    const resume = finishSession;
+    finishSession = null;
+    process.off("SIGINT", sigintHandler);
+    void stream.close().catch(() => void 0);
     if (choice.kind === "new") {
       const { sessionId: _drop, ...rest } = opts;
       void _drop;
@@ -4901,6 +5939,8 @@ async function runSession(term, config, opts) {
       case "cancel":
         if (turnInFlight) {
           turnInFlight.cancel();
+        } else if (pendingTurns > 0) {
+          cancelRemoteTurn();
         }
         if (promptQueue.length > (workerActive ? 1 : 0)) {
           promptQueue.length = workerActive ? 1 : 0;
@@ -4917,7 +5957,7 @@ async function runSession(term, config, opts) {
         screen.setBanner({});
         return;
       case "redraw":
-        screen.redraw();
+        screen.fullRedraw();
         return;
       case "switch-session":
         void switchSession();
@@ -5088,7 +6128,6 @@ async function runSession(term, config, opts) {
     const promptArr = planMode ? [{ type: "text", text: PLAN_PREFIX_TEXT }, ...userBlocks] : userBlocks;
     adjustPendingTurns(1);
     appendRender({ kind: "user-text", text });
-    dispatcher.setTurnRunning(true);
     let cancelled = false;
     turnInFlight = {
       cancel: () => {
@@ -5118,7 +6157,6 @@ async function runSession(term, config, opts) {
       });
     } finally {
       turnInFlight = null;
-      dispatcher.setTurnRunning(false);
       adjustPendingTurns(-1);
       appendRender(
         stopReason !== void 0 ? { kind: "turn-complete", stopReason } : { kind: "turn-complete" }
@@ -5174,7 +6212,7 @@ async function runSession(term, config, opts) {
     const elapsed = end - toolsBlockStartedAt;
     let summary;
     if (total === 0) {
-      summary = inProgress ? `thinking \xB7 ${formatElapsed(elapsed)}` : `no tools \xB7 took ${formatElapsed(elapsed)}`;
+      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)}`;
@@ -5245,6 +6283,10 @@ async function runSession(term, config, opts) {
       if (event.title !== void 0) {
         screen.setHeader({ title: event.title });
       }
+      if (event.agentId !== void 0 && event.agentId !== resolvedAgentId) {
+        resolvedAgentId = event.agentId;
+        screen.setHeader({ agent: event.agentId });
+      }
       return;
     }
     if (event.kind === "usage-update") {
@@ -5277,6 +6319,12 @@ async function runSession(term, config, opts) {
       if (formatted2.length > 0) {
         screen.appendLines(formatted2);
       }
+      screen.clearKey("tools");
+      screen.clearKey("plan");
+      toolStates.clear();
+      toolCallOrder.length = 0;
+      toolsExpanded = false;
+      toolsBlockEndedAt = null;
       startToolsBlock();
       screen.redraw();
       return;
@@ -5317,12 +6365,10 @@ async function runSession(term, config, opts) {
     if (event.kind === "turn-complete") {
       closeAgentText();
       screen.clearKey("plan");
-      if (toolCallOrder.length > 0) {
+      if (toolsBlockStartedAt !== null) {
         toolsBlockEndedAt = Date.now();
         renderToolsBlock();
         screen.clearKey("tools");
-      } else if (toolsBlockStartedAt !== null) {
-        screen.removeBlock("tools");
       }
       toolStates.clear();
       toolCallOrder.length = 0;
@@ -5342,22 +6388,35 @@ async function runSession(term, config, opts) {
   } finally {
     screen.resumeRepaint();
   }
+  if (initialTurnStartedAt !== void 0 && pendingTurns > 0) {
+    sessionBusySince = initialTurnStartedAt;
+    screen.setBanner({
+      status: "busy",
+      elapsedMs: Date.now() - initialTurnStartedAt
+    });
+    if (sessionElapsedTimer === null) {
+      sessionElapsedTimer = setInterval(() => {
+        if (sessionBusySince === null || screenRef === null) {
+          return;
+        }
+        screenRef.setBanner({ elapsedMs: Date.now() - sessionBusySince });
+        renderToolsBlock();
+      }, 1e3);
+    }
+    startToolsBlock();
+  }
   const resetInFlightUiState = () => {
     if (pendingPermission) {
-      const resolve2 = pendingPermission.resolve;
+      const resolve4 = pendingPermission.resolve;
       pendingPermission = null;
       screen.setPermissionPrompt(null);
-      resolve2({ outcome: { outcome: "cancelled" } });
+      resolve4({ outcome: { outcome: "cancelled" } });
     }
     closeAgentText();
     if (toolsBlockStartedAt !== null) {
-      if (toolCallOrder.length > 0) {
-        toolsBlockEndedAt = Date.now();
-        renderToolsBlock();
-        screen.clearKey("tools");
-      } else {
-        screen.removeBlock("tools");
-      }
+      toolsBlockEndedAt = Date.now();
+      renderToolsBlock();
+      screen.clearKey("tools");
       toolStates.clear();
       toolCallOrder.length = 0;
       toolsBlockStartedAt = null;
@@ -5427,7 +6486,7 @@ async function runSession(term, config, opts) {
       ]);
     }
     screen.setBanner({
-      status: pendingTurns > 0 ? "running" : "ready",
+      status: pendingTurns > 0 ? "busy" : "ready",
       elapsedMs: pendingTurns > 0 ? 0 : void 0
     });
   };
@@ -5475,7 +6534,7 @@ async function resolveSession(term, config, opts) {
   const choice = await pickSession(term, {
     cwd,
     sessions,
-    coldLimit: config.sessionListColdLimit
+    config
   });
   if (choice.kind === "abort") {
     return null;
@@ -5496,7 +6555,41 @@ function newCtx(opts, cwd, config) {
     cwd
   };
 }
-var PLAN_PREFIX_TEXT;
+function debugLogUpdate(update, event) {
+  writeDebugLine({
+    src: "session/update",
+    update,
+    event: event === null ? null : { kind: event.kind }
+  });
+}
+function writeDebugLine(payload) {
+  const override = process.env.HYDRA_TUI_DEBUG_LOG;
+  const target = override === void 0 ? paths.tuiLogFile() : override;
+  if (target.length === 0) {
+    return;
+  }
+  try {
+    rotateIfBig(target);
+    const line = JSON.stringify({
+      t: (/* @__PURE__ */ new Date()).toISOString(),
+      ...payload
+    });
+    appendFileSync(target, `${line}
+`);
+  } catch {
+  }
+}
+function rotateIfBig(target) {
+  try {
+    const stat3 = statSync(target);
+    if (stat3.size < TUI_LOG_MAX_BYTES) {
+      return;
+    }
+    renameSync(target, `${target}.0`);
+  } catch {
+  }
+}
+var PLAN_PREFIX_TEXT, TUI_LOG_MAX_BYTES;
 var init_app = __esm({
   "src/tui/app.ts"() {
     "use strict";
@@ -5505,6 +6598,7 @@ var init_app = __esm({
     init_resilient_ws();
     init_config();
     init_daemon_bootstrap();
+    init_session();
     init_paths();
     init_history();
     init_discovery();
@@ -5514,6 +6608,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;
   }
 });
 
@@ -5529,6 +6624,11 @@ var init_tui = __esm({
   }
 });
 
+// src/cli.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname3, resolve as resolve3 } from "path";
+
 // src/cli/parse-args.ts
 function parseArgs(argv) {
   const positional = [];
@@ -5598,8 +6698,7 @@ async function runInit(flags) {
     existing = void 0;
   }
   if (!existing) {
-    const config = defaultConfig();
-    await writeConfig(config);
+    const config = await writeMinimalInitConfig();
     process.stdout.write(
       `Initialized ${paths.config()}
 Auth token: ${config.daemon.authToken}
@@ -5608,11 +6707,14 @@ Auth token: ${config.daemon.authToken}
     return;
   }
   if (flagBool(flags, "rotate-token")) {
-    existing.daemon.authToken = generateAuthToken();
-    await writeConfig(existing);
+    const newToken = generateAuthToken();
+    await updateConfigField((raw) => {
+      const daemon = raw.daemon ??= {};
+      daemon.authToken = newToken;
+    });
     process.stdout.write(
       `Rotated token in ${paths.config()}
-New token: ${existing.daemon.authToken}
+New token: ${newToken}
 `
     );
     return;
@@ -5630,7 +6732,7 @@ import { setTimeout as sleep2 } from "timers/promises";
 
 // src/daemon/server.ts
 init_config();
-import * as fs7 from "fs";
+import * as fs9 from "fs";
 import * as fsp2 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
@@ -5802,6 +6904,10 @@ function planSpawn(agent, extraArgs = []) {
   throw new Error(`Agent ${agent.id} has no usable distribution method.`);
 }
 
+// src/core/session-manager.ts
+import * as fs7 from "fs/promises";
+import { customAlphabet as customAlphabet3 } from "nanoid";
+
 // src/core/agent-instance.ts
 import { spawn } from "child_process";
 
@@ -5859,13 +6965,13 @@ function ndjsonStreamFromStdio(stdout, stdin) {
         throw new Error("stream is closed");
       }
       const line = JSON.stringify(message) + "\n";
-      await new Promise((resolve2, reject) => {
+      await new Promise((resolve4, reject) => {
         stdin.write(line, (err) => {
           if (err) {
             reject(err);
             return;
           }
-          resolve2();
+          resolve4();
         });
       });
     },
@@ -5946,7 +7052,14 @@ init_session();
 init_paths();
 import * as fs4 from "fs/promises";
 import * as path2 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()
@@ -5954,7 +7067,20 @@ var PersistedAgentCommand = z4.object({
 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(),
@@ -6027,6 +7153,25 @@ var SessionStore = class {
       }
     }
   }
+  // 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 {
@@ -6052,7 +7197,9 @@ 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,
@@ -6101,6 +7248,36 @@ var HistoryStore = class {
       });
     });
   }
+  // Trim the on-disk history file to the most recent maxEntries lines.
+  // Runs through the same per-session write queue as append/rewrite so
+  // it's safe to invoke alongside ongoing writes; a no-op if the file is
+  // already at or below the cap.
+  async compact(sessionId, maxEntries) {
+    if (!SESSION_ID_PATTERN2.test(sessionId)) {
+      return;
+    }
+    return this.enqueue(sessionId, async () => {
+      let raw;
+      try {
+        raw = await fs5.readFile(paths.historyFile(sessionId), "utf8");
+      } catch (err) {
+        const e = err;
+        if (e.code === "ENOENT") {
+          return;
+        }
+        throw err;
+      }
+      const lines = raw.split("\n").filter((l) => l.length > 0);
+      if (lines.length <= maxEntries) {
+        return;
+      }
+      const trimmed = lines.slice(-maxEntries);
+      await fs5.writeFile(paths.historyFile(sessionId), trimmed.join("\n") + "\n", {
+        encoding: "utf8",
+        mode: 384
+      });
+    });
+  }
   async load(sessionId) {
     if (!SESSION_ID_PATTERN2.test(sessionId)) {
       return [];
@@ -6189,7 +7366,11 @@ var HistoryStore = class {
 };
 
 // src/core/session-manager.ts
+init_paths();
+init_history();
 init_types();
+var HYDRA_ID_ALPHABET3 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var generateRawSessionId = customAlphabet3(HYDRA_ID_ALPHABET3, 16);
 var SessionManager = class {
   constructor(registry, spawner, store, options = {}) {
     this.registry = registry;
@@ -6268,6 +7449,9 @@ var SessionManager = class {
       err.code = JsonRpcErrorCodes.AgentNotInstalled;
       throw err;
     }
+    if (params.upstreamSessionId === "") {
+      return this.doResurrectFromImport(params);
+    }
     const plan = planSpawn(agentDef, params.agentArgs ?? []);
     const agent = this.spawner({
       agentId: params.agentId,
@@ -6304,12 +7488,53 @@ var SessionManager = class {
       idleTimeoutMs: this.idleTimeoutMs,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       historyStore: this.histories,
-      seedHistory: params.seedHistory,
       currentModel: params.currentModel,
       currentMode: params.currentMode,
-      agentCommands: params.agentCommands
+      agentCommands: params.agentCommands,
+      // Only gate the first-prompt title heuristic when we actually have
+      // a title to preserve. A title-less session (lost to a write race
+      // or never seeded) should re-derive from the next prompt rather
+      // than stay stuck.
+      firstPromptSeeded: !!params.title,
+      createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0
+    });
+    await this.attachManagerHooks(session);
+    return session;
+  }
+  // First-attach path for a session that was created via import(). The
+  // on-disk meta.json carries upstreamSessionId="" as the import
+  // marker; bootstrap a fresh agent (gets a real upstream id) and kick
+  // off seedFromImport so the agent absorbs the historical transcript.
+  // attachManagerHooks rewrites meta.json with the new upstreamSessionId,
+  // so subsequent resurrects of this session use the normal session/load
+  // path.
+  async doResurrectFromImport(params) {
+    const fresh = await this.bootstrapAgent({
+      agentId: params.agentId,
+      cwd: params.cwd,
+      agentArgs: params.agentArgs,
+      mcpServers: []
+    });
+    const session = new Session({
+      sessionId: params.hydraSessionId,
+      cwd: params.cwd,
+      agentId: params.agentId,
+      agent: fresh.agent,
+      upstreamSessionId: fresh.upstreamSessionId,
+      agentMeta: fresh.agentMeta,
+      title: params.title,
+      agentArgs: params.agentArgs,
+      idleTimeoutMs: this.idleTimeoutMs,
+      spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
+      historyStore: this.histories,
+      currentModel: params.currentModel,
+      currentMode: params.currentMode,
+      agentCommands: params.agentCommands,
+      firstPromptSeeded: !!params.title,
+      createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0
     });
     await this.attachManagerHooks(session);
+    void session.seedFromImport().catch(() => void 0);
     return session;
   }
   // Bootstrap a fresh agent process: registry resolve → spawn → initialize
@@ -6391,28 +7616,20 @@ var SessionManager = class {
       }).catch(() => void 0);
     });
     this.sessions.set(session.sessionId, session);
-    await this.store.write(
-      recordFromMemorySession({
-        sessionId: session.sessionId,
-        upstreamSessionId: session.upstreamSessionId,
-        agentId: session.agentId,
-        cwd: session.cwd,
-        title: session.title,
-        agentArgs: session.agentArgs,
-        currentModel: session.currentModel,
-        currentMode: session.currentMode
-      })
-    ).catch(() => void 0);
+    await this.enqueueMetaWrite(session.sessionId, async () => {
+      const existing = await this.store.read(session.sessionId);
+      const merged = mergeForPersistence(session, existing);
+      await this.store.write(merged);
+    }).catch(() => void 0);
   }
   // Resolve a session's recorded history without forcing a resurrect.
-  // Returns the in-memory snapshot if the session is hot, falls back
-  // to the on-disk history file otherwise. Returns undefined if the
-  // session id is unknown to both the live map and disk store, so the
-  // caller can distinguish "no history yet" (empty array) from "404".
+  // Always loads from disk — that's the source of truth whether the
+  // session is hot or cold. Returns undefined if the session id is
+  // unknown to both the live map and disk store, so the caller can
+  // distinguish "no history yet" (empty array) from "404".
   async getHistory(sessionId) {
-    const live = this.sessions.get(sessionId);
-    if (live) {
-      return live.getHistorySnapshot();
+    if (this.sessions.has(sessionId)) {
+      return this.histories.load(sessionId).catch(() => []);
     }
     const record = await this.store.read(sessionId);
     if (!record) {
@@ -6425,20 +7642,41 @@ var SessionManager = class {
     if (!record) {
       return void 0;
     }
-    const seedHistory = await this.histories.load(sessionId).catch(() => []);
+    let title = record.title;
+    if (!title) {
+      title = await this.deriveTitleFromHistory(sessionId);
+    }
     return {
       hydraSessionId: record.sessionId,
       upstreamSessionId: record.upstreamSessionId,
       agentId: record.agentId,
       cwd: record.cwd,
-      title: record.title,
+      title,
       agentArgs: record.agentArgs,
-      seedHistory: seedHistory.length > 0 ? seedHistory : void 0,
       currentModel: record.currentModel,
       currentMode: record.currentMode,
-      agentCommands: record.agentCommands
+      agentCommands: record.agentCommands,
+      createdAt: record.createdAt
     };
   }
+  // Best-effort: peek at the persisted history's first prompt and use
+  // its first line (capped to 200 chars) as a session title. Returns
+  // undefined if no usable prompt is found or any I/O fails.
+  async deriveTitleFromHistory(sessionId) {
+    const history = await this.histories.load(sessionId).catch(() => []);
+    for (const entry of history) {
+      const params = entry.params;
+      if (params?.update?.sessionUpdate !== "prompt_received") {
+        continue;
+      }
+      const text = extractPromptText(params.update.prompt);
+      const line = firstLine(text, 200);
+      if (line) {
+        return line;
+      }
+    }
+    return void 0;
+  }
   get(sessionId) {
     return this.sessions.get(sessionId);
   }
@@ -6478,13 +7716,14 @@ var SessionManager = class {
         continue;
       }
       liveIds.add(session.sessionId);
+      const used = await historyMtimeIso(session.sessionId) ?? new Date(session.updatedAt).toISOString();
       entries.push({
         sessionId: session.sessionId,
         upstreamSessionId: session.upstreamSessionId,
         cwd: session.cwd,
         title: session.title,
         agentId: session.agentId,
-        updatedAt: new Date(session.updatedAt).toISOString(),
+        updatedAt: used,
         attachedClients: session.attachedCount,
         status: "live"
       });
@@ -6497,13 +7736,14 @@ var SessionManager = class {
       if (filter.cwd && r.cwd !== filter.cwd) {
         continue;
       }
+      const used = await historyMtimeIso(r.sessionId) ?? r.updatedAt;
       entries.push({
         sessionId: r.sessionId,
         upstreamSessionId: r.upstreamSessionId,
         cwd: r.cwd,
         title: r.title,
         agentId: r.agentId,
-        updatedAt: r.updatedAt,
+        updatedAt: used,
         attachedClients: 0,
         status: "cold"
       });
@@ -6511,6 +7751,111 @@ var SessionManager = class {
     entries.sort((a, b) => a.updatedAt < b.updatedAt ? 1 : -1);
     return entries;
   }
+  // Build an export bundle for a session, reading meta + history from
+  // disk. Backfills lineageId if the on-disk record pre-dates that
+  // field. Returns undefined if the session doesn't exist. Callers
+  // populate the bundle's exportedFrom metadata themselves.
+  async exportBundle(sessionId) {
+    const record = await this.store.read(sessionId);
+    if (!record) {
+      return void 0;
+    }
+    let withLineage;
+    if (record.lineageId) {
+      withLineage = record;
+    } else {
+      const lineageId = generateLineageId();
+      const backfilled = { ...record, lineageId };
+      await this.enqueueMetaWrite(sessionId, async () => {
+        const latest = await this.store.read(sessionId);
+        if (!latest) {
+          return;
+        }
+        if (latest.lineageId) {
+          return;
+        }
+        await this.store.write({ ...latest, lineageId });
+      }).catch(() => void 0);
+      withLineage = backfilled;
+    }
+    const history = await this.histories.load(sessionId).catch(() => []);
+    const promptHistory = await loadPromptHistorySafely(sessionId);
+    return { record: withLineage, history, promptHistory };
+  }
+  // Create a local session from an imported bundle. Without `replace`,
+  // a bundle with a lineageId we already have on disk throws
+  // BundleAlreadyImported citing the existing local id. With
+  // `replace: true`, the existing record is overwritten in-place (its
+  // local sessionId is preserved so bookmarks/Slack thread links still
+  // resolve), and any live in-memory session is closed so the next
+  // attach triggers the import-reseed path.
+  async importBundle(bundle, opts = {}) {
+    const existing = await this.store.findByLineageId(bundle.session.lineageId);
+    if (existing) {
+      if (!opts.replace) {
+        const err = new Error(
+          `bundle already imported as ${existing.sessionId}`
+        );
+        err.code = JsonRpcErrorCodes.BundleAlreadyImported;
+        err.existingSessionId = existing.sessionId;
+        throw err;
+      }
+      const live = this.sessions.get(existing.sessionId);
+      if (live) {
+        await live.close({ deleteRecord: false }).catch(() => void 0);
+      }
+      await this.writeImportedRecord({
+        sessionId: existing.sessionId,
+        bundle,
+        preservedCreatedAt: existing.createdAt
+      });
+      return {
+        sessionId: existing.sessionId,
+        importedFromSessionId: bundle.session.sessionId,
+        replaced: true
+      };
+    }
+    const newId = `${HYDRA_SESSION_PREFIX}${generateRawSessionId()}`;
+    await this.writeImportedRecord({ sessionId: newId, bundle });
+    return {
+      sessionId: newId,
+      importedFromSessionId: bundle.session.sessionId,
+      replaced: false
+    };
+  }
+  // Write the imported bundle's history.jsonl, prompt-history (if
+  // present), and meta.json. upstreamSessionId is left empty as the
+  // marker that the first attach should bootstrap a fresh agent and
+  // run seedFromImport rather than calling session/load.
+  async writeImportedRecord(args) {
+    await this.histories.rewrite(
+      args.sessionId,
+      args.bundle.history
+    );
+    if (args.bundle.promptHistory && args.bundle.promptHistory.length > 0) {
+      await saveHistory(
+        paths.tuiHistoryFile(args.sessionId),
+        args.bundle.promptHistory
+      ).catch(() => void 0);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.enqueueMetaWrite(args.sessionId, async () => {
+      await this.store.write({
+        sessionId: args.sessionId,
+        lineageId: args.bundle.session.lineageId,
+        upstreamSessionId: "",
+        importedFromSessionId: args.bundle.session.sessionId,
+        agentId: args.bundle.session.agentId,
+        cwd: args.bundle.session.cwd,
+        title: args.bundle.session.title,
+        currentModel: args.bundle.session.currentModel,
+        currentMode: args.bundle.session.currentMode,
+        agentCommands: args.bundle.session.agentCommands,
+        createdAt: args.preservedCreatedAt ?? now,
+        updatedAt: now
+      });
+    });
+  }
   async deleteRecord(sessionId) {
     const record = await this.store.read(sessionId);
     if (!record) {
@@ -6519,6 +7864,10 @@ var SessionManager = class {
     await this.store.delete(sessionId).catch(() => void 0);
     return true;
   }
+  async hasRecord(sessionId) {
+    const record = await this.store.read(sessionId).catch(() => void 0);
+    return record !== void 0;
+  }
   // Persist a title update from Session.setTitle. The on-disk record
   // was written at create time; updating it here keeps the session
   // record's title in sync with what was broadcast to clients so a
@@ -6592,14 +7941,76 @@ var SessionManager = class {
     await Promise.allSettled(sessions.map((s) => s.close()));
     this.sessions.clear();
   }
+  // Wait for every pending meta.json write to settle. Daemon shutdown
+  // hooks call this so a SIGTERM doesn't kill the process mid-write
+  // and lose a freshly-set title (or model/mode/commands).
+  async flushMetaWrites() {
+    const pending = [...this.metaWriteQueues.values()];
+    if (pending.length === 0) {
+      return;
+    }
+    await Promise.allSettled(pending);
+  }
 };
+function mergeForPersistence(session, existing) {
+  const persistedCommands = session.mergedAvailableCommands().length > 0 ? session.agentOnlyAdvertisedCommands().map((c) => {
+    if (c.description !== void 0) {
+      return { name: c.name, description: c.description };
+    }
+    return { name: c.name };
+  }) : void 0;
+  const agentCommands = persistedCommands ?? existing?.agentCommands;
+  return recordFromMemorySession({
+    sessionId: session.sessionId,
+    lineageId: existing?.lineageId ?? generateLineageId(),
+    upstreamSessionId: session.upstreamSessionId,
+    importedFromSessionId: existing?.importedFromSessionId,
+    agentId: session.agentId,
+    cwd: session.cwd,
+    title: session.title,
+    agentArgs: session.agentArgs,
+    currentModel: session.currentModel ?? existing?.currentModel,
+    currentMode: session.currentMode ?? existing?.currentMode,
+    agentCommands,
+    createdAt: existing?.createdAt ?? new Date(session.createdAt).toISOString()
+  });
+}
+async function loadPromptHistorySafely(sessionId) {
+  try {
+    const raw = await fs7.readFile(paths.tuiHistoryFile(sessionId), "utf8");
+    const out = [];
+    for (const line of raw.split("\n")) {
+      if (line.length === 0) {
+        continue;
+      }
+      try {
+        const decoded = JSON.parse(line);
+        if (typeof decoded === "string") {
+          out.push(decoded);
+        }
+      } catch {
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+async function historyMtimeIso(sessionId) {
+  try {
+    const st = await fs7.stat(paths.historyFile(sessionId));
+    return new Date(st.mtimeMs).toISOString();
+  } catch {
+    return void 0;
+  }
+}
 
 // src/core/extensions.ts
 init_paths();
 import { spawn as spawn2 } from "child_process";
-import * as fs6 from "fs";
+import * as fs8 from "fs";
 import * as fsp from "fs/promises";
-import * as path3 from "path";
+import * as path4 from "path";
 var RESTART_BASE_MS = 1e3;
 var RESTART_CAP_MS = 6e4;
 var STOP_GRACE_MS = 3e3;
@@ -6646,9 +8057,9 @@ var ExtensionManager = class {
       } catch {
       }
       tasks.push(
-        new Promise((resolve2) => {
+        new Promise((resolve4) => {
           if (child.exitCode !== null || child.signalCode !== null) {
-            resolve2();
+            resolve4();
             return;
           }
           const timer = setTimeout(() => {
@@ -6656,11 +8067,11 @@ var ExtensionManager = class {
               child.kill("SIGKILL");
             } catch {
             }
-            resolve2();
+            resolve4();
           }, STOP_GRACE_MS);
           child.on("exit", () => {
             clearTimeout(timer);
-            resolve2();
+            resolve4();
           });
         })
       );
@@ -6768,8 +8179,8 @@ var ExtensionManager = class {
     if (child.exitCode !== null || child.signalCode !== null) {
       return;
     }
-    const exited = new Promise((resolve2) => {
-      entry.exitWaiters.push(resolve2);
+    const exited = new Promise((resolve4) => {
+      entry.exitWaiters.push(resolve4);
     });
     try {
       child.kill("SIGTERM");
@@ -6841,7 +8252,7 @@ var ExtensionManager = class {
       if (!entry.endsWith(".pid")) {
         continue;
       }
-      const pidPath = path3.join(paths.extensionsDir(), entry);
+      const pidPath = path4.join(paths.extensionsDir(), entry);
       let pid;
       try {
         const raw = await fsp.readFile(pidPath, "utf8");
@@ -6880,7 +8291,7 @@ var ExtensionManager = class {
     }
     const ext = entry.config;
     const command = ext.command.length > 0 ? ext.command : [ext.name];
-    const logStream = fs6.createWriteStream(paths.extensionLogFile(ext.name), {
+    const logStream = fs8.createWriteStream(paths.extensionLogFile(ext.name), {
       flags: "a"
     });
     logStream.write(
@@ -6930,7 +8341,7 @@ var ExtensionManager = class {
     }
     if (typeof child.pid === "number") {
       try {
-        fs6.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
+        fs8.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
 `, {
           encoding: "utf8",
           mode: 384
@@ -6955,7 +8366,7 @@ var ExtensionManager = class {
     });
     child.on("exit", (code, signal) => {
       try {
-        fs6.unlinkSync(paths.extensionPidFile(ext.name));
+        fs8.unlinkSync(paths.extensionPidFile(ext.name));
       } catch {
       }
       logStream.write(
@@ -6966,8 +8377,8 @@ var ExtensionManager = class {
       entry.pid = void 0;
       entry.lastExitCode = typeof code === "number" ? code : void 0;
       const waiters = entry.exitWaiters.splice(0);
-      for (const resolve2 of waiters) {
-        resolve2();
+      for (const resolve4 of waiters) {
+        resolve4();
       }
       if (this.stopping || entry.manuallyStopped) {
         try {
@@ -7068,6 +8479,76 @@ 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(),
+  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.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_types();
+var HYDRA_VERSION = "0.1.0";
 function registerSessionRoutes(app, manager, defaults) {
   app.get("/v1/sessions", async (request) => {
     const query = request.query;
@@ -7093,6 +8574,22 @@ function registerSessionRoutes(app, manager, defaults) {
       reply.code(500).send({ error: err.message });
     }
   });
+  app.post("/v1/sessions/:id/kill", async (request, reply) => {
+    const raw = request.params.id;
+    const id = await manager.resolveCanonicalId(raw) ?? raw;
+    const session = manager.get(id);
+    if (session) {
+      await session.close({ deleteRecord: false });
+      reply.code(204).send();
+      return;
+    }
+    const exists = await manager.hasRecord(id);
+    if (!exists) {
+      reply.code(404).send({ error: "session not found" });
+      return;
+    }
+    reply.code(204).send();
+  });
   app.delete("/v1/sessions/:id", async (request, reply) => {
     const raw = request.params.id;
     const id = await manager.resolveCanonicalId(raw) ?? raw;
@@ -7109,6 +8606,61 @@ function registerSessionRoutes(app, manager, defaults) {
     }
     reply.code(204).send();
   });
+  app.get("/v1/sessions/:id/export", async (request, reply) => {
+    const raw = request.params.id;
+    const id = await manager.resolveCanonicalId(raw) ?? raw;
+    const exported = await manager.exportBundle(id);
+    if (!exported) {
+      reply.code(404).send({ error: "session not found" });
+      return;
+    }
+    const bundle = encodeBundle({
+      record: exported.record,
+      history: exported.history,
+      promptHistory: exported.promptHistory.length > 0 ? exported.promptHistory : void 0,
+      hydraVersion: HYDRA_VERSION,
+      machine: os2.hostname()
+    });
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    reply.header(
+      "Content-Disposition",
+      `attachment; filename="hydra-${id}-${stamp}.hydra"`
+    );
+    reply.code(200).send(bundle);
+  });
+  app.post("/v1/sessions/import", async (request, reply) => {
+    const body = request.body ?? {};
+    if (body.bundle === void 0) {
+      reply.code(400).send({ error: "missing bundle" });
+      return;
+    }
+    let bundle;
+    try {
+      bundle = decodeBundle(body.bundle);
+    } catch (err) {
+      reply.code(400).send({
+        error: "invalid bundle",
+        details: err.message
+      });
+      return;
+    }
+    try {
+      const result = await manager.importBundle(bundle, {
+        replace: body.replace === true
+      });
+      reply.code(201).send(result);
+    } catch (err) {
+      const e = err;
+      if (e.code === JsonRpcErrorCodes.BundleAlreadyImported) {
+        reply.code(409).send({
+          error: "bundle already imported",
+          existingSessionId: e.existingSessionId
+        });
+        return;
+      }
+      reply.code(500).send({ error: e.message });
+    }
+  });
   app.get("/v1/sessions/:id/history", async (request, reply) => {
     const raw = request.params.id;
     const query = request.query;
@@ -7117,16 +8669,22 @@ function registerSessionRoutes(app, manager, defaults) {
     const live = manager.get(id);
     let snapshot;
     let unsubscribe;
+    let snapshotDone = false;
+    const pending = [];
     if (live) {
-      snapshot = live.getHistorySnapshot();
       if (follow) {
         unsubscribe = live.onBroadcast((entry) => {
           if (reply.raw.writableEnded) {
             return;
           }
-          reply.raw.write(JSON.stringify(entry) + "\n");
+          if (snapshotDone) {
+            reply.raw.write(JSON.stringify(entry) + "\n");
+          } else {
+            pending.push(entry);
+          }
         });
       }
+      snapshot = await live.getHistorySnapshot();
     } else {
       const cold = await manager.getHistory(id);
       if (cold === void 0) {
@@ -7138,9 +8696,23 @@ function registerSessionRoutes(app, manager, defaults) {
     reply.raw.setHeader("Content-Type", "application/x-ndjson");
     reply.raw.setHeader("Cache-Control", "no-cache");
     reply.raw.statusCode = 200;
+    const snapshotKeys = /* @__PURE__ */ new Set();
     for (const entry of snapshot ?? []) {
       reply.raw.write(JSON.stringify(entry) + "\n");
+      const e = entry;
+      if (typeof e.recordedAt === "number") {
+        snapshotKeys.add(String(e.recordedAt));
+      }
+    }
+    for (const entry of pending) {
+      const e = entry;
+      const key = typeof e.recordedAt === "number" ? String(e.recordedAt) : "";
+      if (key && snapshotKeys.has(key)) {
+        continue;
+      }
+      reply.raw.write(JSON.stringify(entry) + "\n");
     }
+    snapshotDone = true;
     if (!unsubscribe) {
       reply.raw.end();
       return reply;
@@ -7300,12 +8872,22 @@ function parseRegisterBody(body) {
   };
 }
 
+// src/daemon/routes/config.ts
+function registerConfigRoutes(app, defaults) {
+  app.get("/v1/config", async () => {
+    return {
+      defaultAgent: defaults.defaultAgent,
+      defaultCwd: defaults.defaultCwd
+    };
+  });
+}
+
 // src/daemon/acp-ws.ts
 init_connection();
 init_ws_stream();
 init_types();
 import { nanoid as nanoid2 } from "nanoid";
-var HYDRA_VERSION = "0.1.0";
+var HYDRA_VERSION2 = "0.1.0";
 var HYDRA_PROTOCOL_VERSION = 1;
 function registerAcpWsEndpoint(app, deps) {
   app.get("/acp", { websocket: true }, (socket, request) => {
@@ -7351,7 +8933,7 @@ function registerAcpWsEndpoint(app, deps) {
         agentArgs: hydraMeta.agentArgs
       });
       const client = bindClientToSession(connection, session, state);
-      session.attach(client, "full");
+      await session.attach(client, "full");
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
         clientId: client.clientId
@@ -7370,14 +8952,22 @@ function registerAcpWsEndpoint(app, deps) {
       const lookupId = hydraHints ? params.sessionId : await deps.manager.resolveCanonicalId(params.sessionId) ?? params.sessionId;
       let session = deps.manager.get(lookupId);
       if (!session) {
-        let resurrectParams = hydraHints ? {
-          hydraSessionId: params.sessionId,
-          upstreamSessionId: hydraHints.upstreamSessionId,
-          agentId: hydraHints.agentId,
-          cwd: hydraHints.cwd,
-          title: hydraHints.title,
-          agentArgs: hydraHints.agentArgs
-        } : await deps.manager.loadFromDisk(lookupId);
+        const fromDisk = await deps.manager.loadFromDisk(lookupId);
+        let resurrectParams = fromDisk;
+        if (hydraHints) {
+          resurrectParams = {
+            hydraSessionId: params.sessionId,
+            upstreamSessionId: hydraHints.upstreamSessionId,
+            agentId: hydraHints.agentId,
+            cwd: hydraHints.cwd,
+            title: hydraHints.title ?? fromDisk?.title,
+            agentArgs: hydraHints.agentArgs ?? fromDisk?.agentArgs,
+            currentModel: fromDisk?.currentModel,
+            currentMode: fromDisk?.currentMode,
+            agentCommands: fromDisk?.agentCommands,
+            createdAt: fromDisk?.createdAt
+          };
+        }
         if (!resurrectParams) {
           const err = new Error(
             `session ${params.sessionId} not found and no resume hints provided`
@@ -7393,13 +8983,13 @@ function registerAcpWsEndpoint(app, deps) {
         state,
         params.clientInfo
       );
-      const replay = session.attach(client, params.historyPolicy);
+      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}`
+        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} replayed=${replay.length}`
       );
       for (const note of replay) {
         await connection.notify(note.method, note.params);
@@ -7495,7 +9085,7 @@ function registerAcpWsEndpoint(app, deps) {
         session = await deps.manager.resurrect(fromDisk);
       }
       const client = bindClientToSession(connection, session, state);
-      const replay = session.attach(client, "pending_only");
+      const replay = await session.attach(client, "pending_only");
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
         clientId: client.clientId
@@ -7553,12 +9143,15 @@ function buildResponseMeta(session) {
   if (commands.length > 0) {
     ours.availableCommands = commands;
   }
+  if (session.turnStartedAt !== void 0) {
+    ours.turnStartedAt = session.turnStartedAt;
+  }
   return mergeMeta(session.agentMeta, ours);
 }
 function buildInitializeResult() {
   return {
     protocolVersion: HYDRA_PROTOCOL_VERSION,
-    agentInfo: { name: "hydra", version: HYDRA_VERSION },
+    agentInfo: { name: "hydra", version: HYDRA_VERSION2 },
     agentCapabilities: {
       // hydra is a transparent proxy: prompt blocks and MCP server configs are
       // forwarded to the underlying agent unchanged. We claim the union of
@@ -7597,7 +9190,7 @@ function bindClientToSession(connection, session, state, clientInfo) {
 }
 
 // src/daemon/server.ts
-var HYDRA_VERSION2 = "0.1.0";
+var HYDRA_VERSION3 = "0.1.0";
 async function startDaemon(config) {
   ensureLoopbackOrTls(config);
   const httpsOptions = config.daemon.tls ? {
@@ -7631,13 +9224,17 @@ async function startDaemon(config) {
     idleTimeoutMs: config.daemon.sessionIdleTimeoutSeconds * 1e3
   });
   const extensions = new ExtensionManager(extensionList(config));
-  registerHealthRoutes(app, HYDRA_VERSION2);
+  registerHealthRoutes(app, HYDRA_VERSION3);
   registerSessionRoutes(app, manager, {
     agentId: config.defaultAgent,
     cwd: config.defaultCwd
   });
   registerAgentRoutes(app, registry);
   registerExtensionRoutes(app, extensions);
+  registerConfigRoutes(app, {
+    defaultAgent: config.defaultAgent,
+    defaultCwd: config.defaultCwd
+  });
   registerAcpWsEndpoint(app, {
     config,
     manager,
@@ -7671,9 +9268,10 @@ async function startDaemon(config) {
   const shutdown = async () => {
     await extensions.stop();
     await manager.closeAll();
+    await manager.flushMetaWrites();
     await app.close();
     try {
-      fs7.unlinkSync(paths.pidFile());
+      fs9.unlinkSync(paths.pidFile());
     } catch {
     }
     try {
@@ -7712,13 +9310,13 @@ function ensureLoopbackOrTls(config) {
 init_daemon_bootstrap();
 
 // src/cli/commands/log-tail.ts
-import * as fs8 from "fs";
+import * as fs10 from "fs";
 import * as fsp3 from "fs/promises";
 async function runLogTail(logPath, argv, notFoundMessage) {
   const opts = parseLogTailFlags(argv);
-  let stat2;
+  let stat3;
   try {
-    stat2 = await fsp3.stat(logPath);
+    stat3 = await fsp3.stat(logPath);
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
@@ -7729,14 +9327,14 @@ async function runLogTail(logPath, argv, notFoundMessage) {
     }
     throw err;
   }
-  let position = await printTail(logPath, stat2.size, opts.tail);
+  let position = await printTail(logPath, stat3.size, opts.tail);
   if (!opts.follow) {
     return;
   }
   process.stdout.write(`-- following ${logPath} --
 `);
   let pending = false;
-  const watcher = fs8.watch(logPath, () => {
+  const watcher = fs10.watch(logPath, () => {
     if (pending) {
       return;
     }
@@ -7764,10 +9362,10 @@ async function runLogTail(logPath, argv, notFoundMessage) {
       }
     });
   });
-  await new Promise((resolve2) => {
+  await new Promise((resolve4) => {
     const finish = () => {
       watcher.close();
-      resolve2();
+      resolve4();
     };
     process.once("SIGINT", finish);
     process.once("SIGTERM", finish);
@@ -8839,14 +10437,16 @@ async function main() {
       process.exit(2);
       return;
     }
-    const sessionId2 = resolveOption(flags2, "session-id");
+    const launchResume = flags2.resume;
+    const sessionId2 = typeof launchResume === "string" ? launchResume : resolveOption(flags2, "session-id");
     const name2 = resolveOption(flags2, "name");
     await runShim({ sessionId: sessionId2, agentId, agentArgs, name: name2 });
     return;
   }
   const { positional, flags } = parseArgs(argv);
   if (flags.version === true || positional[0] === "--version") {
-    process.stdout.write("hydra-acp 0.1.0\n");
+    process.stdout.write(`hydra-acp ${readVersion()}
+`);
     return;
   }
   if (flags.help === true) {
@@ -8854,7 +10454,8 @@ async function main() {
     return;
   }
   const subcommand = positional[0];
-  const sessionId = resolveOption(flags, "session-id");
+  const resumeFlag = flags.resume;
+  const sessionId = typeof resumeFlag === "string" ? resumeFlag : resolveOption(flags, "session-id");
   const name = resolveOption(flags, "name");
   const agentIdFromFlag = resolveOption(flags, "agent-id");
   if (!subcommand) {
@@ -8915,6 +10516,21 @@ async function main() {
         await runSessionsKill(positional[2]);
         return;
       }
+      if (sub === "rm") {
+        await runSessionsRm(positional[2]);
+        return;
+      }
+      if (sub === "export") {
+        const out = resolveOption(flags, "out");
+        await runSessionsExport(positional[2], out);
+        return;
+      }
+      if (sub === "import") {
+        await runSessionsImport(positional[2], {
+          replace: flags.replace === true
+        });
+        return;
+      }
       process.stderr.write(`Unknown sessions subcommand: ${sub}
 `);
       process.exit(2);
@@ -9008,6 +10624,17 @@ async function dispatchTui(flags, base) {
   }
   await runTui(tuiOpts);
 }
+function readVersion() {
+  try {
+    const here = dirname3(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(
+      readFileSync(resolve3(here, "../package.json"), "utf8")
+    );
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
 function printHelp() {
   process.stdout.write(
     [
@@ -9021,12 +10648,17 @@ function printHelp() {
       "                                     Shim mode, force daemon to spawn <agent-id>",
       "                                     from the registry. Args after <agent-id>",
       "                                     are forwarded to the agent's command.",
-      "  hydra-acp --session-id <id>        Attach to an existing session (TUI when in a terminal, shim otherwise)",
+      "  hydra-acp --resume <id>            Attach to an existing session (TUI when in a terminal, shim otherwise)",
       "  hydra-acp init [--rotate-token]    Initialize ~/.hydra-acp/config.json",
       "  hydra-acp daemon start|stop|restart|status",
       "  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>       Kill a session (live or cold)",
+      "  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 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 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",
@@ -9034,15 +10666,16 @@ function printHelp() {
       "  hydra-acp extensions logs <name> [-f] [-n N]Tail or follow an extension's log",
       "  hydra-acp agents [list]                     List agents in the cached registry",
       "  hydra-acp agents refresh                    Force a registry re-fetch",
-      "  hydra-acp tui flags: [--session-id <id>] [--resume] [--new] [--agent-id <id>] [--cwd <path>] [--name <label>]",
-      "                                     Smart default: picks an existing live session if any exist in cwd, else creates a new one",
+      "  hydra-acp tui flags: [--resume [<id>]] [--new] [--agent-id <id>] [--cwd <path>] [--name <label>]",
+      "                                     --resume <id> attaches to a specific session; bare --resume picks the most-recent",
+      "                                     in cwd. Smart default (no flags): picks if any live sessions exist, else new.",
       "  hydra-acp --version                Print version",
       "  hydra-acp --help                   Show this help",
       "",
       "Config knob flags accept env-var equivalents (flag wins):",
-      "  --agent-id    HYDRA_ACP_AGENT_ID",
-      "  --session-id  HYDRA_ACP_SESSION_ID",
-      "  --name        HYDRA_ACP_NAME",
+      "  --agent-id              HYDRA_ACP_AGENT_ID",
+      "  --resume / --session-id HYDRA_ACP_SESSION_ID",
+      "  --name                  HYDRA_ACP_NAME",
       ""
     ].join("\n")
   );