@hydra-acp/cli 0.1.40 → 0.1.41

package/README.md

@@ -187,7 +187,7 @@ hydra-acp session
 
 # 6. Attach a second client to an existing session.
 #    Bare invocation auto-detects: TUI in a terminal, ACP shim when piped.
-hydra-acp --session-id hydra_session_abc123
+hydra-acp --session hydra_session_abc123
 ```
 
 ## CLI
@@ -198,34 +198,55 @@ hydra-acp shim                              # explicit shim mode (forces shim re
 hydra-acp tui                               # explicit terminal-UI mode
 hydra-acp launch <agent>                    # launcher mode: shim that forces the
                                             # daemon to spawn <agent> on session/new
-hydra-acp --session-id <id>                 # attach to existing session
+hydra-acp cat [-p <prompt>] [--detach]      # pipe-friendly headless mode: feeds stdin
+                                            # to a session as prompts and streams the
+                                            # agent's reply to stdout
+hydra-acp --session <id-or-url>             # attach to existing session
                                             # (TUI in a TTY, shim otherwise)
+hydra-acp --reattach                        # pick the most-recent session for cwd
+hydra-acp --new                             # force a fresh session
+hydra-acp --readonly                        # open a session as a transcript viewer (with --session)
 
 hydra-acp init                              # generate the service token
+
+hydra-acp daemon [status]                   # output status of daemon
 hydra-acp daemon start [--foreground]       # detached by default; --foreground to attach
-hydra-acp daemon stop
-hydra-acp daemon status
+hydra-acp daemon stop                       # stop running daemon
+hydra-acp daemon restart                    # stop then start the daemon
+hydra-acp daemon logs [-f] [-n N]           # tail (default 50) or follow the daemon log
 
-hydra-acp session                          # list sessions
-hydra-acp session kill <id>                # close a live session (keeps the on-disk record so it can be resurrected)
-hydra-acp session remove <id>              # remove a session entirely (live or cold)
+hydra-acp session [list ]                   # list sessions
+hydra-acp session kill <id>                 # close a live session (keeps the on-disk record so it can be resurrected)
+hydra-acp session remove <id>               # remove a session entirely (live or cold)
 hydra-acp session export <id> [--out <file>|.]
                                             # write a session bundle (meta + history) to <file>,
                                             # to a default-named file when --out=., or to stdout
-hydra-acp session import <file>|- [--replace]
+hydra-acp session transcript <id>|<file> [--out <file>|.]
+                                            # render a session (id via daemon, or a local .hydra
+                                            # bundle) as a markdown transcript
+hydra-acp session import <file>|- [--replace] [--cwd <path>] [--info]
                                             # import a bundle from <file> or stdin (-);
-                                            # --replace overwrites an existing lineage match
+                                            # --replace overwrites a lineage match (kills it
+                                            # if live); --cwd overrides the bundle's recorded
+                                            # working directory; --info prints the bundle's
+                                            # meta without importing
 
-hydra-acp extension                        # list configured extensions and live state
+hydra-acp extension [list]                 # list configured extensions and live state
 hydra-acp extension add <name>             # add to config (--command, --args, --env, --disabled)
 hydra-acp extension remove <name>          # remove from config
 hydra-acp extension start|stop|restart <n> # lifecycle on a running extension
 hydra-acp extension logs <name> [-f] [-n]  # tail (default 50) or follow an extension's log
 
-hydra-acp agent                            # list agents in the registry
+hydra-acp agent [list]                     # list agents in the registry
 hydra-acp agent install <id>               # pre-install an agent (else lazy on first use)
+hydra-acp agent refresh                    # force a registry re-fetch
+hydra-acp agent sync <id>                  # spawn <id> just long enough to ACP session/list it,
+                                           # then persist any sessions it remembers as cold rows
+                                           # (lets you bring in pre-existing agent sessions)
 
-hydra-acp config                            # print resolved config path/values
+hydra-acp auth                             # list active session tokens
+hydra-acp auth password [--force]          # set the daemon's master password
+hydra-acp auth revoke <id>                 # revoke a session token
 ```
 
 A bare invocation (`hydra-acp` with no subcommand) auto-dispatches based on whether stdout is a TTY: a real terminal launches the TUI, a piped stdio (the editor-spawned case) drops into shim mode. Pass `shim` or `tui` explicitly to force one or the other. Editors should configure `hydra-acp shim` so the choice is unambiguous regardless of how the editor wires stdio.
@@ -317,11 +338,11 @@ Every config-knob flag has an `HYDRA_ACP_FOO_BAR` env-var equivalent. Flag wins
 | `--name` | `HYDRA_ACP_NAME` |
 | `--agent` | `HYDRA_ACP_AGENT` |
 | `--model` | `HYDRA_ACP_MODEL` |
-| `--session-id` | `HYDRA_ACP_SESSION_ID` |
+| `--session` | `HYDRA_ACP_SESSION` |
 
 `--model` is a one-shot override for the per-agent `defaultModels` entry in `~/.hydra-acp/config.json`. It only applies at fresh session creation — resurrect and `/hydra agent` switch ignore it (resurrected sessions stay on whatever model they were last using).
 
-Action commands (`init`, `daemon`, `sessions`, `--help`, `--version`, `--rotate-token`) are not config knobs and are flag-only.
+Action commands (`init`, `daemon`, `session`, `extension`, `agent`, `auth`, `cat`, `--help`, `--version`, `--rotate-token`) are not config knobs and are flag-only.
 
 ### Registry id resolution
 

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")
     };
   }
@@ -3832,7 +3837,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 +3846,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 +3856,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;
   }
 });
 
@@ -7353,24 +7377,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 +8484,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);
             }
@@ -11019,11 +11041,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 +11056,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 ",
@@ -11656,9 +11680,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);
   }
@@ -12035,8 +12085,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 +12464,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 +12472,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 +12832,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 +12855,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 +13033,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 +13049,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 +14745,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 +14871,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 +15177,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 +15273,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 +15592,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.
@@ -17451,7 +17655,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 +17677,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 +18802,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 +20146,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 +21332,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 +21348,6 @@ async function main() {
         await runDaemonRestart();
         return;
       }
-      if (sub === "status") {
-        await runDaemonStatus();
-        return;
-      }
       if (sub === "logs") {
         await runDaemonLogs(tail.slice(1));
         return;
@@ -21070,6 +21460,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 +21624,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 +21648,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",

package/dist/index.d.ts

@@ -1984,6 +1984,7 @@ declare const SessionRecord: z.ZodObject<{
         name?: string | undefined;
         description?: string | undefined;
     }>, "many">>;
+    pendingHistorySync: z.ZodOptional<z.ZodBoolean>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -2022,6 +2023,7 @@ declare const SessionRecord: z.ZodObject<{
         name?: string | undefined;
         description?: string | undefined;
     }[] | undefined;
+    pendingHistorySync?: boolean | undefined;
 }, {
     sessionId: string;
     version: 1;
@@ -2058,6 +2060,7 @@ declare const SessionRecord: z.ZodObject<{
         name?: string | undefined;
         description?: string | undefined;
     }[] | undefined;
+    pendingHistorySync?: boolean | undefined;
 }>;
 type SessionRecord = z.infer<typeof SessionRecord>;
 declare class SessionStore {
@@ -2305,6 +2308,7 @@ interface ResurrectParams {
     agentModes?: AdvertisedMode[];
     agentModels?: AdvertisedModel[];
     createdAt?: string;
+    pendingHistorySync?: boolean;
 }
 type AgentSpawner = (opts: AgentInstanceOptions) => AgentInstance;
 interface SessionManagerOptions {
@@ -2333,11 +2337,17 @@ declare class SessionManager {
     private doResurrect;
     private doResurrectFromImport;
     private resolveImportCwd;
+    syncFromAgent(agentId: string): Promise<{
+        synced: SessionRecord[];
+        skipped: number;
+    }>;
+    private collectAgentSessions;
     private bootstrapAgent;
     private attachManagerHooks;
     getHistory(sessionId: string): Promise<HistoryEntry[] | undefined>;
     loadHistory(sessionId: string): Promise<HistoryEntry[]>;
     loadFromDisk(sessionId: string): Promise<ResurrectParams | undefined>;
+    private clearPendingHistorySync;
     private deriveTitleFromHistory;
     get(sessionId: string): Session | undefined;
     activeAgentVersions(): Map<string, Set<string>>;
@@ -2459,6 +2469,7 @@ declare const paths: {
     extensionLogFile: (name: string) => string;
     extensionPidFile: (name: string) => string;
     tuiHistoryFile: (id: string) => string;
+    globalTuiHistoryFile: () => string;
     tuiLogFile: () => string;
 };
 

package/dist/index.js

@@ -87,6 +87,11 @@ var paths = {
   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")
 };
 
@@ -4325,6 +4330,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()
 });
@@ -4445,6 +4456,7 @@ function recordFromMemorySession(args) {
     agentCommands: args.agentCommands,
     agentModes: args.agentModes,
     agentModels: args.agentModels,
+    pendingHistorySync: args.pendingHistorySync,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
   };
@@ -4780,7 +4792,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,
@@ -4870,6 +4888,133 @@ var SessionManager = class {
     }
     return os2.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: os2.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.
@@ -5062,9 +5207,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.
@@ -7461,7 +7618,7 @@ function registerSessionRoutes(app, manager, defaults) {
 }
 
 // src/daemon/routes/agents.ts
-function registerAgentRoutes(app, registry) {
+function registerAgentRoutes(app, registry, manager, opts = {}) {
   app.get("/v1/agents", async () => {
     const doc = await registry.load();
     return {
@@ -7482,6 +7639,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
@@ -8597,7 +8809,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hydra-acp/cli",
-  "version": "0.1.40",
+  "version": "0.1.41",
   "description": "Multi-client ACP session daemon: spawn agents, attach over WSS, multiplex sessions across editors.",
   "license": "MIT",
   "type": "module",