@hydra-acp/cli 0.1.57 → 0.1.58

package/dist/cli.js

@@ -108,7 +108,11 @@ var init_paths = __esm({
       // line, append-only so concurrent TUIs don't lose each other's
       // writes.
       globalTuiHistoryFile: () => path.join(hydraHome(), "prompt-history"),
-      tuiLogFile: () => path.join(hydraHome(), "tui.log")
+      tuiLogFile: () => path.join(hydraHome(), "tui.log"),
+      // Diagnostic dump of every JSON-RPC message that crosses a `hydra-acp
+      // shim` process. Append-only NDJSON. One file shared by every shim;
+      // each line carries the writing process's pid for disambiguation.
+      shimWireLogFile: () => path.join(hydraHome(), "shim-wire.log")
     };
   }
 });
@@ -1025,6 +1029,12 @@ function extractHydraMeta(meta) {
   if (typeof obj.mcpStdin === "boolean") {
     out.mcpStdin = obj.mcpStdin;
   }
+  if (typeof obj.interactive === "boolean") {
+    out.interactive = obj.interactive;
+  }
+  if (typeof obj.ancillary === "boolean") {
+    out.ancillary = obj.ancillary;
+  }
   if (typeof obj.promptAmending === "boolean") {
     out.promptAmending = obj.promptAmending;
   }
@@ -1269,10 +1279,14 @@ var init_types = __esm({
       // local session, an import is a cross-machine takeover.
       forkedFromSessionId: z3.string().optional(),
       forkedFromMessageId: z3.string().optional(),
-      // clientInfo from the process that issued session/new. Lets list views
-      // hide cat-style ancillary sessions by default while letting an
-      // override flag surface them.
+      // clientInfo from the process that issued session/new. Carried for
+      // log/display; the effective filtering signal is `interactive` below.
       originatingClient: z3.object({ name: z3.string(), version: z3.string().optional() }).optional(),
+      // Tristate filter signal computed by effectiveInteractive(): explicit
+      // when the record stored a value, else inferred (legacy cat hint or
+      // history-presence). Clients can use this to render a hint glyph
+      // (e.g. dim non-interactive rows when the user toggles them in).
+      interactive: z3.boolean().optional(),
       updatedAt: z3.string(),
       attachedClients: z3.number().int().nonnegative(),
       status: z3.enum(["live", "cold"]).default("live"),
@@ -1295,7 +1309,10 @@ var init_types = __esm({
     });
     SessionPromptParams = z3.object({
       sessionId: z3.string(),
-      prompt: z3.array(z3.unknown())
+      prompt: z3.array(z3.unknown()),
+      // Hydra extensions ride under _meta["hydra-acp"] (e.g. `ancillary` to
+      // mark a non-promoting turn). Kept so Session.prompt can read them.
+      _meta: z3.record(z3.unknown()).optional()
     });
     SessionCancelParams = z3.object({
       sessionId: z3.string()
@@ -2622,6 +2639,12 @@ var init_session = __esm({
       forkedFromSessionId;
       forkedFromMessageId;
       originatingClient;
+      // Tristate. Mutates from undefined → true on first prompt (or directly
+      // false if init.interactive === false). Persisted via interactiveHandlers.
+      _interactive;
+      get interactive() {
+        return this._interactive;
+      }
       title;
       // Snapshot state delivered to attaching clients via the attach
       // response _meta rather than via history replay (which would be
@@ -2750,6 +2773,7 @@ var init_session = __esm({
       agentModelsHandlers = [];
       modelHandlers = [];
       modeHandlers = [];
+      interactiveHandlers = [];
       usageHandlers = [];
       cumulativeCost = 0;
       // Total cost across all agent lives. costAmount in the returned snapshot
@@ -2833,6 +2857,7 @@ var init_session = __esm({
         if (init.firstPromptSeeded) {
           this._firstPromptSeeded = true;
         }
+        this._interactive = init.interactive;
         this.historyStore = init.historyStore;
         this.historyMaxEntries = init.historyMaxEntries ?? DEFAULT_HISTORY_MAX_ENTRIES;
         this.compactEvery = Math.max(1, Math.floor(this.historyMaxEntries * 0.2));
@@ -3095,19 +3120,25 @@ var init_session = __esm({
         return this.loadReplay(historyPolicy, opts);
       }
       async loadReplay(historyPolicy, opts) {
-        const all = coalesceReplay(await this.getHistorySnapshot());
+        const raw = await this.getHistorySnapshot();
         const state = this.buildStateSnapshotReplay();
         if (historyPolicy === "after_message") {
-          const cutoff = opts.afterMessageId ? findMessageIdIndex(all, opts.afterMessageId) : -1;
+          const cutoff = opts.afterMessageId ? findMessageIdIndex(raw, opts.afterMessageId) : -1;
           if (cutoff < 0) {
-            return { entries: [...state, ...all], appliedPolicy: "full" };
+            return {
+              entries: [...state, ...coalesceReplay(raw)],
+              appliedPolicy: "full"
+            };
           }
           return {
-            entries: [...state, ...all.slice(cutoff + 1)],
+            entries: [...state, ...coalesceReplay(raw.slice(cutoff + 1))],
             appliedPolicy: "after_message"
           };
         }
-        return { entries: [...state, ...all], appliedPolicy: "full" };
+        return {
+          entries: [...state, ...coalesceReplay(raw)],
+          appliedPolicy: "full"
+        };
       }
       // Synthesizes one session/update notification per cached STATE_UPDATE_KIND
       // so an attaching client receives the current snapshot through the
@@ -3288,6 +3319,18 @@ var init_session = __esm({
         const messageId = generateMessageId();
         this.maybeSeedTitleFromPrompt(params);
         this._firstPromptSeeded = true;
+        const ancillary = extractHydraMeta(
+          (params ?? {})._meta
+        ).ancillary === true;
+        if (!ancillary && this._interactive === void 0) {
+          this._interactive = true;
+          for (const handler of this.interactiveHandlers) {
+            try {
+              handler(true);
+            } catch {
+            }
+          }
+        }
         return this.enqueueUserPrompt(client, params, messageId);
       }
       // DEVIATION FROM RFD #533: this broadcast is deliberately deferred
@@ -4070,13 +4113,7 @@ var init_session = __esm({
               this.logger?.info(
                 `live config_option_update(model): sessionId=${this.sessionId} ${JSON.stringify(this.currentModel)} \u2192 ${JSON.stringify(trimmed)}`
               );
-              this.currentModel = trimmed;
-              for (const handler of this.modelHandlers) {
-                try {
-                  handler(trimmed);
-                } catch {
-                }
-              }
+              this.applyModelChange(trimmed);
             }
           }
           break;
@@ -4272,6 +4309,9 @@ var init_session = __esm({
       onModeChange(handler) {
         this.modeHandlers.push(handler);
       }
+      onInteractiveChange(handler) {
+        this.interactiveHandlers.push(handler);
+      }
       // Apply a model change initiated by a client request (session/set_model)
       // when the agent doesn't emit a current_model_update notification, or
       // emits a non-spec shape (e.g. config_option_update). Fires modelHandlers
@@ -6269,6 +6309,9 @@ async function listSessions(target, opts = {}, fetchImpl = fetch) {
   if (opts.all) {
     url.searchParams.set("all", "true");
   }
+  if (opts.includeNonInteractive) {
+    url.searchParams.set("includeNonInteractive", "true");
+  }
   const response = await fetchImpl(url.toString(), {
     headers: { Authorization: `Bearer ${target.token}` }
   });
@@ -6295,7 +6338,8 @@ async function listSessions(target, opts = {}, fetchImpl = fetch) {
     forkedFromSessionId: s.forkedFromSessionId,
     forkedFromMessageId: s.forkedFromMessageId,
     busy: s.busy,
-    originatingClient: s.originatingClient
+    originatingClient: s.originatingClient,
+    interactive: s.interactive
   }));
 }
 async function forkSession(target, id, opts = {}, fetchImpl = fetch) {
@@ -6359,13 +6403,17 @@ async function regenSessionTitle(target, id, fetchImpl = fetch) {
   }
 }
 async function searchSessions(target, query, opts = {}, fetchImpl = fetch) {
-  const url = new URL(`${target.baseUrl}/v1/sessions/search`);
-  url.searchParams.set("q", query);
+  const body = { q: query };
   if (opts.sessionIds && opts.sessionIds.length > 0) {
-    url.searchParams.set("sessionIds", opts.sessionIds.join(","));
+    body.sessionIds = opts.sessionIds;
   }
-  const response = await fetchImpl(url.toString(), {
-    headers: { Authorization: `Bearer ${target.token}` }
+  const response = await fetchImpl(`${target.baseUrl}/v1/sessions/search`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${target.token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
   });
   if (!response.ok) {
     throw new Error(`daemon returned HTTP ${response.status}`);
@@ -7864,6 +7912,85 @@ var init_update_check = __esm({
   }
 });
 
+// src/core/cwd.ts
+import * as fs22 from "fs/promises";
+import * as path17 from "path";
+async function validateLocalCwd(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    return { ok: false, reason: "path is empty" };
+  }
+  const resolved = path17.resolve(expandHome(trimmed));
+  let stat5;
+  try {
+    stat5 = await fs22.stat(resolved);
+  } catch {
+    return { ok: false, reason: `${resolved} does not exist` };
+  }
+  if (!stat5.isDirectory()) {
+    return { ok: false, reason: `${resolved} is not a directory` };
+  }
+  return { ok: true, path: resolved };
+}
+async function pickInitialLocalCwd(sessionCwd) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (p) => {
+    if (!seen.has(p)) {
+      seen.add(p);
+      candidates.push(p);
+    }
+  };
+  push(sessionCwd);
+  if (sessionCwd.startsWith("/Users/")) {
+    push("/home/" + sessionCwd.slice("/Users/".length));
+  } else if (sessionCwd.startsWith("/home/")) {
+    push("/Users/" + sessionCwd.slice("/home/".length));
+  }
+  for (const candidate of candidates) {
+    try {
+      const stat5 = await fs22.stat(candidate);
+      if (stat5.isDirectory()) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function completeLocalPath(input) {
+  const lastSlash = input.lastIndexOf("/");
+  let prefix;
+  let basePrefix;
+  let dirForRead;
+  if (lastSlash === -1) {
+    prefix = "";
+    basePrefix = input;
+    dirForRead = ".";
+  } else {
+    prefix = input.slice(0, lastSlash + 1);
+    basePrefix = input.slice(lastSlash + 1);
+    dirForRead = lastSlash === 0 ? "/" : prefix;
+  }
+  const resolvedDir = path17.resolve(expandHome(dirForRead));
+  let entries;
+  try {
+    const list = await fs22.readdir(resolvedDir, { withFileTypes: true });
+    entries = list.map((e) => ({ name: e.name, isDir: e.isDirectory() }));
+  } catch {
+    return { prefix, basePrefix, matches: [] };
+  }
+  const showHidden = basePrefix.startsWith(".");
+  const matches = entries.filter((e) => e.name.startsWith(basePrefix)).filter((e) => showHidden || !e.name.startsWith(".")).map((e) => e.isDir ? `${e.name}/` : e.name).sort();
+  return { prefix, basePrefix, matches };
+}
+var init_cwd = __esm({
+  "src/core/cwd.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
 // src/tui/input.ts
 function formatPasteToken(id, lineCount) {
   return `[pasted #${id} +${lineCount} lines]`;
@@ -8125,12 +8252,18 @@ var init_input = __esm({
             return [];
           case "ctrl-c":
             return this.handleCtrlC();
-          case "ctrl-d":
+          case "ctrl-d": {
             if (this.bufferIsEmpty()) {
               return [{ type: "exit" }];
             }
+            const lastLine = this.buffer[this.buffer.length - 1] ?? "";
+            const atEndOfBuffer = this.row === this.buffer.length - 1 && this.col >= lastLine.length;
+            if (atEndOfBuffer) {
+              return [{ type: "exit" }];
+            }
             this.deleteForward();
             return [];
+          }
           case "ctrl-l":
             return [{ type: "redraw" }];
           case "ctrl-p":
@@ -8808,9 +8941,9 @@ var init_input = __esm({
 });
 
 // src/tui/attachments.ts
-import path17 from "path";
+import path18 from "path";
 function mimeFromExtension(p) {
-  return EXTENSION_TO_MIME[path17.extname(p).toLowerCase()] ?? null;
+  return EXTENSION_TO_MIME[path18.extname(p).toLowerCase()] ?? null;
 }
 function isSupportedImagePath(p) {
   return mimeFromExtension(p) !== null;
@@ -10698,9 +10831,9 @@ uncaught: ${err.stack ?? err.message}
         this.permissionPrompt = spec ? { ...spec } : null;
         this.repaint();
       }
-      // Two-line confirmation modal that takes over the prompt area. Used to
-      // ask "interrupt before exit?" when the user quits during an in-flight
-      // turn that no one else is watching. Pass null to dismiss.
+      // Two-line confirmation modal that takes over the prompt area. Pass
+      // null to dismiss. Currently unused — kept as a generic primitive for
+      // any future modal that needs a question + hint footer.
       setConfirmPrompt(spec) {
         this.confirmPrompt = spec ? { ...spec } : null;
         this.repaint();
@@ -12301,7 +12434,11 @@ var init_import_action_prompt = __esm({
 // src/tui/picker.ts
 function createPickerPrefs() {
   return {
-    filters: { cwdOnly: false, hostFilter: "__local", showCat: false }
+    filters: {
+      cwdOnly: false,
+      hostFilter: "__local",
+      includeNonInteractive: false
+    }
   };
 }
 async function pickSession(term, opts) {
@@ -12329,10 +12466,8 @@ async function pickSession(term, opts) {
     if (prefs.filters.cwdOnly) {
       base = base.filter((s) => s.cwd === opts.cwd);
     }
-    if (!prefs.filters.showCat) {
-      base = base.filter(
-        (s) => s.originatingClient?.name !== HYDRA_CAT_CLIENT_NAME
-      );
+    if (!prefs.filters.includeNonInteractive) {
+      base = base.filter((s) => s.interactive === true);
     }
     base = filterByHost(base, prefs.filters.hostFilter);
     return base;
@@ -12534,8 +12669,8 @@ async function pickSession(term, opts) {
         prefs.filters.hostFilter === "__local" ? "host: local" : `host: ${prefs.filters.hostFilter}`
       );
     }
-    if (prefs.filters.showCat) {
-      parts.push("+cat");
+    if (prefs.filters.includeNonInteractive) {
+      parts.push("+non-interactive");
     }
     if (above > 0) {
       parts.push(`\u2191 ${above} above`);
@@ -13176,7 +13311,9 @@ ${cells}`;
       try {
         const beforeKey = refreshOpts.silent ? renderFingerprint() : "";
         const beforeTotal = total;
-        const next = await listSessions(opts.target);
+        const next = await listSessions(opts.target, {
+          includeNonInteractive: true
+        });
         const followId = preferredId ?? (selectedIdx > 0 ? visible[selectedIdx - 1]?.sessionId : void 0);
         allSessions = sortSessions(next, opts.cwd);
         applyFilter();
@@ -13654,7 +13791,7 @@ ${cells}`;
         const effects = composer.feed(event);
         const after = composer.state();
         const unchanged = before.buffer.length === after.buffer.length && before.buffer.every((line, i) => line === after.buffer[i]) && before.row === after.row && before.col === after.col;
-        if (effects.some((e) => e.type === "exit") || unchanged && name === "CTRL_D") {
+        if (effects.some((e) => e.type === "exit")) {
           cleanup();
           resolve8({ kind: "abort" });
           return;
@@ -13754,7 +13891,7 @@ ${cells}`;
         }
         if (name === "i" || name === "I") {
           const keepId = selectedIdx > 0 ? visible[selectedIdx - 1]?.sessionId : void 0;
-          prefs.filters.showCat = !prefs.filters.showCat;
+          prefs.filters.includeNonInteractive = !prefs.filters.includeNonInteractive;
           applyFilter();
           restoreCursorAfterFilter(keepId);
           renderFromScratch();
@@ -14020,7 +14157,6 @@ var init_picker = __esm({
     init_session_row();
     init_paths();
     init_session();
-    init_hydra_version();
     init_discovery();
     init_history();
     init_input();
@@ -14060,85 +14196,6 @@ var init_picker = __esm({
   }
 });
 
-// src/core/cwd.ts
-import * as fs21 from "fs/promises";
-import * as path18 from "path";
-async function validateLocalCwd(input) {
-  const trimmed = input.trim();
-  if (trimmed.length === 0) {
-    return { ok: false, reason: "path is empty" };
-  }
-  const resolved = path18.resolve(expandHome(trimmed));
-  let stat5;
-  try {
-    stat5 = await fs21.stat(resolved);
-  } catch {
-    return { ok: false, reason: `${resolved} does not exist` };
-  }
-  if (!stat5.isDirectory()) {
-    return { ok: false, reason: `${resolved} is not a directory` };
-  }
-  return { ok: true, path: resolved };
-}
-async function pickInitialLocalCwd(sessionCwd) {
-  const candidates = [];
-  const seen = /* @__PURE__ */ new Set();
-  const push = (p) => {
-    if (!seen.has(p)) {
-      seen.add(p);
-      candidates.push(p);
-    }
-  };
-  push(sessionCwd);
-  if (sessionCwd.startsWith("/Users/")) {
-    push("/home/" + sessionCwd.slice("/Users/".length));
-  } else if (sessionCwd.startsWith("/home/")) {
-    push("/Users/" + sessionCwd.slice("/home/".length));
-  }
-  for (const candidate of candidates) {
-    try {
-      const stat5 = await fs21.stat(candidate);
-      if (stat5.isDirectory()) {
-        return candidate;
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-async function completeLocalPath(input) {
-  const lastSlash = input.lastIndexOf("/");
-  let prefix;
-  let basePrefix;
-  let dirForRead;
-  if (lastSlash === -1) {
-    prefix = "";
-    basePrefix = input;
-    dirForRead = ".";
-  } else {
-    prefix = input.slice(0, lastSlash + 1);
-    basePrefix = input.slice(lastSlash + 1);
-    dirForRead = lastSlash === 0 ? "/" : prefix;
-  }
-  const resolvedDir = path18.resolve(expandHome(dirForRead));
-  let entries;
-  try {
-    const list = await fs21.readdir(resolvedDir, { withFileTypes: true });
-    entries = list.map((e) => ({ name: e.name, isDir: e.isDirectory() }));
-  } catch {
-    return { prefix, basePrefix, matches: [] };
-  }
-  const showHidden = basePrefix.startsWith(".");
-  const matches = entries.filter((e) => e.name.startsWith(basePrefix)).filter((e) => showHidden || !e.name.startsWith(".")).map((e) => e.isDir ? `${e.name}/` : e.name).sort();
-  return { prefix, basePrefix, matches };
-}
-var init_cwd = __esm({
-  "src/core/cwd.ts"() {
-    "use strict";
-    init_config();
-  }
-});
-
 // src/tui/completion.ts
 function longestCommonPrefix(names) {
   if (names.length === 0) {
@@ -14189,24 +14246,25 @@ async function promptForImportCwd(term, session, opts = {}) {
   const defaultCwd = opts.defaultCwd ?? await pickInitialLocalCwd(session.cwd) ?? os6.homedir();
   resetTerminalModes();
   const shortId2 = stripHydraSessionPrefix(session.sessionId);
-  const fromMachine = session.importedFromMachine ?? "another machine";
   const originalCwd = shortenHomePath(session.cwd);
+  const title = opts.title ?? "Fork locally \u2014 choose cwd";
+  const intro = opts.intro ?? "Pick a local cwd for this session:";
+  const headerRows = [
+    { label: "session: ", value: shortId2 },
+    ...session.importedFromMachine ? [{ label: "from:    ", value: session.importedFromMachine }] : [],
+    { label: "cwd:     ", value: originalCwd }
+  ];
   let buffer = defaultCwd;
   let errorLine = null;
   let busy = false;
   let layout = null;
   const render = () => {
-    const contentHeight = 9;
+    const contentHeight = headerRows.length + 6;
     layout = drawBox(term, {
       contentHeight,
-      title: "Fork locally \u2014 choose cwd"
+      title
     });
     const innerW = layout.contentW;
-    const headerRows = [
-      { label: "session: ", value: shortId2 },
-      { label: "from:    ", value: fromMachine },
-      { label: "cwd:     ", value: originalCwd }
-    ];
     let row = 0;
     for (const hr of headerRows) {
       term.moveTo(layout.contentX, layout.contentY + row);
@@ -14216,7 +14274,7 @@ async function promptForImportCwd(term, session, opts = {}) {
     }
     row++;
     term.moveTo(layout.contentX, layout.contentY + row);
-    term.noFormat(" Pick a local cwd for this session:");
+    term.noFormat(` ${intro}`);
     row += 2;
     paintInputRow(row);
     row += 2;
@@ -14230,7 +14288,7 @@ async function promptForImportCwd(term, session, opts = {}) {
       );
     }
   };
-  const inputRow = () => 6;
+  const inputRow = () => headerRows.length + 3;
   const paintInputRow = (rowOffset) => {
     if (!layout) {
       return;
@@ -14411,7 +14469,7 @@ var init_import_cwd_prompt = __esm({
 
 // src/tui/clipboard.ts
 import { spawn as nodeSpawn } from "child_process";
-import fs22 from "fs/promises";
+import fs23 from "fs/promises";
 import os7 from "os";
 import path19 from "path";
 async function readClipboard(envIn = {}) {
@@ -14452,7 +14510,7 @@ async function readMacOS(env) {
       return img;
     }
   } catch {
-    await fs22.unlink(tmpPath).catch(() => void 0);
+    await fs23.unlink(tmpPath).catch(() => void 0);
   }
   try {
     const buf = await runCapture(env.spawn, "pbpaste", []);
@@ -14567,9 +14625,9 @@ async function which(env, cmd) {
 }
 async function readFileAsAttachment(p, unlinkAfter) {
   try {
-    const buf = await fs22.readFile(p);
+    const buf = await fs23.readFile(p);
     if (unlinkAfter) {
-      await fs22.unlink(p).catch(() => void 0);
+      await fs23.unlink(p).catch(() => void 0);
     }
     if (buf.length === 0) {
       return { ok: false, reason: "no image on clipboard" };
@@ -14694,7 +14752,7 @@ function parseReattachResponse(result) {
   return out;
 }
 function shouldDriftSnap(args) {
-  return !args.replayDraining && args.pendingTurns > 0 && args.queueSize === 0 && !args.ownTurnInFlight && !args.hasInFlightHead;
+  return !args.replayDraining && !args.amended && args.pendingTurns > 0 && args.queueSize === 0 && !args.ownTurnInFlight && !args.hasInFlightHead;
 }
 function computeAttachReconcile(args) {
   if (args.daemonTurnStartedAt !== void 0) {
@@ -14715,10 +14773,10 @@ var init_reconnect_state = __esm({
 });
 
 // src/tui/app.ts
-import { appendFileSync, statSync, renameSync } from "fs";
+import { appendFileSync, statSync as statSync2, renameSync as renameSync2 } from "fs";
 import { nanoid as nanoid3 } from "nanoid";
 import termkit from "terminal-kit";
-import fs23 from "fs/promises";
+import fs24 from "fs/promises";
 import path20 from "path";
 function isReadonlyForbiddenEffect(effect) {
   switch (effect.type) {
@@ -14856,6 +14914,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     }
   };
   let pendingTurns = 0;
+  let cancelling = false;
   let currentHeadMessageId;
   let sessionBusySince = null;
   let sessionElapsedTimer = null;
@@ -14866,6 +14925,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     pendingTurns = Math.max(0, pendingTurns + delta);
     const screenReady = typeof screenRef !== "undefined" && screenRef !== null;
     if (before === 0 && pendingTurns > 0) {
+      cancelling = false;
       sessionBusySince = Date.now();
       lastUpdateAt = Date.now();
       dispatcherRef?.setTurnRunning(true);
@@ -14886,6 +14946,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         }, 1e3);
       }
     } else if (before > 0 && pendingTurns === 0) {
+      cancelling = false;
       sessionBusySince = null;
       lastUpdateAt = null;
       dispatcherRef?.setTurnRunning(false);
@@ -14900,6 +14961,11 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
           stalled: false
         });
       }
+    } else if (pendingTurns > 0 && cancelling) {
+      cancelling = false;
+      if (screenReady) {
+        screenRef.setBanner({ status: "busy", stalled: false });
+      }
     }
     void delta;
   };
@@ -15258,18 +15324,19 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       historyPolicy: "full",
       clientInfo: { name: "hydra-acp-tui", version: HYDRA_VERSION },
       ...opts.readonly === true ? { readonly: true } : {},
-      // Forward the user-chosen cwd for first-launch imported sessions
-      // via a full resume hint. upstreamSessionId is empty so the
-      // daemon routes through doResurrectFromImport (session-manager.ts)
-      // with the user-supplied cwd instead of silently falling back to
-      // $HOME in resolveImportCwd.
-      ...ctx.importAttachHint !== void 0 ? {
+      // Forward the user-chosen cwd via a full resume hint. An empty
+      // upstreamSessionId routes through doResurrectFromImport
+      // (first-launch imports); a real one takes the normal session/load
+      // path (repairing a local session whose recorded cwd is gone).
+      // Either way the daemon resurrects with this cwd instead of the
+      // stale recorded one.
+      ...ctx.resumeHint !== void 0 ? {
         _meta: {
           [HYDRA_META_KEY]: {
             resume: {
-              upstreamSessionId: "",
-              agentId: ctx.importAttachHint.agentId,
-              cwd: ctx.importAttachHint.cwd
+              upstreamSessionId: ctx.resumeHint.upstreamSessionId,
+              agentId: ctx.resumeHint.agentId,
+              cwd: ctx.resumeHint.cwd
             }
           }
         }
@@ -15356,9 +15423,6 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         if (pendingPermission && tryHandlePermissionKey(ev)) {
           continue;
         }
-        if (exitConfirmation && tryHandleExitConfirmKey(ev)) {
-          continue;
-        }
         if (tryHandleHelpKey(ev)) {
           continue;
         }
@@ -15572,86 +15636,35 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
   const cancelRemoteTurn = () => {
     conn.notify("session/cancel", { sessionId: resolvedSessionId }).catch(() => void 0);
   };
-  const sigintHandler = () => {
-    if (turnInFlight) {
-      turnInFlight.cancel();
+  const markCancelling = () => {
+    if (screenRef === null) {
       return;
     }
-    if (pendingTurns > 0) {
-      cancelRemoteTurn();
+    if (pendingTurns !== 1) {
       return;
     }
-    void requestExit();
+    cancelling = true;
+    screenRef.setBanner({
+      status: "cancelling",
+      elapsedMs: void 0,
+      stalled: false
+    });
   };
-  let exitConfirmation = null;
-  const requestExit = async () => {
-    if (exitConfirmation) {
-      stop(0);
-      return;
-    }
-    if (pendingTurns === 0) {
-      stop(0);
-      return;
-    }
-    let onlyClient = false;
-    try {
-      const sessions = await listSessions(target);
-      const me = sessions.find((s) => s.sessionId === resolvedSessionId);
-      onlyClient = !me || me.attachedClients <= 1;
-    } catch {
-      stop(0);
+  const sigintHandler = () => {
+    if (turnInFlight) {
+      turnInFlight.cancel();
+      markCancelling();
       return;
     }
-    if (!onlyClient) {
-      stop(0);
+    if (pendingTurns > 0) {
+      cancelRemoteTurn();
+      markCancelling();
       return;
     }
-    exitConfirmation = { offered: true };
-    screen.setConfirmPrompt({
-      question: "Agent is still working. Interrupt it before exit?",
-      hint: "y interrupt then exit \xB7 n / Enter detach silently \xB7 Esc cancel"
-    });
-  };
-  const dismissExitConfirmation = () => {
-    exitConfirmation = null;
-    screen.setConfirmPrompt(null);
+    requestExit();
   };
-  const tryHandleExitConfirmKey = (ev) => {
-    if (!exitConfirmation) {
-      return false;
-    }
-    if (ev.type === "char") {
-      const ch = ev.ch.toLowerCase();
-      if (ch === "y") {
-        dismissExitConfirmation();
-        conn.notify("session/cancel", { sessionId: resolvedSessionId }).catch(() => void 0);
-        stop(0);
-        return true;
-      }
-      if (ch === "n") {
-        dismissExitConfirmation();
-        stop(0);
-        return true;
-      }
-      return true;
-    }
-    if (ev.type === "key") {
-      if (ev.name === "enter") {
-        dismissExitConfirmation();
-        stop(0);
-        return true;
-      }
-      if (ev.name === "escape") {
-        dismissExitConfirmation();
-        return true;
-      }
-      if (ev.name === "ctrl-c" || ev.name === "ctrl-d") {
-        dismissExitConfirmation();
-        stop(0);
-        return true;
-      }
-    }
-    return true;
+  const requestExit = () => {
+    stop(0);
   };
   const buildHelpEntries = () => {
     const enqueueDesc = "enqueue prompt (sends now, or queues during a turn)";
@@ -15723,7 +15736,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     let resolvedChoice = null;
     let attachOverrides = null;
     while (resolvedChoice === null) {
-      const sessions = await listSessions(target);
+      const sessions = await listSessions(target, { includeNonInteractive: true });
       const choice2 = await pickSession(term, {
         cwd: resolvedCwd,
         sessions,
@@ -15761,14 +15774,43 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
           readonly: false,
           cwd: decided2.ctx.cwd
         };
-        if (decided2.ctx.importAttachHint !== void 0) {
-          attachOverrides.importAttachHint = decided2.ctx.importAttachHint;
+        if (decided2.ctx.resumeHint !== void 0) {
+          attachOverrides.resumeHint = decided2.ctx.resumeHint;
         }
         break;
       }
       const chosen = sessions.find((s) => s.sessionId === choice2.sessionId);
       const isImportedFirstLaunch = chosen !== void 0 && !!chosen.importedFromMachine && !chosen.upstreamSessionId && choice2.readonly !== true;
       if (!isImportedFirstLaunch) {
+        if (target.isLocal && chosen && !chosen.importedFromMachine && choice2.readonly !== true) {
+          const v = await validateLocalCwd(chosen.cwd);
+          if (!v.ok) {
+            const r = await promptForImportCwd(term, chosen, {
+              defaultCwd: expandHome(config.defaultCwd),
+              title: "Working directory missing \u2014 choose cwd",
+              intro: "This session's working directory no longer exists. Pick a new one:"
+            });
+            if (r.kind === "cancel") {
+              screen.start({ skipFullscreen: true });
+              screen.resumeRepaint();
+              return;
+            }
+            if (r.kind === "back") {
+              continue;
+            }
+            resolvedChoice = { choice: choice2, sessions };
+            attachOverrides = {
+              readonly: false,
+              cwd: r.path,
+              resumeHint: {
+                agentId: choice2.agentId ?? chosen.agentId ?? "",
+                cwd: r.path,
+                upstreamSessionId: ""
+              }
+            };
+            break;
+          }
+        }
         resolvedChoice = { choice: choice2, sessions };
         break;
       }
@@ -15787,8 +15829,8 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         readonly: opsShim.readonly === true,
         cwd: decided.ctx.cwd
       };
-      if (decided.ctx.importAttachHint !== void 0) {
-        attachOverrides.importAttachHint = decided.ctx.importAttachHint;
+      if (decided.ctx.resumeHint !== void 0) {
+        attachOverrides.resumeHint = decided.ctx.resumeHint;
       }
     }
     const { choice } = resolvedChoice;
@@ -15823,10 +15865,10 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     if (choice.agentId !== void 0) {
       nextOpts.agentId = choice.agentId;
     }
-    if (attachOverrides?.importAttachHint !== void 0) {
-      nextOpts.importAttachHint = attachOverrides.importAttachHint;
+    if (attachOverrides?.resumeHint !== void 0) {
+      nextOpts.resumeHint = attachOverrides.resumeHint;
     } else {
-      delete nextOpts.importAttachHint;
+      delete nextOpts.resumeHint;
     }
     resume(nextOpts);
   };
@@ -15929,10 +15971,11 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         } else if (pendingTurns > 0) {
           cancelRemoteTurn();
         }
+        markCancelling();
         return;
       }
       case "exit":
-        void requestExit();
+        requestExit();
         return;
       case "plan-toggle":
         void handleModeToggle(effect.on);
@@ -16020,7 +16063,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         continue;
       }
       try {
-        const buf = await fs23.readFile(token);
+        const buf = await fs24.readFile(token);
         if (buf.length > MAX_ATTACHMENT_BYTES) {
           screen.notify(
             `image too large (${formatSize(buf.length)}, max ${formatSize(MAX_ATTACHMENT_BYTES)})`
@@ -16230,7 +16273,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     switch (cmd) {
       case "/quit":
       case "/exit":
-        void requestExit();
+        requestExit();
         return true;
       case "/clear":
         toolStates.clear();
@@ -16241,6 +16284,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         toolsBlockStopReason = null;
         toolsExpanded = false;
         lastEditMarkPath = null;
+        turnHasShownProse = false;
         screen.clearScrollback();
         return true;
       case "/demo-plan": {
@@ -16586,6 +16630,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     }
   };
   let lastEditMarkPath = null;
+  let turnHasShownProse = false;
   const maybeRenderEditDiff = (toolCallId) => {
     const mode = config.tui.showFileUpdates;
     if (mode === "none") {
@@ -16602,6 +16647,9 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       }
       return;
     }
+    if (!turnHasShownProse) {
+      return;
+    }
     const diff = state.editDiff;
     if (diff.path && diff.path === lastEditMarkPath) {
       return;
@@ -16687,6 +16735,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       toolsExpanded = false;
       toolsBlockEndedAt = null;
       lastEditMarkPath = null;
+      turnHasShownProse = false;
       startToolsBlock();
       screen.redraw();
       return;
@@ -16694,6 +16743,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     if (event.kind === "agent-text") {
       closeThought();
       if (event.text.length > 0) {
+        turnHasShownProse = true;
         lastEditMarkPath = null;
       }
       appendAgentText(event.text);
@@ -16702,6 +16752,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     if (event.kind === "agent-thought") {
       closeAgentText();
       if (viewPrefs.showThoughts && event.text.length > 0) {
+        turnHasShownProse = true;
         lastEditMarkPath = null;
       }
       appendThought(event.text);
@@ -16825,13 +16876,15 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       toolsExpanded = false;
       upstreamInterruptedSeen = false;
       lastEditMarkPath = null;
+      turnHasShownProse = false;
       screen.ensureSeparator();
       if (shouldDriftSnap({
         pendingTurns,
         queueSize: queueCache.size,
         ownTurnInFlight: turnInFlight !== null,
         hasInFlightHead: currentHeadMessageId !== void 0,
-        replayDraining
+        replayDraining,
+        amended: event.amended === true
       })) {
         adjustPendingTurns(-pendingTurns);
       }
@@ -16910,6 +16963,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     toolsBlockStopReason = null;
     toolsExpanded = false;
     lastEditMarkPath = null;
+    turnHasShownProse = false;
   };
   onDisconnectHook = () => {
     screen.setBanner({ status: "disconnected", elapsedMs: void 0 });
@@ -17059,8 +17113,8 @@ async function resolveSession(term, config, target, opts, pickerPrefs) {
       agentId: opts.agentId ?? "",
       cwd
     };
-    if (opts.importAttachHint !== void 0) {
-      ctx.importAttachHint = opts.importAttachHint;
+    if (opts.resumeHint !== void 0) {
+      ctx.resumeHint = opts.resumeHint;
     }
     return ctx;
   }
@@ -17082,7 +17136,7 @@ async function resolveSession(term, config, target, opts, pickerPrefs) {
     };
   }
   while (true) {
-    const sessions = await listSessions(target);
+    const sessions = await listSessions(target, { includeNonInteractive: true });
     const choice = await pickSession(term, {
       cwd,
       sessions,
@@ -17122,6 +17176,33 @@ async function resolveSession(term, config, target, opts, pickerPrefs) {
       }
       return decided.ctx;
     }
+    if (target.isLocal && chosen && !chosen.importedFromMachine && !opts.readonly) {
+      const v = await validateLocalCwd(chosen.cwd);
+      if (!v.ok) {
+        const r = await promptForImportCwd(term, chosen, {
+          defaultCwd: expandHome(config.defaultCwd),
+          title: "Working directory missing \u2014 choose cwd",
+          intro: "This session's working directory no longer exists. Pick a new one:"
+        });
+        if (r.kind === "cancel") {
+          return null;
+        }
+        if (r.kind === "back") {
+          continue;
+        }
+        const agentId = choice.agentId ?? chosen.agentId ?? "";
+        return {
+          sessionId: choice.sessionId,
+          agentId,
+          cwd: r.path,
+          resumeHint: {
+            agentId,
+            cwd: r.path,
+            upstreamSessionId: ""
+          }
+        };
+      }
+    }
     return {
       sessionId: choice.sessionId,
       agentId: choice.agentId ?? "",
@@ -17164,7 +17245,9 @@ async function runImportedFirstLaunchFlow(term, chosen, choice, opts) {
         sessionId: choice.sessionId,
         agentId,
         cwd: cwdResult.path,
-        importAttachHint: { agentId, cwd: cwdResult.path }
+        // Empty upstreamSessionId → import-reseed path for a never-launched
+        // imported session.
+        resumeHint: { agentId, cwd: cwdResult.path, upstreamSessionId: "" }
       }
     };
   }
@@ -17208,9 +17291,15 @@ fork failed: ${err.message}
       // For foreign-never-launched forks, the daemon stamped the chosen
       // cwd onto meta.json via the POST body, but the very first attach
       // still goes through the import-reseed path (upstreamSessionId=""),
-      // and importAttachHint is what makes attachManagerHooks persist
+      // and the resume hint is what makes attachManagerHooks persist
       // the local cwd over the bundle's recorded one.
-      ...isForeignNeverLaunched ? { importAttachHint: { agentId: choice.sourceAgentId ?? "", cwd } } : {}
+      ...isForeignNeverLaunched ? {
+        resumeHint: {
+          agentId: choice.sourceAgentId ?? "",
+          cwd,
+          upstreamSessionId: ""
+        }
+      } : {}
     }
   };
 }
@@ -17336,11 +17425,11 @@ function createInstallStatusLine(term, baseLabel) {
 }
 function rotateIfBig(target) {
   try {
-    const stat5 = statSync(target);
+    const stat5 = statSync2(target);
     if (stat5.size < logMaxBytes) {
       return;
     }
-    renameSync(target, `${target}.0`);
+    renameSync2(target, `${target}.0`);
   } catch {
   }
 }
@@ -17352,6 +17441,7 @@ var init_app = __esm({
     init_types();
     init_resilient_ws();
     init_config();
+    init_cwd();
     init_remote_target();
     init_daemon_bootstrap();
     init_bin_name();
@@ -18849,10 +18939,17 @@ var SessionRecord = z5.object({
   // ended at. Kept so future UI can show "branched from turn N of session X".
   forkedFromSessionId: z5.string().optional(),
   forkedFromMessageId: z5.string().optional(),
-  // clientInfo from the process that issued session/new. Picker and
-  // `sessions list` use this to hide cat-style ancillary sessions by
-  // default; carried in meta.json so cold sessions filter the same way.
+  // clientInfo from the process that issued session/new. Display only
+  // since the `interactive` flag below; kept on the record for log
+  // attribution and as the legacy hint inside effectiveInteractive
+  // (pre-flag cat sessions can be recognised from this field).
   originatingClient: PersistedOriginatingClient.optional(),
+  // Tristate: true once the session has had a real turn, false when
+  // explicitly created as ancillary (e.g. `hydra cat`), undefined for
+  // pre-flag records / freshly-created sessions that haven't decided
+  // yet. effectiveInteractive() in session-manager.ts is the single
+  // resolver — every filter site goes through it.
+  interactive: z5.boolean().optional(),
   createdAt: z5.string(),
   updatedAt: z5.string()
 });
@@ -18971,6 +19068,7 @@ function recordFromMemorySession(args) {
     forkedFromSessionId: args.forkedFromSessionId,
     forkedFromMessageId: args.forkedFromMessageId,
     originatingClient: args.originatingClient,
+    interactive: args.interactive,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
   };
@@ -19774,6 +19872,7 @@ var HistoryStore = class {
 
 // src/core/session-manager.ts
 init_paths();
+init_config();
 init_history();
 
 // src/core/bundle.ts
@@ -19809,6 +19908,14 @@ var BundleSession = z6.object({
   currentUsage: PersistedUsage.optional(),
   agentCommands: z6.array(PersistedAgentCommand).optional(),
   agentModes: z6.array(PersistedAgentMode).optional(),
+  // Raw interactive tristate (NOT the resolved effectiveInteractive) so
+  // the value stays promotable on the destination: a cat/empty source
+  // arrives as undefined and a real turn there can still flip it to
+  // true. Carried alongside originatingClient so the importer's
+  // effectiveInteractive can re-apply the cat-name hint at read time
+  // without freezing a sticky `false` into the record.
+  interactive: z6.boolean().optional(),
+  originatingClient: PersistedOriginatingClient.optional(),
   createdAt: z6.string(),
   updatedAt: z6.string()
 });
@@ -19852,6 +19959,8 @@ function encodeBundle(params) {
       ...params.record.currentUsage !== void 0 ? { currentUsage: params.record.currentUsage } : {},
       ...params.record.agentCommands !== void 0 ? { agentCommands: params.record.agentCommands } : {},
       ...params.record.agentModes !== void 0 ? { agentModes: params.record.agentModes } : {},
+      ...params.record.interactive !== void 0 ? { interactive: params.record.interactive } : {},
+      ...params.record.originatingClient !== void 0 ? { originatingClient: params.record.originatingClient } : {},
       createdAt: params.record.createdAt,
       updatedAt: params.record.updatedAt
     },
@@ -19890,6 +19999,7 @@ var SessionManager = class {
     this.logger = options.logger;
     this.npmRegistry = options.npmRegistry;
     this.extensionCommands = options.extensionCommands;
+    this.defaultCwd = options.defaultCwd ?? "~";
     this.synopsisCoordinator = new SynopsisCoordinator({
       registry: this.registry,
       store: this.store,
@@ -19923,6 +20033,7 @@ var SessionManager = class {
   logger;
   npmRegistry;
   extensionCommands;
+  defaultCwd;
   // Background queue for ephemeral-agent synopsis generation. Runs
   // out-of-band so session close is instant; persists synopsis/title
   // via the same enqueueMetaWrite path the in-session handlers used.
@@ -19982,6 +20093,7 @@ var SessionManager = class {
       transformChain: params.transformChain,
       parentSessionId: params.parentSessionId,
       originatingClient: params.originatingClient,
+      interactive: params.interactive,
       extensionCommands: this.extensionCommands,
       scheduleSynopsis: () => this.synopsisCoordinator.schedule(session.sessionId)
     });
@@ -20028,6 +20140,9 @@ var SessionManager = class {
     if (params.upstreamSessionId === "") {
       return this.doResurrectFromImport(params);
     }
+    if (!await this.dirExists(params.cwd)) {
+      return this.doResurrectFromImport(params);
+    }
     const plan = await planSpawn(agentDef, params.agentArgs ?? [], {
       npmRegistry: this.npmRegistry,
       onInstallProgress: params.onInstallProgress
@@ -20155,6 +20270,7 @@ var SessionManager = class {
       firstPromptSeeded: !!params.title,
       createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0,
       originatingClient: params.originatingClient,
+      interactive: params.interactive,
       forkedFromSessionId: params.forkedFromSessionId,
       forkedFromMessageId: params.forkedFromMessageId,
       extensionCommands: this.extensionCommands,
@@ -20171,7 +20287,7 @@ var SessionManager = class {
   // so subsequent resurrects of this session use the normal session/load
   // path.
   async doResurrectFromImport(params) {
-    const cwd = await this.resolveImportCwd(params.cwd);
+    const cwd = await this.resolveResurrectCwd(params.cwd);
     const fresh = await this.bootstrapAgent({
       agentId: params.agentId,
       cwd,
@@ -20226,6 +20342,7 @@ var SessionManager = class {
       firstPromptSeeded: !!params.title,
       createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0,
       originatingClient: params.originatingClient,
+      interactive: params.interactive,
       forkedFromSessionId: params.forkedFromSessionId,
       forkedFromMessageId: params.forkedFromMessageId,
       extensionCommands: this.extensionCommands,
@@ -20235,15 +20352,50 @@ var SessionManager = class {
     void session.seedFromImport().catch(() => void 0);
     return session;
   }
-  async resolveImportCwd(cwd) {
+  async dirExists(cwd) {
     try {
-      const stat5 = await fs14.stat(cwd);
-      if (stat5.isDirectory()) {
-        return cwd;
-      }
+      return (await fs14.stat(cwd)).isDirectory();
     } catch {
+      return false;
     }
-    return os3.homedir();
+  }
+  // When the last client detaches from a session that resolves to
+  // non-interactive — e.g. a `hydra cat` run, born interactive:undefined
+  // with originatingClient hydra-acp-cat, whose every prompt is ancillary
+  // — close it so its agent process doesn't linger until the (default 1h)
+  // idle timeout fires. The cold record is kept, so the rare refine-in-TUI
+  // still works via the resurrect/reseed path. Sessions promoted to
+  // interactive (driven by a real, non-ancillary prompt) resolve to true
+  // and are left running.
+  async reapIfOrphanedNonInteractive(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session || session.attachedCount > 0) {
+      return;
+    }
+    const interactive = effectiveInteractive(
+      {
+        interactive: session.interactive,
+        ...session.originatingClient ? { originatingClient: session.originatingClient } : {}
+      },
+      true
+    );
+    if (interactive !== false) {
+      return;
+    }
+    this.logger?.info(
+      `reaping orphaned non-interactive session ${sessionId} (agent killed, cold record kept)`
+    );
+    await session.close({ deleteRecord: false }).catch(() => void 0);
+  }
+  // Resolve a recorded cwd for resurrect: use it if it still exists,
+  // otherwise fall back to the configured defaultCwd. Covers both bundles
+  // imported from another machine and local sessions (e.g. `cat`) whose
+  // recorded dir was cleaned up, so the reseed spawn never ENOENTs.
+  async resolveResurrectCwd(cwd) {
+    if (await this.dirExists(cwd)) {
+      return cwd;
+    }
+    return expandHome(this.defaultCwd);
   }
   // Pull every session the agent itself remembers (across all cwds) and
   // persist a cold hydra record for each one we don't already track.
@@ -20332,6 +20484,10 @@ var SessionManager = class {
         agentId,
         cwd: entry.cwd,
         pendingHistorySync: true,
+        // `hydra agent sync` is a user-explicit "show me agent-side
+        // sessions" action; the rows are meant to be visible immediately
+        // even before the first resurrect populates history.jsonl.
+        interactive: true,
         createdAt: ts,
         updatedAt: ts
       };
@@ -20498,6 +20654,11 @@ var SessionManager = class {
         () => void 0
       );
     });
+    session.onInteractiveChange((interactive) => {
+      void this.persistSnapshot(session.sessionId, { interactive }).catch(
+        () => void 0
+      );
+    });
     session.onUsageChange((usage) => {
       void this.persistSnapshot(session.sessionId, {
         currentUsage: usageSnapshotToPersisted(usage)
@@ -20591,6 +20752,7 @@ var SessionManager = class {
       createdAt: record.createdAt,
       pendingHistorySync: record.pendingHistorySync,
       originatingClient: record.originatingClient,
+      interactive: record.interactive,
       forkedFromSessionId: record.forkedFromSessionId,
       forkedFromMessageId: record.forkedFromMessageId
     };
@@ -20678,12 +20840,27 @@ var SessionManager = class {
   async list(filter = {}) {
     const entries = [];
     const liveIds = /* @__PURE__ */ new Set();
+    const includeRow = (interactive) => {
+      if (filter.includeNonInteractive) return true;
+      return interactive === true;
+    };
     for (const session of this.sessions.values()) {
       if (filter.cwd && session.cwd !== filter.cwd) {
         continue;
       }
       liveIds.add(session.sessionId);
-      const used = await historyMtimeIso(session.sessionId) ?? new Date(session.updatedAt).toISOString();
+      const hist = await historyStatus(session.sessionId);
+      const interactive = effectiveInteractive(
+        {
+          interactive: session.interactive,
+          ...session.originatingClient ? { originatingClient: session.originatingClient } : {}
+        },
+        hist.hasContent
+      );
+      if (!includeRow(interactive)) {
+        continue;
+      }
+      const used = hist.mtime ?? new Date(session.updatedAt).toISOString();
       entries.push({
         sessionId: session.sessionId,
         upstreamSessionId: session.upstreamSessionId,
@@ -20696,6 +20873,7 @@ var SessionManager = class {
         forkedFromSessionId: session.forkedFromSessionId,
         forkedFromMessageId: session.forkedFromMessageId,
         originatingClient: session.originatingClient,
+        interactive,
         updatedAt: used,
         attachedClients: session.attachedCount,
         status: "live",
@@ -20710,7 +20888,12 @@ var SessionManager = class {
       if (filter.cwd && r.cwd !== filter.cwd) {
         continue;
       }
-      const used = await historyMtimeIso(r.sessionId) ?? r.updatedAt;
+      const hist = await historyStatus(r.sessionId);
+      const interactive = effectiveInteractive(r, hist.hasContent);
+      if (!includeRow(interactive)) {
+        continue;
+      }
+      const used = hist.mtime ?? r.updatedAt;
       entries.push({
         sessionId: r.sessionId,
         upstreamSessionId: r.upstreamSessionId,
@@ -20728,6 +20911,7 @@ var SessionManager = class {
         forkedFromSessionId: r.forkedFromSessionId,
         forkedFromMessageId: r.forkedFromMessageId,
         originatingClient: r.originatingClient,
+        interactive,
         updatedAt: used,
         attachedClients: 0,
         status: "cold",
@@ -20962,8 +21146,18 @@ var SessionManager = class {
         currentUsage: args.bundle.session.currentUsage,
         agentCommands: args.bundle.session.agentCommands,
         agentModes: args.bundle.session.agentModes,
+        // Carry the source's raw interactive tristate and originating
+        // client rather than forcing true. A real conversation arrives
+        // as true (visible immediately); an empty source arrives as
+        // undefined (hidden until a turn lands here); a cat source
+        // arrives as undefined + cat originatingClient, so
+        // effectiveInteractive hides it via the hint while leaving it
+        // promotable. Legacy bundles (pre-flag) carry neither and fall
+        // back to effectiveInteractive's history-presence inference.
+        interactive: args.bundle.session.interactive,
+        originatingClient: args.bundle.session.originatingClient,
         createdAt: args.preservedCreatedAt ?? now,
-        // Fallback path for historyMtimeIso (used when the history file
+        // Fallback path for historyStatus (used when the history file
         // is missing). Keep this consistent with the utimes stamp above.
         updatedAt: args.bundle.session.updatedAt
       });
@@ -21072,6 +21266,8 @@ var SessionManager = class {
         ...update.agentCommands !== void 0 ? { agentCommands: update.agentCommands } : {},
         ...update.agentModes !== void 0 ? { agentModes: update.agentModes } : {},
         ...update.agentModels !== void 0 ? { agentModels: update.agentModels } : {},
+        ...update.interactive !== void 0 ? { interactive: update.interactive } : {},
+        ...update.cwd !== void 0 ? { cwd: update.cwd } : {},
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
     });
@@ -21248,6 +21444,7 @@ function mergeForPersistence(session, existing) {
     forkedFromSessionId: session.forkedFromSessionId ?? existing?.forkedFromSessionId,
     forkedFromMessageId: session.forkedFromMessageId ?? existing?.forkedFromMessageId,
     originatingClient: session.originatingClient ?? existing?.originatingClient,
+    interactive: session.interactive ?? existing?.interactive,
     createdAt: existing?.createdAt ?? new Date(session.createdAt).toISOString()
   });
 }
@@ -21554,13 +21751,25 @@ async function loadPromptHistorySafely(sessionId) {
     return [];
   }
 }
-async function historyMtimeIso(sessionId) {
+async function historyStatus(sessionId) {
   try {
     const st = await fs14.stat(paths.historyFile(sessionId));
-    return new Date(st.mtimeMs).toISOString();
+    return {
+      mtime: new Date(st.mtimeMs).toISOString(),
+      hasContent: st.size > 0
+    };
   } catch {
-    return void 0;
+    return { hasContent: false };
+  }
+}
+function effectiveInteractive(record, hasContent) {
+  if (record.interactive !== void 0) {
+    return record.interactive;
   }
+  if (record.originatingClient?.name === HYDRA_CAT_CLIENT_NAME) {
+    return false;
+  }
+  return hasContent ? true : void 0;
 }
 
 // src/core/child-supervisor.ts
@@ -23338,17 +23547,21 @@ function resolveHydraHost(defaults) {
 function registerSessionRoutes(app, manager, defaults) {
   app.get("/v1/sessions", async (request) => {
     const query = request.query;
-    const sessions = await manager.list({ cwd: query?.cwd });
+    const includeNonInteractive = query?.includeNonInteractive === "1" || query?.includeNonInteractive === "true";
+    const sessions = await manager.list({
+      cwd: query?.cwd,
+      includeNonInteractive
+    });
     return { sessions };
   });
-  app.get("/v1/sessions/search", async (request, reply) => {
-    const query = request.query;
-    const q = query?.q ?? "";
+  app.post("/v1/sessions/search", async (request, reply) => {
+    const body = request.body ?? {};
+    const q = typeof body.q === "string" ? body.q : "";
     if (q.trim().length === 0) {
       reply.code(400).send({ error: "q is required" });
       return reply;
     }
-    const ids = query?.sessionIds ? query.sessionIds.split(",").filter((s) => s.length > 0) : void 0;
+    const ids = Array.isArray(body.sessionIds) ? body.sessionIds.filter((s) => typeof s === "string" && s.length > 0) : void 0;
     const out = await searchHistories(manager, q, { sessionIds: ids });
     return out;
   });
@@ -23943,13 +24156,8 @@ function parseRegisterBody2(body) {
 }
 
 // src/daemon/routes/config.ts
-function registerConfigRoutes(app, defaults) {
-  app.get("/v1/config", async () => {
-    return {
-      defaultAgent: defaults.defaultAgent,
-      defaultCwd: defaults.defaultCwd
-    };
-  });
+function registerConfigRoutes(app, snapshot) {
+  app.get("/v1/config", async () => snapshot);
 }
 
 // src/daemon/routes/auth.ts
@@ -24469,7 +24677,8 @@ function registerAcpWsEndpoint(app, deps) {
           model: hydraMeta.model,
           onInstallProgress: makeInstallProgressForwarder(connection),
           transformChain,
-          originatingClient: state.clientInfo
+          originatingClient: state.clientInfo,
+          ...hydraMeta.interactive !== void 0 ? { interactive: hydraMeta.interactive } : {}
         });
       } catch (err) {
         if (stdinReservation !== void 0) {
@@ -24596,8 +24805,9 @@ function registerAcpWsEndpoint(app, deps) {
           err.code = JsonRpcErrorCodes.SessionNotFound;
           throw err;
         }
+        const resurrectWithOriginator = resurrectParams.originatingClient ? resurrectParams : { ...resurrectParams, originatingClient: state.clientInfo };
         session = await deps.manager.resurrect({
-          ...resurrectParams,
+          ...resurrectWithOriginator,
           onInstallProgress: makeInstallProgressForwarder(connection)
         });
         wireDefaultTransformers(session, deps);
@@ -24654,6 +24864,9 @@ function registerAcpWsEndpoint(app, deps) {
       const session = deps.manager.get(params.sessionId);
       session?.detach(att.clientId);
       state.attached.delete(params.sessionId);
+      if (session) {
+        void deps.manager.reapIfOrphanedNonInteractive(params.sessionId);
+      }
       return { sessionId: params.sessionId, status: "detached" };
     });
     connection.onRequest("session/list", async (raw) => {
@@ -25901,7 +26114,8 @@ async function startDaemon(config, serviceToken) {
     sessionHistoryMaxEntries: config.daemon.sessionHistoryMaxEntries,
     logger: agentLogger,
     npmRegistry: config.npmRegistry,
-    extensionCommands
+    extensionCommands,
+    defaultCwd: config.defaultCwd
   });
   const extensions = new ExtensionManager(extensionList(config), void 0, {
     tokenRegistry: processRegistry
@@ -25922,7 +26136,12 @@ async function startDaemon(config, serviceToken) {
   registerTransformerRoutes(app, transformers);
   registerConfigRoutes(app, {
     defaultAgent: config.defaultAgent,
-    defaultCwd: config.defaultCwd
+    defaultCwd: config.defaultCwd,
+    defaultModels: { ...config.defaultModels },
+    ...config.synopsisAgent !== void 0 ? { synopsisAgent: config.synopsisAgent } : {},
+    ...config.synopsisModel !== void 0 ? { synopsisModel: config.synopsisModel } : {},
+    synopsisOnClose: config.synopsisOnClose,
+    defaultTransformers: [...config.defaultTransformers]
   });
   registerAuthRoutes(app, {
     store: sessionTokenStore,
@@ -26410,7 +26629,6 @@ init_remote_target();
 init_remote_url();
 init_session();
 init_discovery();
-init_hydra_version();
 import * as fs19 from "fs/promises";
 import * as path16 from "path";
 init_session_row();
@@ -26419,6 +26637,9 @@ async function runSessionsList(opts = {}) {
   const serviceToken = await loadServiceToken();
   const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
   const url = new URL(`${baseUrl}/v1/sessions`);
+  if (opts.includeNonInteractive || opts.all) {
+    url.searchParams.set("includeNonInteractive", "true");
+  }
   const response = await fetch(url.toString(), {
     headers: { Authorization: `Bearer ${serviceToken}` }
   });
@@ -26428,13 +26649,11 @@ async function runSessionsList(opts = {}) {
     process.exit(1);
   }
   const body = await response.json();
-  const sessionsAfterCatFilter = opts.includeCat ? body.sessions : body.sessions.filter(
-    (s) => s.originatingClient?.name !== HYDRA_CAT_CLIENT_NAME
-  );
+  const sessionsAfterInteractiveFilter = body.sessions;
   const host = opts.host ?? "local";
-  const hostFiltered = host === "all" ? sessionsAfterCatFilter : host === "local" ? sessionsAfterCatFilter.filter(
+  const hostFiltered = host === "all" ? sessionsAfterInteractiveFilter : host === "local" ? sessionsAfterInteractiveFilter.filter(
     (s) => !s.importedFromMachine || !!s.upstreamSessionId
-  ) : sessionsAfterCatFilter.filter(
+  ) : sessionsAfterInteractiveFilter.filter(
     (s) => s.importedFromMachine === host && !s.upstreamSessionId
   );
   if (opts.json) {
@@ -28631,15 +28850,17 @@ async function runAgentsLogs(agentId, rest) {
   const logPath = paths.agentLogFile(agentId);
   await runLogTail(logPath, rest, "No log file (agent never ran?)");
 }
-async function runAgentsSetDefault(agentId) {
-  if (!agentId) {
-    process.stderr.write("Usage: hydra-acp agent set <agent-id>\n");
-    process.exit(2);
-    return;
-  }
+async function runAgentsSet(agentId, modelId) {
   const config = await loadConfig();
   const serviceToken = await loadServiceToken();
   const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  if (!agentId) {
+    const daemonView2 = await fetchDaemonAgentDefaults(baseUrl, serviceToken);
+    const view = daemonView2 ?? readAgentDefaults(await readRawConfig3());
+    process.stdout.write(`${formatDefaultLine(view)}
+`);
+    return;
+  }
   let known;
   try {
     const r = await fetch(`${baseUrl}/v1/agents`, {
@@ -28660,13 +28881,62 @@ async function runAgentsSetDefault(agentId) {
     return;
   }
   const raw = await readRawConfig3();
-  raw.defaultAgent = agentId;
-  await writeRawConfig3(raw);
+  if (modelId === void 0) {
+    raw.defaultAgent = agentId;
+    await writeRawConfig3(raw);
+  } else {
+    const models = raw.defaultModels && typeof raw.defaultModels === "object" ? raw.defaultModels : {};
+    models[agentId] = modelId;
+    raw.defaultModels = models;
+    await writeRawConfig3(raw);
+  }
+  const disk = readAgentDefaults(await readRawConfig3());
+  if (modelId !== void 0 && agentId !== disk.agent) {
+    process.stdout.write(
+      `Default model for ${agentId} is now ${modelId}.
+`
+    );
+  }
+  process.stdout.write(`${formatDefaultLine(disk)}
+`);
+  const daemonView = await fetchDaemonAgentDefaults(baseUrl, serviceToken);
+  if (daemonView === void 0) {
+    return;
+  }
+  if (daemonView.agent === disk.agent && daemonView.model === disk.model) {
+    return;
+  }
   process.stdout.write(
-    `Set defaultAgent to '${agentId}' in ${paths.config()}
+    `Daemon still has ${formatAgentModel(daemonView)} \u2014 restart with \`hydra-acp daemon restart\` to apply.
 `
   );
 }
+function formatDefaultLine(view) {
+  return `Default agent is ${formatAgentModel(view)}`;
+}
+function formatAgentModel(view) {
+  return view.model !== void 0 ? `${view.agent} with ${view.model}` : view.agent;
+}
+function readAgentDefaults(raw) {
+  const agent = typeof raw.defaultAgent === "string" ? raw.defaultAgent : "(unset)";
+  const models = raw.defaultModels && typeof raw.defaultModels === "object" ? raw.defaultModels : {};
+  const rawModel = models[agent];
+  return typeof rawModel === "string" ? { agent, model: rawModel } : { agent };
+}
+async function fetchDaemonAgentDefaults(baseUrl, serviceToken) {
+  try {
+    const r = await fetch(`${baseUrl}/v1/config`, {
+      headers: { Authorization: `Bearer ${serviceToken}` }
+    });
+    if (!r.ok) {
+      return void 0;
+    }
+    const body = await r.json();
+    return readAgentDefaults(body);
+  } catch {
+    return void 0;
+  }
+}
 async function readRawConfig3() {
   const raw = await fsp12.readFile(paths.config(), "utf8");
   return JSON.parse(raw);
@@ -28837,6 +29107,7 @@ function maxLen5(headerCell, values) {
 }
 
 // src/shim/proxy.ts
+import * as fs21 from "fs";
 init_config();
 init_remote_target();
 init_daemon_bootstrap();
@@ -29013,6 +29284,8 @@ function isResponse2(msg) {
 
 // src/shim/proxy.ts
 init_permission_pick();
+init_hydra_version();
+init_paths();
 
 // src/core/process-title.ts
 init_bin_name();
@@ -29097,6 +29370,7 @@ function wireShim({
   tracker
 }) {
   upstream.onMessage((msg) => {
+    wireLog("daemon\u2192client", msg);
     tracker.observeFromServer(msg);
     if (opts.dangerouslySkipPermissions === true && isPermissionRequest(msg)) {
       void upstream.send({
@@ -29111,7 +29385,12 @@ function wireShim({
   });
   const namingState = { name: opts.name, used: false };
   downstream.onMessage((msg) => {
+    wireLog("client\u2192daemon", msg);
     tracker.observeFromClient(msg);
+    if (isInitializeRequest(msg)) {
+      void upstream.send(normaliseInitializeClientInfo(msg));
+      return;
+    }
     if (isSessionNewRequest(msg)) {
       if (opts.sessionId) {
         void upstream.send(buildAttachFromNew(msg, opts.sessionId));
@@ -29255,6 +29534,29 @@ async function replayAttach(stream, ctx, afterMessageId) {
 function isSessionNewRequest(msg) {
   return "method" in msg && "id" in msg && msg.id !== void 0 && msg.method === "session/new";
 }
+function isInitializeRequest(msg) {
+  return "method" in msg && "id" in msg && msg.id !== void 0 && msg.method === "initialize";
+}
+function normaliseInitializeClientInfo(msg) {
+  const params = msg.params ?? {};
+  const existing = params.clientInfo;
+  const existingObj = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : void 0;
+  const existingName = existingObj && typeof existingObj.name === "string" ? existingObj.name.trim() : "";
+  if (existingName.length > 0) {
+    return msg;
+  }
+  return {
+    ...msg,
+    params: {
+      ...params,
+      clientInfo: {
+        ...existingObj ?? {},
+        name: "hydra-acp-shim",
+        version: HYDRA_VERSION
+      }
+    }
+  };
+}
 function isPermissionRequest(msg) {
   return "method" in msg && "id" in msg && msg.id !== void 0 && msg.method === "session/request_permission";
 }
@@ -29276,6 +29578,40 @@ function rewriteSessionNewWithAgent(msg, agentId) {
     params: { ...params, agentId }
   };
 }
+var WIRE_LOG_MAX_BYTES = 25 * 1024 * 1024;
+var wireLogChecked = false;
+var wireLogPath = null;
+function wireLog(direction, msg) {
+  if (!process.env.HYDRA_SHIM_WIRE_LOG) {
+    return;
+  }
+  if (!wireLogChecked) {
+    wireLogChecked = true;
+    try {
+      wireLogPath = paths.shimWireLogFile();
+      fs21.mkdirSync(paths.home(), { recursive: true });
+      const st = fs21.statSync(wireLogPath, { throwIfNoEntry: false });
+      if (st && st.size > WIRE_LOG_MAX_BYTES) {
+        fs21.renameSync(wireLogPath, `${wireLogPath}.1`);
+      }
+    } catch {
+      wireLogPath = null;
+    }
+  }
+  if (!wireLogPath) {
+    return;
+  }
+  try {
+    const line = JSON.stringify({
+      t: (/* @__PURE__ */ new Date()).toISOString(),
+      pid: process.pid,
+      dir: direction,
+      msg
+    }) + "\n";
+    fs21.appendFile(wireLogPath, line, () => void 0);
+  } catch {
+  }
+}
 function injectHydraMeta(msg, additions) {
   const params = msg.params ?? {};
   const existingMeta = params._meta ?? {};
@@ -29428,6 +29764,13 @@ function applyStyle(text, style) {
 // src/cli/commands/cat.ts
 var DEFAULT_STREAM_THRESHOLD = 1 * 1024 * 1024;
 var HYDRA_STDIN_TOOL_PREFIX = "mcp__hydra-acp-stdin__";
+function catPromptParams(sessionId, prompt) {
+  return {
+    sessionId,
+    prompt,
+    _meta: { [HYDRA_META_KEY]: { ancillary: true } }
+  };
+}
 function deriveTitleFromPrompt(prompt) {
   if (!prompt) {
     return void 0;
@@ -29608,10 +29951,7 @@ async function runCatLoop(args) {
       return;
     }
     try {
-      await conn.request("session/prompt", {
-        sessionId,
-        prompt: promptBlocks
-      });
+      await conn.request("session/prompt", catPromptParams(sessionId, promptBlocks));
       firstChunkSent = true;
     } catch (err) {
       stderr(`hydra-acp cat: prompt failed: ${err.message}
@@ -29834,10 +30174,10 @@ function runStreamingPath(args) {
     }
     await writeChain.catch(() => void 0);
     const promptText = buildStreamPromptText(opts.prompt, open2.capacityBytes);
-    const promptDone = conn.request("session/prompt", {
-      sessionId,
-      prompt: [{ type: "text", text: promptText }]
-    }).catch((err) => {
+    const promptDone = conn.request(
+      "session/prompt",
+      catPromptParams(sessionId, [{ type: "text", text: promptText }])
+    ).catch((err) => {
       args.onPromptFailed(
         new Error(`prompt failed: ${err.message}`)
       );
@@ -30167,7 +30507,7 @@ async function main() {
           all: flags.all === true,
           json: flags.json === true,
           host: typeof flags.host === "string" ? flags.host : void 0,
-          includeCat: flags["include-cat"] === true
+          includeNonInteractive: flags["include-non-interactive"] === true
         });
         return;
       }
@@ -30332,7 +30672,7 @@ async function main() {
         return;
       }
       if (sub === "set") {
-        await runAgentsSetDefault(positional[2]);
+        await runAgentsSet(positional[2], positional[3]);
         return;
       }
       if (sub === "log" || sub === "logs") {
@@ -30540,10 +30880,10 @@ function printHelp() {
       "  hydra-acp daemon start [--foreground]   Start daemon (detached by default; --foreground to attach)",
       "  hydra-acp daemon stop|restart",
       "  hydra-acp daemon logs [-f] [-n N]  Tail or follow the daemon log",
-      "  hydra-acp session [list] [--all] [--json] [--host=<host>] [--include-cat]",
-      "                                     List sessions (live + 20 most-recent cold; --all for everything; --json emits JSON for scripts).",
+      "  hydra-acp session [list] [--all] [--json] [--host=<host>] [--include-non-interactive]",
+      "                                     List sessions (live + 20 most-recent cold; --all lifts the cold cap AND surfaces non-interactive sessions; --json emits JSON for scripts).",
       "                                     --host filters by origin machine: 'local' (default) shows only sessions created here, 'all' shows everything, or pass a hostname (e.g. machine-b) to show only imports from that peer.",
-      "                                     --include-cat surfaces sessions spawned by `hydra cat` (hidden by default).",
+      "                                     --include-non-interactive surfaces ancillary (e.g. `hydra cat`) or never-prompted sessions while keeping the cold cap (a narrower --all).",
       "  hydra-acp session info <id> [--verbose] [--json] [--diff] [--fold] [--no-color] [--no-pager]",
       "                                     Aggregate one session: turn count, tool histogram, files touched, cost/duration, synopsis. --diff appends the session diff under the summary and pages the whole thing on a TTY (inherits --fold).",
       "  hydra-acp session diff <id> [--json] [--no-color] [--no-pager] [--fold]",
@@ -30571,7 +30911,7 @@ function printHelp() {
       "  hydra-acp agent [list]                      List agents in the cached registry",
       "  hydra-acp agent refresh                     Force a registry re-fetch",
       "  hydra-acp agent install <id>                Pre-install <id> from the registry (else lazy on first session)",
-      "  hydra-acp agent set <id>                    Set <id> as the default agent (config.defaultAgent)",
+      "  hydra-acp agent set [<id>] [model]          With no args, report the daemon's current default agent and its default model. With <id>, set <id> as the default agent (config.defaultAgent). With <id> and [model], set the per-agent default model (config.defaultModels[<id>]).",
       "  hydra-acp agent sync <id>                   Spawn <id> just long enough to ACP session/list it, then persist any sessions it remembers (across every cwd) as cold rows in `session list`",
       "  hydra-acp agent log <id> [-f] [-n N]         Tail or follow an agent's spawn/stderr log",
       "  hydra-acp auth password [--force]           Set the daemon's master password",