@hydra-acp/cli 0.1.40 → 0.1.42

package/dist/cli.js

@@ -91,6 +91,11 @@ var init_paths = __esm({
       extensionLogFile: (name) => path.join(hydraHome(), "extensions", `${name}.log`),
       extensionPidFile: (name) => path.join(hydraHome(), "extensions", `${name}.pid`),
       tuiHistoryFile: (id) => path.join(hydraHome(), "sessions", id, "prompt-history"),
+      // Cross-session prompt history. Up-arrow / ^R fall through to this
+      // after the per-session list is exhausted. JSONL, one entry per
+      // 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")
     };
   }
@@ -980,7 +985,8 @@ function mergeMeta(passthrough, ours) {
 function sessionListEntryToWire(entry) {
   const hydraMeta = {
     attachedClients: entry.attachedClients,
-    status: entry.status
+    status: entry.status,
+    busy: entry.busy
   };
   if (entry.agentId !== void 0) {
     hydraMeta.agentId = entry.agentId;
@@ -1126,6 +1132,10 @@ var init_types = __esm({
       updatedAt: z3.string(),
       attachedClients: z3.number().int().nonnegative(),
       status: z3.enum(["live", "cold"]).default("live"),
+      // True while the session is mid-turn (an agent prompt is in flight).
+      // Always false for cold sessions. Lets pickers render a busy dot
+      // without having to attach.
+      busy: z3.boolean().default(false),
       _meta: z3.record(z3.unknown()).optional()
     });
     SessionListEntryWire = z3.object({
@@ -3832,7 +3842,7 @@ function parseHistory(text) {
   }
   return out;
 }
-function appendEntry(history, entry) {
+function appendEntry(history, entry, cap = HISTORY_CAP) {
   const trimmed = entry.replace(/\n+$/, "");
   if (trimmed.length === 0) {
     return history;
@@ -3841,8 +3851,8 @@ function appendEntry(history, entry) {
     return history;
   }
   const out = history.concat(trimmed);
-  if (out.length > HISTORY_CAP) {
-    return out.slice(out.length - HISTORY_CAP);
+  if (out.length > cap) {
+    return out.slice(out.length - cap);
   }
   return out;
 }
@@ -3851,11 +3861,30 @@ async function saveHistory(file, history) {
   const lines = history.map((entry) => JSON.stringify(entry));
   await fs10.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
 }
-var HISTORY_CAP;
+async function appendHistoryLine(file, entry) {
+  const trimmed = entry.replace(/\n+$/, "");
+  if (trimmed.length === 0) {
+    return;
+  }
+  await fs10.mkdir(path6.dirname(file), { recursive: true });
+  await fs10.appendFile(file, JSON.stringify(trimmed) + "\n", {
+    encoding: "utf8"
+  });
+}
+function buildCombinedHistory(global, session) {
+  if (session.length === 0) {
+    return [...global];
+  }
+  const sessionSet = new Set(session);
+  const filteredGlobal = global.filter((e) => !sessionSet.has(e));
+  return [...filteredGlobal, ...session];
+}
+var HISTORY_CAP, GLOBAL_HISTORY_CAP;
 var init_history = __esm({
   "src/tui/history.ts"() {
     "use strict";
     HISTORY_CAP = 500;
+    GLOBAL_HISTORY_CAP = 2e3;
   }
 });
 
@@ -4425,7 +4454,8 @@ async function listSessions(target, opts = {}, fetchImpl = fetch) {
     currentUsage: s.currentUsage,
     title: s.title,
     importedFromMachine: s.importedFromMachine,
-    importedFromUpstreamSessionId: s.importedFromUpstreamSessionId
+    importedFromUpstreamSessionId: s.importedFromUpstreamSessionId,
+    busy: s.busy
   }));
 }
 async function killSession(target, id, fetchImpl = fetch) {
@@ -4549,7 +4579,7 @@ function toRow(s, now = Date.now()) {
   return {
     session: stripHydraSessionPrefix(s.sessionId),
     upstream: formatUpstreamCell(s.upstreamSessionId, s.importedFromMachine),
-    state: formatState(s.status, s.attachedClients),
+    state: formatState(s.status, s.busy),
     agent: formatAgentCell(s.agentId, s.currentUsage),
     age: formatRelativeAge(s.updatedAt, now),
     title: s.title ?? "-",
@@ -4565,11 +4595,11 @@ function formatUpstreamCell(upstreamSessionId, importedFromMachine) {
   }
   return "-";
 }
-function formatState(status, clients) {
+function formatState(status, busy) {
   if (status === "cold") {
     return "COLD";
   }
-  return `LIVE(${clients})`;
+  return busy ? "LIVE\u2022" : "LIVE";
 }
 function computeWidths(rows) {
   return {
@@ -7005,6 +7035,10 @@ uncaught: ${err.stack ?? err.message}
           this.handleCsi27Stdin(text);
           return;
         }
+        if (text.includes("\x1B[200~")) {
+          this.handleRawStdinSegment(text);
+          return;
+        }
         if (text.includes("\n")) {
           const parts = text.split("\n");
           for (let i = 0; i < parts.length; i++) {
@@ -7353,24 +7387,22 @@ uncaught: ${err.stack ?? err.message}
         this.writeProgressIndicator(this.banner.status === "busy" ? 3 : 0);
         this.syncedPartialRepaint(() => this.drawBanner());
       }
-      // Wrap a partial repaint (banner-only, indicator-only, etc.) in a
+      // Wrap a partial repaint (banner-only, prompt-only, etc.) in a
       // synchronized-output bracket so the row swap is atomic on terminals
-      // that support DEC 2026, and hide the cursor across the paint so it
-      // doesn't visibly jump to the row being repainted before placeCursor
-      // snaps it back. placeCursor re-asserts visibility for normal /
-      // scrollback-search / readonly; modal modes only moveTo, so we
-      // re-show explicitly when one of them is active.
+      // that support DEC 2026. Cursor movement (moveTo) is buffered inside
+      // BSU/ESU, so the cursor appears at its final placeCursor position
+      // without visibly visiting intermediate rows. We intentionally do NOT
+      // hide the cursor here: ?25l/h (cursor visibility) is terminal *state*
+      // applied immediately rather than buffered, so hiding inside a BSU/ESU
+      // block causes a visible blink (cursor disappears → frame commits →
+      // cursor reappears) on every banner tick — worse than any skitter.
       syncedPartialRepaint(paint) {
         if (!this.started) {
           return;
         }
         withSync(() => {
-          this.term.hideCursor();
           paint();
           this.placeCursor();
-          if (this.permissionPrompt || this.confirmPrompt || this.helpPrompt) {
-            this.term.hideCursor(false);
-          }
         });
       }
       currentModeId() {
@@ -8462,7 +8494,7 @@ uncaught: ${err.stack ?? err.message}
           const body = ` ${marker} ${i + 1}. ${truncate(opt.label, w - 8)}`;
           writeRow(`perm|o|${w}|${i}|${isSel ? "1" : "0"}|${opt.label}`, () => {
             if (isSel) {
-              this.term.brightCyan(body);
+              this.term.brightYellow(body);
             } else {
               this.term.dim(body);
             }
@@ -8771,7 +8803,7 @@ async function pickSession(term, opts) {
       if (tier !== 0) {
         return tier;
       }
-      return b.updatedAt.localeCompare(a.updatedAt);
+      return b.updatedAt.slice(0, 16).localeCompare(a.updatedAt.slice(0, 16));
     });
   };
   let cwdOnly = false;
@@ -9178,6 +9210,8 @@ async function pickSession(term, opts) {
   renderFromScratch();
   return await new Promise((resolve6) => {
     let resolved = false;
+    let autoRefreshTimer = null;
+    let autoRefreshInFlight = false;
     const onResize = () => {
       if (resolved) {
         return;
@@ -9189,6 +9223,10 @@ async function pickSession(term, opts) {
         return;
       }
       resolved = true;
+      if (autoRefreshTimer) {
+        clearInterval(autoRefreshTimer);
+        autoRefreshTimer = null;
+      }
       term.off("key", onKey);
       term.off("resize", onResize);
       process.stdout.write("\x1B[?2004l");
@@ -9205,8 +9243,16 @@ async function pickSession(term, opts) {
       term.moveTo(1, indicatorRow() + 1);
       term("\n");
     };
-    const refresh = async (preferredId) => {
+    const renderFingerprint = () => {
+      const cells = rows.map(
+        (r) => `${r.session}|${r.upstream}|${r.state}|${r.agent}|${r.age}|${r.title}|${r.cwd}`
+      ).join("\n");
+      return `${selectedIdx}:${scrollOffset}:${transientStatus ?? ""}
+${cells}`;
+    };
+    const refresh = async (preferredId, refreshOpts = {}) => {
       try {
+        const beforeKey = refreshOpts.silent ? renderFingerprint() : "";
         const next = await listSessions(opts.target);
         allSessions = sortSessions(next);
         applyFilter();
@@ -9223,8 +9269,14 @@ async function pickSession(term, opts) {
           scrollOffset = Math.max(0, visible.length - viewportSize);
         }
         adjustScroll();
+        if (refreshOpts.silent && renderFingerprint() === beforeKey) {
+          return;
+        }
         renderFromScratch();
       } catch (err) {
+        if (refreshOpts.silent) {
+          return;
+        }
         transientStatus = `refresh failed: ${err.message}`;
         renderFromScratch();
       }
@@ -9701,6 +9753,16 @@ async function pickSession(term, opts) {
     }
     term.on("key", onKey);
     term.on("resize", onResize);
+    autoRefreshTimer = setInterval(() => {
+      if (resolved || mode !== "normal" || searchActive || autoRefreshInFlight) {
+        return;
+      }
+      const currentId = selectedIdx > 0 ? visible[selectedIdx - 1]?.sessionId : void 0;
+      autoRefreshInFlight = true;
+      void refresh(currentId, { silent: true }).finally(() => {
+        autoRefreshInFlight = false;
+      });
+    }, 3e3);
   });
 }
 function readTermHeight(term) {
@@ -11019,11 +11081,13 @@ function toolIconStyle(status) {
 }
 function formatPlan(event) {
   const stopped = event.stopped === true;
+  const amended = event.amended === true;
+  const stoppedStyle = amended ? "tool-status-cancelled" : "tool-status-fail";
   if (event.entries.length === 0) {
     return [
       {
         prefix: "\u25A3 ",
-        prefixStyle: stopped ? "tool-status-fail" : "plan",
+        prefixStyle: stopped ? stoppedStyle : "plan",
         body: "(empty plan)",
         bodyStyle: "dim"
       }
@@ -11032,7 +11096,7 @@ function formatPlan(event) {
   const allComplete = event.entries.every(
     (e) => (e.status ?? "pending") === "completed"
   );
-  const headerStyle = allComplete ? "plan-done" : stopped ? "tool-status-fail" : "plan";
+  const headerStyle = allComplete ? "plan-done" : stopped ? stoppedStyle : "plan";
   const lines = [
     {
       prefix: "\u25A3 ",
@@ -11137,9 +11201,38 @@ async function runTuiApp(opts) {
   const viewPrefs = {
     showThoughts: config.tui.showThoughts
   };
+  let altScreenEngaged = false;
+  const enterAltScreen = () => {
+    if (altScreenEngaged) {
+      return;
+    }
+    term.fullscreen(true);
+    altScreenEngaged = true;
+  };
+  const leaveAltScreen = () => {
+    if (!altScreenEngaged) {
+      return;
+    }
+    term.fullscreen(false);
+    altScreenEngaged = false;
+    process.stdout.write("\n");
+  };
+  enterAltScreen();
+  const altScreenCleanup = () => {
+    if (altScreenEngaged) {
+      term.fullscreen(false);
+      altScreenEngaged = false;
+    }
+  };
+  process.once("exit", altScreenCleanup);
   let nextOpts = opts;
-  while (nextOpts !== null) {
-    nextOpts = await runSession(term, config, target, nextOpts, exitHint, viewPrefs);
+  try {
+    while (nextOpts !== null) {
+      nextOpts = await runSession(term, config, target, nextOpts, exitHint, viewPrefs);
+    }
+  } finally {
+    leaveAltScreen();
+    process.off("exit", altScreenCleanup);
   }
   const pendingUpdate = await getPendingUpdate();
   if (pendingUpdate) {
@@ -11149,7 +11242,6 @@ async function runTuiApp(opts) {
   if (exitHint.sessionId && process.stdout.isTTY) {
     const short = stripHydraSessionPrefix(exitHint.sessionId);
     const flags = exitHint.readonly ? " --readonly" : "";
-    process.stdout.write("\x1B[2J\x1B[H");
     process.stdout.write(
       `To resume: ${invokedBinName()} tui --session ${short}${flags}
 `
@@ -11160,7 +11252,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
   const ctx = await resolveSession(term, config, target, opts);
   if (!ctx) {
     term.grabInput(false);
-    process.exit(0);
+    return null;
   }
   const launchLabelBase = ctx.sessionId === "__new__" ? "Starting new session\u2026" : "Resuming session\u2026";
   const installStatus = createInstallStatusLine(term, launchLabelBase);
@@ -11656,9 +11748,35 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
     initialQueue = hydraMeta.queue;
   }
   const historyFile = paths.tuiHistoryFile(resolvedSessionId);
+  const globalHistoryFile = paths.globalTuiHistoryFile();
   let history = await loadHistory(historyFile).catch(() => []);
-  const dispatcher = new InputDispatcher({ history });
+  let globalHistory = await loadHistory(globalHistoryFile).catch(() => []);
+  if (globalHistory.length > GLOBAL_HISTORY_CAP) {
+    globalHistory = globalHistory.slice(globalHistory.length - GLOBAL_HISTORY_CAP);
+  }
+  const dispatcher = new InputDispatcher({
+    history: buildCombinedHistory(globalHistory, history)
+  });
   dispatcherRef = dispatcher;
+  const recordHistoryEntry = (entry) => {
+    const trimmed = entry.replace(/\n+$/, "");
+    if (trimmed.length === 0) {
+      return;
+    }
+    const nextSession = appendEntry(history, trimmed);
+    const sessionChanged = nextSession !== history;
+    history = nextSession;
+    const nextGlobal = appendEntry(globalHistory, trimmed, GLOBAL_HISTORY_CAP);
+    const globalChanged = nextGlobal !== globalHistory;
+    globalHistory = nextGlobal;
+    dispatcher.setHistory(buildCombinedHistory(globalHistory, history));
+    if (sessionChanged) {
+      saveHistory(historyFile, history).catch(() => void 0);
+    }
+    if (globalChanged) {
+      appendHistoryLine(globalHistoryFile, trimmed).catch(() => void 0);
+    }
+  };
   if (pendingTurns > 0) {
     dispatcher.setTurnRunning(true);
   }
@@ -11867,7 +11985,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
   const sessionbarAgent = resolvedAgentId || agentInfoName || "?";
   const usage = { ...initialUsage ?? {} };
   installStatus.finalize();
-  screen.start();
+  screen.start({ skipFullscreen: true });
   screen.setHideThoughts(!viewPrefs.showThoughts);
   screen.setSessionbar({
     agent: sessionbarAgent,
@@ -12015,7 +12133,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
       sessionElapsedTimer = null;
     }
     screen.clearWindowTitle();
-    screen.stop();
+    screen.stop({ keepFullscreen: true });
     saveHistory(historyFile, history).catch(() => void 0);
     void stream.close().catch(() => void 0);
   };
@@ -12035,8 +12153,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
     }
     const pendingDraft = dispatcher.state().buffer.join("\n");
     if (pendingDraft.replace(/\s+$/, "").length > 0) {
-      history = appendEntry(history, pendingDraft);
-      dispatcher.setHistory(history);
+      recordHistoryEntry(pendingDraft);
     }
     screen.pauseRepaint();
     screen.stop({ keepFullscreen: true });
@@ -12415,9 +12532,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
     if (handleBuiltinCommand(text)) {
       return;
     }
-    history = appendEntry(history, text);
-    dispatcher.setHistory(history);
-    saveHistory(historyFile, history).catch(() => void 0);
+    recordHistoryEntry(text);
     void runPrompt(text, attachments);
   };
   const amendPrompt = (text, attachments) => {
@@ -12425,9 +12540,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
     if (handleBuiltinCommand(text)) {
       return;
     }
-    history = appendEntry(history, text);
-    dispatcher.setHistory(history);
-    saveHistory(historyFile, history).catch(() => void 0);
+    recordHistoryEntry(text);
     if (!daemonSupportsAmend || currentHeadMessageId === void 0) {
       void runPrompt(text, attachments);
       return;
@@ -12787,16 +12900,18 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
     const end = toolsBlockEndedAt ?? Date.now();
     const elapsed = end - toolsBlockStartedAt;
     const stoppedReason = !inProgress && toolsBlockStopReason !== null && toolsBlockStopReason !== "end_turn" ? toolsBlockStopReason : null;
+    const isAmended = stoppedReason === "amended";
+    const stoppedLabel = isAmended ? `amended \xB7 ${formatElapsed(elapsed)}` : `stopped (${stoppedReason}) \xB7 ${formatElapsed(elapsed)}`;
     let summary;
     if (total === 0) {
       if (stoppedReason !== null) {
-        summary = `stopped (${stoppedReason}) \xB7 ${formatElapsed(elapsed)}`;
+        summary = stoppedLabel;
       } else {
         summary = inProgress ? `thinking \xB7 ${formatElapsed(elapsed)}` : `thought \xB7 ${formatElapsed(elapsed)}`;
       }
     } else {
       const noun = total === 1 ? "tool" : "tools";
-      const timing = stoppedReason !== null ? `stopped (${stoppedReason}) \xB7 ${formatElapsed(elapsed)}` : inProgress ? formatElapsed(elapsed) : `took ${formatElapsed(elapsed)}`;
+      const timing = stoppedReason !== null ? stoppedLabel : inProgress ? formatElapsed(elapsed) : `took ${formatElapsed(elapsed)}`;
       const parts = [`${total} ${noun}`, timing];
       if (inProgress) {
         if (hidden > 0) {
@@ -12808,8 +12923,9 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
       summary = parts.join(" \xB7 ");
     }
     const pureThinking = total === 0 && inProgress;
-    const frozenStyle = stoppedReason !== null ? "tool-status-fail" : "tool";
-    const frozenBodyStyle = stoppedReason !== null ? "tool-status-fail" : "dim";
+    const stoppedHeaderStyle = isAmended ? "tool-status-cancelled" : "tool-status-fail";
+    const frozenStyle = stoppedReason !== null ? stoppedHeaderStyle : "tool";
+    const frozenBodyStyle = stoppedReason !== null ? stoppedHeaderStyle : "dim";
     const lines = [
       {
         prefix: "\u2699 ",
@@ -12985,7 +13101,11 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
         effectiveStopReason = "error";
       }
       if (lastPlanEvent !== null && effectiveStopReason !== void 0 && effectiveStopReason !== "end_turn") {
-        const lines = formatEvent({ ...lastPlanEvent, stopped: true });
+        const lines = formatEvent({
+          ...lastPlanEvent,
+          stopped: true,
+          amended: event.amended === true
+        });
         if (lines.length > 0) {
           screen.upsertLines("plan", lines);
         }
@@ -12997,7 +13117,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
         toolsBlockStopReason = effectiveStopReason ?? null;
         renderToolsBlock();
         screen.clearKey("tools");
-      } else if (effectiveStopReason !== void 0 && effectiveStopReason !== "end_turn") {
+      } else if (effectiveStopReason !== void 0 && effectiveStopReason !== "end_turn" && effectiveStopReason !== "amended") {
         screen.appendLines([
           {
             prefix: "\u26A0 ",
@@ -14693,6 +14813,12 @@ var SessionRecord = z4.object({
   agentCommands: z4.array(PersistedAgentCommand).optional(),
   agentModes: z4.array(PersistedAgentMode).optional(),
   agentModels: z4.array(PersistedAgentModel).optional(),
+  // One-shot flag set when `hydra agent sync` mints a row from an
+  // agent-side session/list entry: signals that the first resurrect
+  // should *keep* the agent's session/load replay (instead of draining
+  // it) so the local history.jsonl gets populated from the agent's
+  // memory. Cleared after that first resurrect completes.
+  pendingHistorySync: z4.boolean().optional(),
   createdAt: z4.string(),
   updatedAt: z4.string()
 });
@@ -14813,6 +14939,7 @@ function recordFromMemorySession(args) {
     agentCommands: args.agentCommands,
     agentModes: args.agentModes,
     agentModels: args.agentModels,
+    pendingHistorySync: args.pendingHistorySync,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
   };
@@ -15118,7 +15245,13 @@ var SessionManager = class {
       await agent.kill().catch(() => void 0);
       return this.doResurrectFromImport(params);
     }
-    agent.connection.drainBuffered("session/update");
+    if (params.pendingHistorySync === true) {
+      void this.clearPendingHistorySync(params.hydraSessionId).catch(
+        () => void 0
+      );
+    } else {
+      agent.connection.drainBuffered("session/update");
+    }
     const session = new Session({
       sessionId: params.hydraSessionId,
       cwd: params.cwd,
@@ -15208,6 +15341,133 @@ var SessionManager = class {
     }
     return os3.homedir();
   }
+  // Pull every session the agent itself remembers (across all cwds) and
+  // persist a cold hydra record for each one we don't already track.
+  // Used by `hydra agent sync <id>` to surface sessions created outside
+  // hydra — or by other tools — in `hydra session list` so the picker
+  // can resurrect them. Spawns a throwaway agent process for the
+  // initialize + session/list pair, then kills it. Records are minted
+  // with pendingHistorySync:true so the first resurrect records the
+  // agent's session/load replay into history.jsonl rather than dropping
+  // it.
+  async syncFromAgent(agentId) {
+    const agentDef = await this.registry.getAgent(agentId);
+    if (!agentDef) {
+      const err = new Error(
+        `agent ${agentId} not found in registry`
+      );
+      err.code = JsonRpcErrorCodes.AgentNotInstalled;
+      throw err;
+    }
+    const plan = await planSpawn(agentDef, [], {
+      npmRegistry: this.npmRegistry
+    });
+    const agent = this.spawner({
+      agentId,
+      cwd: os3.homedir(),
+      plan
+    });
+    let initResult;
+    try {
+      initResult = await agent.connection.request(
+        "initialize",
+        {
+          protocolVersion: ACP_PROTOCOL_VERSION,
+          clientCapabilities: {},
+          clientInfo: { name: "hydra", version: HYDRA_VERSION }
+        }
+      );
+    } catch (err) {
+      await agent.kill().catch(() => void 0);
+      throw err;
+    }
+    const caps = initResult.agentCapabilities ?? {};
+    if (caps.sessionCapabilities?.list === void 0) {
+      await agent.kill().catch(() => void 0);
+      throw new Error(
+        `agent ${agentId} does not advertise sessionCapabilities.list; cannot sync`
+      );
+    }
+    let entries;
+    try {
+      entries = await this.collectAgentSessions(agent);
+    } catch (err) {
+      await agent.kill().catch(() => void 0);
+      throw err;
+    }
+    await agent.kill().catch(() => void 0);
+    const existing = /* @__PURE__ */ new Set();
+    for (const live of this.sessions.values()) {
+      existing.add(`${live.agentId}::${live.upstreamSessionId}`);
+    }
+    const stored = await this.store.list().catch(() => []);
+    for (const rec of stored) {
+      existing.add(`${rec.agentId}::${rec.upstreamSessionId}`);
+    }
+    const synced = [];
+    let skipped = 0;
+    for (const entry of entries) {
+      const dedupeKey = `${agentId}::${entry.sessionId}`;
+      if (existing.has(dedupeKey)) {
+        skipped += 1;
+        continue;
+      }
+      existing.add(dedupeKey);
+      const newId = `${HYDRA_SESSION_PREFIX}${generateRawSessionId()}`;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const ts = entry.updatedAt ?? now;
+      const recordArgs = {
+        sessionId: newId,
+        lineageId: generateLineageId(),
+        upstreamSessionId: entry.sessionId,
+        agentId,
+        cwd: entry.cwd,
+        pendingHistorySync: true,
+        createdAt: ts,
+        updatedAt: ts
+      };
+      if (entry.title !== void 0) {
+        recordArgs.title = entry.title;
+      }
+      const record = recordFromMemorySession(recordArgs);
+      await this.store.write(record);
+      synced.push({ version: 1, ...record });
+    }
+    return { synced, skipped };
+  }
+  // Paginate the agent's session/list, threading nextCursor until the
+  // agent stops returning one. Each entry the spec guarantees has
+  // { sessionId, cwd }; title and updatedAt are optional.
+  async collectAgentSessions(agent) {
+    const out = [];
+    let cursor;
+    for (let page = 0; page < 100; page += 1) {
+      const params = {};
+      if (cursor !== void 0) {
+        params.cursor = cursor;
+      }
+      const result = await agent.connection.request("session/list", params);
+      const rows = Array.isArray(result.sessions) ? result.sessions : [];
+      for (const row of rows) {
+        if (typeof row.sessionId !== "string" || typeof row.cwd !== "string") {
+          continue;
+        }
+        const entry = { sessionId: row.sessionId, cwd: row.cwd };
+        if (typeof row.title === "string") {
+          entry.title = row.title;
+        }
+        if (typeof row.updatedAt === "string") {
+          entry.updatedAt = row.updatedAt;
+        }
+        out.push(entry);
+      }
+      if (typeof result.nextCursor !== "string" || result.nextCursor.length === 0) {
+        break;
+      }
+      cursor = result.nextCursor;
+    }
+    return out;
+  }
   // Bootstrap a fresh agent process: registry resolve → spawn → initialize
   // → session/new. Shared by create() and the /hydra agent path so both
   // go through the same env / capabilities / error-handling.
@@ -15400,9 +15660,21 @@ var SessionManager = class {
       agentCommands: record.agentCommands,
       agentModes: record.agentModes,
       agentModels: record.agentModels,
-      createdAt: record.createdAt
+      createdAt: record.createdAt,
+      pendingHistorySync: record.pendingHistorySync
     };
   }
+  async clearPendingHistorySync(sessionId) {
+    await this.enqueueMetaWrite(sessionId, async () => {
+      const record = await this.store.read(sessionId);
+      if (!record || record.pendingHistorySync !== true) {
+        return;
+      }
+      const next = { ...record };
+      delete next.pendingHistorySync;
+      await this.store.write(next);
+    });
+  }
   // Best-effort: peek at the persisted history's first prompt and use
   // its first line (capped to 200 chars) as a session title. Returns
   // undefined if no usable prompt is found or any I/O fails.
@@ -15488,7 +15760,8 @@ var SessionManager = class {
         currentUsage: session.currentUsage,
         updatedAt: used,
         attachedClients: session.attachedCount,
-        status: "live"
+        status: "live",
+        busy: session.turnStartedAt !== void 0
       });
     }
     const records = await this.store.list().catch(() => []);
@@ -15512,7 +15785,8 @@ var SessionManager = class {
         importedFromUpstreamSessionId: r.importedFromUpstreamSessionId,
         updatedAt: used,
         attachedClients: 0,
-        status: "cold"
+        status: "cold",
+        busy: false
       });
     }
     entries.sort((a, b) => a.updatedAt < b.updatedAt ? 1 : -1);
@@ -17451,7 +17725,8 @@ function registerSessionRoutes(app, manager, defaults) {
 }
 
 // src/daemon/routes/agents.ts
-function registerAgentRoutes(app, registry) {
+init_types();
+function registerAgentRoutes(app, registry, manager, opts = {}) {
   app.get("/v1/agents", async () => {
     const doc = await registry.load();
     return {
@@ -17472,6 +17747,61 @@ function registerAgentRoutes(app, registry) {
     const doc = await registry.refresh();
     return { version: doc.version, agentCount: doc.agents.length };
   });
+  app.post("/v1/agents/:id/install", async (request, reply) => {
+    const id = request.params.id;
+    const agent = await registry.getAgent(id);
+    if (!agent) {
+      reply.code(404).send({ error: `agent ${id} not found in registry` });
+      return;
+    }
+    if (agent.distribution.uvx && !agent.distribution.npx && !agent.distribution.binary) {
+      reply.send({
+        agentId: agent.id,
+        version: agent.version ?? "current",
+        distribution: "uvx",
+        installed: false,
+        message: "uvx agents resolve on first run; nothing to pre-install."
+      });
+      return;
+    }
+    try {
+      const plan = await planSpawn(agent, [], { npmRegistry: opts.npmRegistry });
+      const distribution = agent.distribution.npx ? "npx" : agent.distribution.binary ? "binary" : "unknown";
+      reply.send({
+        agentId: agent.id,
+        version: plan.version,
+        distribution,
+        installed: true,
+        command: plan.command
+      });
+    } catch (err) {
+      reply.code(500).send({ error: err.message });
+    }
+  });
+  app.post("/v1/agents/:id/sync", async (request, reply) => {
+    const agentId = request.params.id;
+    try {
+      const { synced, skipped } = await manager.syncFromAgent(agentId);
+      return {
+        synced: synced.map((r) => ({
+          sessionId: r.sessionId,
+          upstreamSessionId: r.upstreamSessionId,
+          agentId: r.agentId,
+          cwd: r.cwd,
+          title: r.title,
+          updatedAt: r.updatedAt
+        })),
+        skipped
+      };
+    } catch (err) {
+      const e = err;
+      if (e.code === JsonRpcErrorCodes.AgentNotInstalled) {
+        reply.code(404).send({ error: e.message });
+        return;
+      }
+      reply.code(409).send({ error: e.message });
+    }
+  });
 }
 
 // src/daemon/routes/health.ts
@@ -18542,7 +18872,7 @@ async function startDaemon(config, serviceToken) {
     agentId: config.defaultAgent,
     cwd: config.defaultCwd
   });
-  registerAgentRoutes(app, registry);
+  registerAgentRoutes(app, registry, manager, { npmRegistry: config.npmRegistry });
   registerExtensionRoutes(app, extensions);
   registerConfigRoutes(app, {
     defaultAgent: config.defaultAgent,
@@ -19886,6 +20216,136 @@ async function runAgentsList() {
 Registry version: ${body.version}
 `);
 }
+async function runAgentsInstall(agentId) {
+  if (!agentId) {
+    process.stderr.write("Usage: hydra-acp agent install <agent-id>\n");
+    process.exit(2);
+    return;
+  }
+  const config = await loadConfig();
+  const serviceToken = await loadServiceToken();
+  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  process.stdout.write(`Installing ${agentId}\u2026
+`);
+  let body;
+  try {
+    const r = await fetch(
+      `${baseUrl}/v1/agents/${encodeURIComponent(agentId)}/install`,
+      {
+        method: "POST",
+        headers: { Authorization: `Bearer ${serviceToken}` }
+      }
+    );
+    if (!r.ok) {
+      let detail = `HTTP ${r.status}`;
+      try {
+        const j = await r.json();
+        if (j.error) {
+          detail = j.error;
+        }
+      } catch {
+      }
+      process.stderr.write(`hydra agent install ${agentId}: ${detail}
+`);
+      process.exit(1);
+    }
+    body = await r.json();
+  } catch (err) {
+    process.stderr.write(
+      `Could not reach daemon at ${baseUrl}: ${err.message}
+`
+    );
+    process.exit(1);
+    return;
+  }
+  if (!body.installed) {
+    process.stdout.write(
+      `${body.agentId} (${body.version}, ${body.distribution}): ${body.message ?? "nothing to install"}
+`
+    );
+    return;
+  }
+  process.stdout.write(
+    `Installed ${body.agentId} (${body.version}, ${body.distribution})
+`
+  );
+  if (body.command) {
+    process.stdout.write(`  \u2192 ${body.command}
+`);
+  }
+}
+async function runAgentsSync(agentId) {
+  if (!agentId) {
+    process.stderr.write("Usage: hydra-acp agent sync <agent-id>\n");
+    process.exit(2);
+    return;
+  }
+  const config = await loadConfig();
+  const serviceToken = await loadServiceToken();
+  const baseUrl = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  let body;
+  try {
+    const r = await fetch(`${baseUrl}/v1/agents/${encodeURIComponent(agentId)}/sync`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${serviceToken}` }
+    });
+    if (!r.ok) {
+      let detail = `HTTP ${r.status}`;
+      try {
+        const j = await r.json();
+        if (j.error) {
+          detail = j.error;
+        }
+      } catch {
+      }
+      process.stderr.write(`hydra agent sync ${agentId}: ${detail}
+`);
+      process.exit(1);
+    }
+    body = await r.json();
+  } catch (err) {
+    process.stderr.write(
+      `Could not reach daemon at ${baseUrl}: ${err.message}
+`
+    );
+    process.exit(1);
+    return;
+  }
+  if (body.synced.length === 0) {
+    process.stdout.write(
+      `Nothing new to sync (${body.skipped} already tracked).
+`
+    );
+    return;
+  }
+  const rows = body.synced.map((s) => ({
+    id: s.sessionId,
+    upstream: s.upstreamSessionId,
+    cwd: s.cwd,
+    title: s.title ?? "-"
+  }));
+  const header = { id: "ID", upstream: "UPSTREAM", cwd: "CWD", title: "TITLE" };
+  const widths = {
+    id: maxLen3(header.id, rows.map((r) => r.id)),
+    upstream: maxLen3(header.upstream, rows.map((r) => r.upstream)),
+    cwd: maxLen3(header.cwd, rows.map((r) => r.cwd))
+  };
+  const fmt = (r) => [
+    r.id.padEnd(widths.id),
+    r.upstream.padEnd(widths.upstream),
+    r.cwd.padEnd(widths.cwd),
+    r.title
+  ].join("  ");
+  process.stdout.write(fmt(header) + "\n");
+  for (const r of rows) {
+    process.stdout.write(fmt(r) + "\n");
+  }
+  process.stdout.write(
+    `
+Synced ${body.synced.length} session(s); skipped ${body.skipped} already tracked.
+`
+  );
+}
 async function runAgentsRefresh() {
   const config = await loadConfig();
   const serviceToken = await loadServiceToken();
@@ -20942,7 +21402,11 @@ async function main() {
       const daemonIdx = argv.indexOf("daemon");
       const tail = argv.slice(daemonIdx + 1);
       const sub = tail[0];
-      if (sub === "start" || sub === void 0) {
+      if (sub === void 0 || sub === "status") {
+        await runDaemonStatus();
+        return;
+      }
+      if (sub === "start") {
         await runDaemonStart(flags);
         return;
       }
@@ -20954,10 +21418,6 @@ async function main() {
         await runDaemonRestart();
         return;
       }
-      if (sub === "status") {
-        await runDaemonStatus();
-        return;
-      }
       if (sub === "logs") {
         await runDaemonLogs(tail.slice(1));
         return;
@@ -21070,6 +21530,14 @@ async function main() {
         await runAgentsRefresh();
         return;
       }
+      if (sub === "install") {
+        await runAgentsInstall(positional[2]);
+        return;
+      }
+      if (sub === "sync") {
+        await runAgentsSync(positional[2]);
+        return;
+      }
       process.stderr.write(`Unknown agent subcommand: ${sub}
 `);
       process.exit(2);
@@ -21226,8 +21694,9 @@ function printHelp() {
       "  --readonly                         Open a session as a transcript viewer (requires --session).",
       "  HYDRA_ACP_SESSION                  Env var equivalent of --session (flag wins).",
       "  hydra-acp init [--rotate-token]    Initialize ~/.hydra-acp/config.json",
+      "  hydra-acp daemon [status]          Show daemon pid/version (default when no subcommand)",
       "  hydra-acp daemon start [--foreground]   Start daemon (detached by default; --foreground to attach)",
-      "  hydra-acp daemon stop|restart|status",
+      "  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>]",
       "                                     List sessions (live + 20 most-recent cold; --all for everything; --json emits JSON for scripts).",
@@ -21249,6 +21718,8 @@ function printHelp() {
       "  hydra-acp extension logs <name> [-f] [-n N]      Tail or follow an extension's log",
       "  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 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 auth password [--force]           Set the daemon's master password",
       "  hydra-acp auth [list]                       List active session tokens",
       "  hydra-acp auth revoke <id>                  Revoke a session token",