@hydra-acp/cli 0.1.56 → 0.1.58

package/dist/index.js

@@ -104,7 +104,11 @@ var paths = {
   // 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")
 };
 
 // src/core/service-token.ts
@@ -1441,6 +1445,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;
   }
@@ -1561,10 +1571,14 @@ var SessionListEntry = z3.object({
   // 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"),
@@ -1622,7 +1636,10 @@ function sessionListEntryToWire(entry) {
 }
 var 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()
 });
 var SessionCancelParams = z3.object({
   sessionId: z3.string()
@@ -2672,12 +2689,6 @@ var HYDRA_COMMANDS = [
   }
 ];
 var VERB_INDEX = new Map(HYDRA_COMMANDS.map((c) => [c.verb, c]));
-function hydraCommandsAsAdvertised() {
-  return HYDRA_COMMANDS.map((c) => ({
-    name: c.argsHint ? `${c.name} ${c.argsHint}` : c.name,
-    description: c.description
-  }));
-}
 
 // src/core/coalesce-replay.ts
 function coalesceReplay(entries) {
@@ -2888,6 +2899,12 @@ var Session = class {
   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
@@ -3016,6 +3033,7 @@ var Session = class {
   agentModelsHandlers = [];
   modelHandlers = [];
   modeHandlers = [];
+  interactiveHandlers = [];
   usageHandlers = [];
   cumulativeCost = 0;
   // Total cost across all agent lives. costAmount in the returned snapshot
@@ -3099,6 +3117,7 @@ var Session = class {
     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));
@@ -3361,19 +3380,25 @@ var Session = class {
     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
@@ -3554,6 +3579,18 @@ var Session = class {
     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
@@ -4336,13 +4373,7 @@ var Session = class {
           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;
@@ -4538,24 +4569,38 @@ var Session = class {
   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
   // (persistence) and broadcasts a synthetic current_model_update so all
   // attached clients — including the originator — repaint immediately.
+  //
+  // The broadcast fires even when `modelId` already equals currentModel.
+  // claude-acp emits a stale current_model_update (with the pre-change
+  // value) during set_model processing and a separate config_option_update
+  // with the new value; the configOption path updates currentModel here
+  // before our synthetic broadcast would run, so a value-equality guard
+  // would suppress the corrective broadcast and leave attached clients
+  // (notably the TUI, which doesn't render config_option_update) showing
+  // the stale model from the agent's earlier notification.
   applyModelChange(modelId) {
     const trimmed = modelId.trim();
-    if (!trimmed || trimmed === this.currentModel) {
+    if (!trimmed) {
       return;
     }
-    this.logger?.info(
-      `applyModelChange: sessionId=${this.sessionId} ${JSON.stringify(this.currentModel)} \u2192 ${JSON.stringify(trimmed)}`
-    );
-    this.currentModel = trimmed;
-    for (const handler of this.modelHandlers) {
-      try {
-        handler(trimmed);
-      } catch {
+    if (trimmed !== this.currentModel) {
+      this.logger?.info(
+        `applyModelChange: sessionId=${this.sessionId} ${JSON.stringify(this.currentModel)} \u2192 ${JSON.stringify(trimmed)}`
+      );
+      this.currentModel = trimmed;
+      for (const handler of this.modelHandlers) {
+        try {
+          handler(trimmed);
+        } catch {
+        }
       }
     }
     const update = {
@@ -4572,23 +4617,39 @@ var Session = class {
   }
   // Apply a mode change initiated by a client request (session/set_mode)
   // when the agent doesn't emit a current_mode_update notification on its
-  // own. Fires modeHandlers so the persistence hook and any other listeners
-  // see the change, identical to the agent-notification path.
+  // own. Fires modeHandlers (persistence) and broadcasts a synthetic
+  // current_mode_update so all attached clients — including the originator
+  // — repaint immediately, mirroring applyModelChange. Without the
+  // broadcast, peer clients (e.g. the TUI when set_mode was issued by Zed
+  // through the shim) would stay on the prior mode.
   applyModeChange(modeId) {
     const trimmed = modeId.trim();
-    if (!trimmed || trimmed === this.currentMode) {
+    if (!trimmed) {
       return;
     }
-    this.logger?.info(
-      `applyModeChange: sessionId=${this.sessionId} ${JSON.stringify(this.currentMode)} \u2192 ${JSON.stringify(trimmed)}`
-    );
-    this.currentMode = trimmed;
-    for (const handler of this.modeHandlers) {
-      try {
-        handler(trimmed);
-      } catch {
+    if (trimmed !== this.currentMode) {
+      this.logger?.info(
+        `applyModeChange: sessionId=${this.sessionId} ${JSON.stringify(this.currentMode)} \u2192 ${JSON.stringify(trimmed)}`
+      );
+      this.currentMode = trimmed;
+      for (const handler of this.modeHandlers) {
+        try {
+          handler(trimmed);
+        } catch {
+        }
       }
     }
+    const update = {
+      sessionUpdate: "current_mode_update",
+      currentModeId: trimmed
+    };
+    if (this.agentAdvertisedModes.length > 0) {
+      update.availableModes = [...this.agentAdvertisedModes];
+    }
+    this.recordAndBroadcast("session/update", {
+      sessionId: this.upstreamSessionId,
+      update
+    });
   }
   onUsageChange(handler) {
     this.usageHandlers.push(handler);
@@ -4600,8 +4661,8 @@ var Session = class {
   // entries, then whatever the agent advertised.
   mergedAvailableCommands() {
     const out = [
-      ...hydraCommandsAsAdvertised(),
-      { name: "model <model-id>", description: "Switch model; omit arg to list available models" },
+      { name: "hydra", description: "Hydra session command (kill, restart, title, agent <agent>)" },
+      { name: "model", description: "Switch model; omit arg to list available models" },
       { name: "sessions", description: "List all sessions" },
       { name: "help", description: "Show available commands" }
     ];
@@ -6216,10 +6277,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()
 });
@@ -6338,6 +6406,7 @@ function recordFromMemorySession(args) {
     forkedFromSessionId: args.forkedFromSessionId,
     forkedFromMessageId: args.forkedFromMessageId,
     originatingClient: args.originatingClient,
+    interactive: args.interactive,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
   };
@@ -7193,6 +7262,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()
 });
@@ -7236,6 +7313,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
     },
@@ -7271,6 +7350,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,
@@ -7304,6 +7384,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.
@@ -7363,6 +7444,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)
     });
@@ -7409,6 +7491,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
@@ -7536,6 +7621,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,
@@ -7552,7 +7638,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,
@@ -7607,6 +7693,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,
@@ -7616,15 +7703,50 @@ var SessionManager = class {
     void session.seedFromImport().catch(() => void 0);
     return session;
   }
-  async resolveImportCwd(cwd) {
+  async dirExists(cwd) {
     try {
-      const stat2 = await fs13.stat(cwd);
-      if (stat2.isDirectory()) {
-        return cwd;
-      }
+      return (await fs13.stat(cwd)).isDirectory();
     } catch {
+      return false;
+    }
+  }
+  // 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;
     }
-    return os2.homedir();
+    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.
@@ -7713,6 +7835,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
       };
@@ -7879,6 +8005,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)
@@ -7972,6 +8103,7 @@ var SessionManager = class {
       createdAt: record.createdAt,
       pendingHistorySync: record.pendingHistorySync,
       originatingClient: record.originatingClient,
+      interactive: record.interactive,
       forkedFromSessionId: record.forkedFromSessionId,
       forkedFromMessageId: record.forkedFromMessageId
     };
@@ -8059,12 +8191,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,
@@ -8077,6 +8224,7 @@ var SessionManager = class {
         forkedFromSessionId: session.forkedFromSessionId,
         forkedFromMessageId: session.forkedFromMessageId,
         originatingClient: session.originatingClient,
+        interactive,
         updatedAt: used,
         attachedClients: session.attachedCount,
         status: "live",
@@ -8091,7 +8239,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,
@@ -8109,6 +8262,7 @@ var SessionManager = class {
         forkedFromSessionId: r.forkedFromSessionId,
         forkedFromMessageId: r.forkedFromMessageId,
         originatingClient: r.originatingClient,
+        interactive,
         updatedAt: used,
         attachedClients: 0,
         status: "cold",
@@ -8343,8 +8497,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
       });
@@ -8453,6 +8617,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()
       });
     });
@@ -8629,6 +8795,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()
   });
 }
@@ -8935,13 +9102,25 @@ async function loadPromptHistorySafely(sessionId) {
     return [];
   }
 }
-async function historyMtimeIso(sessionId) {
+async function historyStatus(sessionId) {
   try {
     const st = await fs13.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
@@ -11168,17 +11347,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;
   });
@@ -11772,13 +11955,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
@@ -12343,7 +12521,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) {
@@ -12470,8 +12649,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);
@@ -12528,6 +12708,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) => {
@@ -13775,7 +13958,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
@@ -13796,7 +13980,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,