@hydra-acp/cli 0.1.51 → 0.1.52

package/dist/index.js

@@ -184,7 +184,13 @@ var DaemonConfig = z.object({
   // tunnel (ngrok) or VPN (Tailscale) under a different name. The
   // `--host` flag on `share` overrides this; omitting both falls
   // back to `daemon.host`, then to "127.0.0.1" with a stderr warning.
-  publicHost: z.string().optional()
+  publicHost: z.string().optional(),
+  // How often (minutes) the daemon runs `agent sync` against every
+  // installed (non-uvx) agent in the background, picking up sessions
+  // created outside hydra so the picker can resurrect them. Spawns
+  // are staggered across the window — N agents on a 60-minute interval
+  // mean one agent spawn every 60/N minutes. Set 0 to disable entirely.
+  agentSyncIntervalMinutes: z.number().nonnegative().default(60)
 });
 var RegistryConfig = z.object({
   url: z.string().url().default(REGISTRY_URL_DEFAULT),
@@ -387,6 +393,7 @@ function expandHome(p) {
 
 // src/core/registry.ts
 import * as fs4 from "fs/promises";
+import * as path4 from "path";
 import { z as z2 } from "zod";
 
 // src/core/binary-install.ts
@@ -554,10 +561,10 @@ async function downloadTo(args) {
       logSink(formatProgress(args.agentId, received, total));
     }
   });
-  await new Promise((resolve3, reject) => {
+  await new Promise((resolve4, reject) => {
     nodeStream.on("error", reject);
     out.on("error", reject);
-    out.on("finish", () => resolve3());
+    out.on("finish", () => resolve4());
     nodeStream.pipe(out);
   });
   logSink(formatProgress(
@@ -609,14 +616,14 @@ async function extract(archivePath, dest) {
   throw new Error(`Unsupported archive format: ${archivePath}`);
 }
 function run(cmd, args) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const child = spawn(cmd, args, {
       stdio: ["ignore", "ignore", "inherit"]
     });
     child.on("error", reject);
     child.on("exit", (code, signal) => {
       if (code === 0) {
-        resolve3();
+        resolve4();
         return;
       }
       reject(
@@ -628,11 +635,11 @@ function run(cmd, args) {
   });
 }
 async function hasCommand(name) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const finder = process.platform === "win32" ? "where" : "which";
     const child = spawn(finder, [name], { stdio: "ignore" });
-    child.on("error", () => resolve3(false));
-    child.on("exit", (code) => resolve3(code === 0));
+    child.on("error", () => resolve4(false));
+    child.on("exit", (code) => resolve4(code === 0));
   });
 }
 async function fileExists(p) {
@@ -759,7 +766,7 @@ function runNpmInstall(args) {
 }
 async function runNpmInstallOnce(args, attempt) {
   try {
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       const registryArgs = args.registry ? ["--registry", args.registry] : [];
       let child;
       try {
@@ -801,7 +808,7 @@ async function runNpmInstallOnce(args, attempt) {
       });
       child.on("exit", (code, signal) => {
         if (code === 0) {
-          resolve3();
+          resolve4();
           return;
         }
         const reason = code !== null ? `exit code ${code}` : `signal ${signal ?? "unknown"}`;
@@ -988,6 +995,13 @@ var Registry = class {
     await this.writeDiskCache(fresh);
     return fresh.data;
   }
+  // Epoch ms of the last successful registry fetch (in-memory or
+  // disk). Returns undefined before load()/refresh() has populated the
+  // cache. Used by `/v1/agents` to surface "synced N minutes ago" in
+  // the CLI without exposing the full cache shape.
+  lastFetchedAt() {
+    return this.cache?.fetchedAt;
+  }
   async getAgent(id) {
     const doc = await this.load();
     const exact = doc.agents.find((a) => a.id === id);
@@ -1074,6 +1088,46 @@ function npxPackageBasename(agent) {
   const atIdx = afterSlash.lastIndexOf("@");
   return atIdx <= 0 ? afterSlash : afterSlash.slice(0, atIdx);
 }
+async function agentInstallState(agent) {
+  const platformKey = currentPlatformKey();
+  if (!platformKey) {
+    return "no";
+  }
+  const version = agent.version ?? "current";
+  if (agent.distribution.binary) {
+    const target = pickBinaryTarget(agent.distribution.binary, platformKey);
+    if (target?.cmd) {
+      const cmdPath = path4.resolve(
+        paths.agentInstallDir(agent.id, platformKey, version),
+        target.cmd
+      );
+      if (await fileExists3(cmdPath)) {
+        return "yes";
+      }
+    }
+  }
+  if (agent.distribution.npx) {
+    const npx = agent.distribution.npx;
+    const bin = npx.bin ?? npxPackageBasename(agent) ?? npx.package;
+    const installDir = paths.agentNpmInstallDir(agent.id, platformKey, version);
+    const binPath = path4.join(installDir, "node_modules", ".bin", bin);
+    if (await fileExists3(binPath)) {
+      return "yes";
+    }
+  }
+  if (!agent.distribution.npx && !agent.distribution.binary && agent.distribution.uvx) {
+    return "lazy";
+  }
+  return "no";
+}
+async function fileExists3(p) {
+  try {
+    await fs4.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function planSpawn(agent, callerArgs = [], options = {}) {
   const version = agent.version ?? "current";
   if (agent.distribution.npx) {
@@ -1689,13 +1743,13 @@ function ndjsonStreamFromStdio(stdout, stdin) {
         throw new Error("stream is closed");
       }
       const line = JSON.stringify(message) + "\n";
-      await new Promise((resolve3, reject) => {
+      await new Promise((resolve4, reject) => {
         stdin.write(line, (err) => {
           if (err) {
             reject(err);
             return;
           }
-          resolve3();
+          resolve4();
         });
       });
     },
@@ -1787,9 +1841,9 @@ var JsonRpcConnection = class _JsonRpcConnection {
     }
     const id = nanoid();
     const message = { jsonrpc: "2.0", id, method, params };
-    const response = new Promise((resolve3, reject) => {
+    const response = new Promise((resolve4, reject) => {
       this.pending.set(id, {
-        resolve: (result) => resolve3(result),
+        resolve: (result) => resolve4(result),
         reject
       });
       this.stream.send(message).catch((err) => {
@@ -2216,14 +2270,14 @@ var SessionStreamBuffer = class {
     if (cap === 0) {
       return Promise.resolve("timeout");
     }
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       const waiter = {
         resolve: (outcome) => {
           if (waiter.timer !== void 0) {
             clearTimeout(waiter.timer);
             waiter.timer = void 0;
           }
-          resolve3(outcome);
+          resolve4(outcome);
         },
         timer: setTimeout(() => {
           const idx = this.waiters.indexOf(waiter);
@@ -2231,7 +2285,7 @@ var SessionStreamBuffer = class {
             this.waiters.splice(idx, 1);
           }
           waiter.timer = void 0;
-          resolve3("timeout");
+          resolve4("timeout");
         }, cap)
       };
       this.waiters.push(waiter);
@@ -2434,8 +2488,8 @@ var SessionStreamBuffer = class {
     return out;
   }
   scheduleFileWrite(chunk) {
-    const path13 = this.filePath;
-    if (path13 === void 0) {
+    const path14 = this.filePath;
+    if (path14 === void 0) {
       return;
     }
     if (this.fileCapReached) {
@@ -2450,7 +2504,7 @@ var SessionStreamBuffer = class {
     const slice = chunk.length <= remaining ? chunk : chunk.subarray(0, remaining);
     this.fileBytesWritten += slice.length;
     const willHitCap = this.fileBytesWritten >= this.fileCapBytes;
-    this.fileWriteChain = this.fileWriteChain.then(() => fsp3.appendFile(path13, slice)).catch((err) => {
+    this.fileWriteChain = this.fileWriteChain.then(() => fsp3.appendFile(path14, slice)).catch((err) => {
       this.logWriteError?.(err);
     });
     if (willHitCap && !this.fileCapReached) {
@@ -2863,7 +2917,7 @@ var Session = class {
         const claimIdx = i;
         const claimEnvelope = envelope;
         const claimOriginatedBy = new Set(originatedBy);
-        await new Promise((resolve3) => {
+        await new Promise((resolve4) => {
           const timer = setTimeout(() => {
             if (this.pendingClaims.delete(token)) {
               this.broadcastQueueNotification(
@@ -2874,14 +2928,14 @@ var Session = class {
                 claimEnvelope,
                 /* @__PURE__ */ new Set([...claimOriginatedBy, t.name]),
                 claimIdx + 1
-              ).then(resolve3);
+              ).then(resolve4);
             }
           }, TRANSFORMER_CLAIM_TIMEOUT_MS);
           if (typeof timer.unref === "function") {
             timer.unref();
           }
           this.pendingClaims.set(token, {
-            resolve: () => resolve3(),
+            resolve: () => resolve4(),
             timer,
             transformerName: t.name,
             method: "session/update",
@@ -3721,7 +3775,7 @@ var Session = class {
         const claimIdx = i;
         const claimEnvelope = envelope;
         const claimOriginatedBy = new Set(originatedBy);
-        return new Promise((resolve3) => {
+        return new Promise((resolve4) => {
           const timer = setTimeout(() => {
             if (this.pendingClaims.delete(token)) {
               this.broadcastQueueNotification(
@@ -3733,14 +3787,14 @@ var Session = class {
                 claimEnvelope,
                 /* @__PURE__ */ new Set([...claimOriginatedBy, t.name]),
                 claimIdx + 1
-              ).then(resolve3).catch(() => resolve3(defaultStopPayload(method)));
+              ).then(resolve4).catch(() => resolve4(defaultStopPayload(method)));
             }
           }, TRANSFORMER_CLAIM_TIMEOUT_MS);
           if (typeof timer.unref === "function") {
             timer.unref();
           }
           this.pendingClaims.set(token, {
-            resolve: resolve3,
+            resolve: resolve4,
             timer,
             transformerName: t.name,
             method,
@@ -4493,12 +4547,12 @@ ${text}
       } else {
         const inList = current ? models.some((m) => m.modelId === current) : true;
         const lines = models.map((m) => {
-          const marker = m.modelId === current ? " \u25C0" : "";
+          const marker = m.modelId === current ? "\u25B6 " : "  ";
           const desc = m.name && m.name !== m.modelId ? `  ${m.name}` : "";
-          return `${m.modelId}${marker}${desc}`;
+          return `${marker}${m.modelId}${desc}`;
         });
         if (!inList && current) {
-          lines.unshift(`${current} \u25C0`);
+          lines.unshift(`\u25B6 ${current}`);
         }
         body = lines.join("\n");
       }
@@ -4998,12 +5052,12 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
     this.clients.clear();
     if (this.streamBuffer !== void 0) {
       const buf = this.streamBuffer;
-      const path13 = this.streamFilePath;
+      const path14 = this.streamFilePath;
       this.streamBuffer = void 0;
       this.streamFilePath = void 0;
       buf.close();
-      if (path13 !== void 0) {
-        void buf.drainFileWrites().then(() => fsp4.unlink(path13).catch(() => void 0));
+      if (path14 !== void 0) {
+        void buf.drainFileWrites().then(() => fsp4.unlink(path14).catch(() => void 0));
       }
     }
     for (const handler of this.closeHandlers) {
@@ -5165,7 +5219,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
     }
     const clientParams = this.rewriteForClient(params);
     const toolCallId = extractToolCallId(clientParams);
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       let settled = false;
       const outbound = [];
       const entry = { addClient: sendTo };
@@ -5204,7 +5258,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
                 update
               }).catch(() => void 0);
             }
-            resolve3(result);
+            resolve4(result);
           });
         }).catch((err) => {
           settle(() => reject(err));
@@ -5220,14 +5274,14 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
   // in flight, but doesn't emit prompt_queue_* broadcasts — clients
   // shouldn't see hydra's housekeeping in their chip list.
   async enqueuePrompt(task) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const entry = {
         kind: "internal",
         messageId: generateMessageId(),
         enqueuedAt: Date.now(),
         cancelled: false,
         task,
-        resolve: resolve3,
+        resolve: resolve4,
         reject
       };
       this.promptQueue.push(entry);
@@ -5246,7 +5300,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
     if (client.clientInfo?.name) originator.name = client.clientInfo.name;
     if (client.clientInfo?.version)
       originator.version = client.clientInfo.version;
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const entry = {
         kind: "user",
         messageId,
@@ -5255,7 +5309,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         prompt: promptArray,
         enqueuedAt: Date.now(),
         cancelled: false,
-        resolve: resolve3,
+        resolve: resolve4,
         reject
       };
       this.promptQueue.push(entry);
@@ -5677,7 +5731,7 @@ function firstLine(text, max) {
 
 // src/core/session-store.ts
 import * as fs6 from "fs/promises";
-import * as path4 from "path";
+import * as path5 from "path";
 import { customAlphabet as customAlphabet2 } from "nanoid";
 import { z as z4 } from "zod";
 var HYDRA_ID_ALPHABET2 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -6051,29 +6105,29 @@ var HistoryStore = class {
 
 // src/tui/history.ts
 import { promises as fs8 } from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 async function saveHistory(file, history) {
-  await fs8.mkdir(path5.dirname(file), { recursive: true });
+  await fs8.mkdir(path6.dirname(file), { recursive: true });
   const lines = history.map((entry) => JSON.stringify(entry));
   await fs8.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
 }
 
 // src/core/hydra-version.ts
 import { fileURLToPath } from "url";
-import * as path6 from "path";
+import * as path7 from "path";
 import * as fs9 from "fs";
 function resolveVersion() {
   try {
-    let dir = path6.dirname(fileURLToPath(import.meta.url));
+    let dir = path7.dirname(fileURLToPath(import.meta.url));
     for (let i = 0; i < 8; i += 1) {
-      const candidate = path6.join(dir, "package.json");
+      const candidate = path7.join(dir, "package.json");
       if (fs9.existsSync(candidate)) {
         const pkg = JSON.parse(fs9.readFileSync(candidate, "utf8"));
         if (typeof pkg.version === "string" && pkg.version.length > 0 && (typeof pkg.name !== "string" || pkg.name.includes("hydra-acp"))) {
           return pkg.version;
         }
       }
-      const parent = path6.dirname(dir);
+      const parent = path7.dirname(dir);
       if (parent === dir) {
         break;
       }
@@ -7547,7 +7601,7 @@ async function historyMtimeIso(sessionId) {
 import { spawn as spawn4 } from "child_process";
 import * as fs11 from "fs";
 import * as fsp5 from "fs/promises";
-import * as path7 from "path";
+import * as path8 from "path";
 var RESTART_BASE_MS = 1e3;
 var RESTART_CAP_MS = 6e4;
 var STOP_GRACE_MS = 3e3;
@@ -7604,9 +7658,9 @@ var ExtensionManager = class {
       } catch {
       }
       tasks.push(
-        new Promise((resolve3) => {
+        new Promise((resolve4) => {
           if (child.exitCode !== null || child.signalCode !== null) {
-            resolve3();
+            resolve4();
             return;
           }
           const timer = setTimeout(() => {
@@ -7614,11 +7668,11 @@ var ExtensionManager = class {
               child.kill("SIGKILL");
             } catch {
             }
-            resolve3();
+            resolve4();
           }, STOP_GRACE_MS);
           child.on("exit", () => {
             clearTimeout(timer);
-            resolve3();
+            resolve4();
           });
         })
       );
@@ -7726,8 +7780,8 @@ var ExtensionManager = class {
     if (child.exitCode !== null || child.signalCode !== null) {
       return;
     }
-    const exited = new Promise((resolve3) => {
-      entry.exitWaiters.push(resolve3);
+    const exited = new Promise((resolve4) => {
+      entry.exitWaiters.push(resolve4);
     });
     try {
       child.kill("SIGTERM");
@@ -7802,7 +7856,7 @@ var ExtensionManager = class {
       if (!entry.endsWith(".pid")) {
         continue;
       }
-      const pidPath = path7.join(paths.extensionsDir(), entry);
+      const pidPath = path8.join(paths.extensionsDir(), entry);
       let pid;
       try {
         const raw = await fsp5.readFile(pidPath, "utf8");
@@ -7934,8 +7988,8 @@ var ExtensionManager = class {
         entry.processToken = void 0;
       }
       const waiters = entry.exitWaiters.splice(0);
-      for (const resolve3 of waiters) {
-        resolve3();
+      for (const resolve4 of waiters) {
+        resolve4();
       }
       if (this.stopping || entry.manuallyStopped) {
         try {
@@ -7983,7 +8037,7 @@ function withCode2(err, code) {
 import { spawn as spawn5 } from "child_process";
 import * as fs12 from "fs";
 import * as fsp6 from "fs/promises";
-import * as path8 from "path";
+import * as path9 from "path";
 var RESTART_BASE_MS2 = 1e3;
 var RESTART_CAP_MS2 = 6e4;
 var STOP_GRACE_MS2 = 3e3;
@@ -8067,9 +8121,9 @@ var TransformerManager = class {
       } catch {
       }
       tasks.push(
-        new Promise((resolve3) => {
+        new Promise((resolve4) => {
           if (child.exitCode !== null || child.signalCode !== null) {
-            resolve3();
+            resolve4();
             return;
           }
           const timer = setTimeout(() => {
@@ -8077,11 +8131,11 @@ var TransformerManager = class {
               child.kill("SIGKILL");
             } catch {
             }
-            resolve3();
+            resolve4();
           }, STOP_GRACE_MS2);
           child.on("exit", () => {
             clearTimeout(timer);
-            resolve3();
+            resolve4();
           });
         })
       );
@@ -8186,8 +8240,8 @@ var TransformerManager = class {
     if (child.exitCode !== null || child.signalCode !== null) {
       return;
     }
-    const exited = new Promise((resolve3) => {
-      entry.exitWaiters.push(resolve3);
+    const exited = new Promise((resolve4) => {
+      entry.exitWaiters.push(resolve4);
     });
     try {
       child.kill("SIGTERM");
@@ -8262,7 +8316,7 @@ var TransformerManager = class {
       if (!entry.endsWith(".pid")) {
         continue;
       }
-      const pidPath = path8.join(paths.transformersDir(), entry);
+      const pidPath = path9.join(paths.transformersDir(), entry);
       let pid;
       try {
         const raw = await fsp6.readFile(pidPath, "utf8");
@@ -8394,8 +8448,8 @@ var TransformerManager = class {
         entry.processToken = void 0;
       }
       const waiters = entry.exitWaiters.splice(0);
-      for (const resolve3 of waiters) {
-        resolve3();
+      for (const resolve4 of waiters) {
+        resolve4();
       }
       if (this.stopping || entry.manuallyStopped) {
         try {
@@ -8490,7 +8544,7 @@ var ExtensionCommandRegistry = class {
 
 // src/core/agent-prune.ts
 import * as fsp7 from "fs/promises";
-import * as path9 from "path";
+import * as path10 from "path";
 var logSink3 = (msg) => {
   process.stderr.write(msg + "\n");
 };
@@ -8508,7 +8562,7 @@ async function pruneStaleAgentVersions(registry, sessionManager) {
     desiredByAgent.set(a.id, a.version ?? "current");
   }
   const activeByAgent = sessionManager.activeAgentVersions();
-  const platformDir = path9.join(paths.agentsDir(), platformKey);
+  const platformDir = path10.join(paths.agentsDir(), platformKey);
   let agentEntries;
   try {
     agentEntries = await fsp7.readdir(platformDir, { withFileTypes: true });
@@ -8530,7 +8584,7 @@ async function pruneStaleAgentVersions(registry, sessionManager) {
       continue;
     }
     const activeVersions = activeByAgent.get(agentId) ?? /* @__PURE__ */ new Set();
-    const agentDir = path9.join(platformDir, agentId);
+    const agentDir = path10.join(platformDir, agentId);
     let versionEntries;
     try {
       versionEntries = await fsp7.readdir(agentDir, { withFileTypes: true });
@@ -8554,7 +8608,7 @@ async function pruneStaleAgentVersions(registry, sessionManager) {
       if (version.includes(".partial-")) {
         continue;
       }
-      const versionDir = path9.join(agentDir, version);
+      const versionDir = path10.join(agentDir, version);
       try {
         await fsp7.rm(versionDir, { recursive: true, force: true });
         logSink3(`hydra-acp: pruned stale ${agentId} ${version} (${versionDir})`);
@@ -8567,9 +8621,75 @@ async function pruneStaleAgentVersions(registry, sessionManager) {
   }
 }
 
+// src/core/agent-sync-scheduler.ts
+function startAgentSyncScheduler(opts) {
+  let timer;
+  let stopped = false;
+  let cursor = 0;
+  const log = (level, msg) => {
+    if (!opts.logger) {
+      return;
+    }
+    opts.logger[level](`agent-sync: ${msg}`);
+  };
+  const tick = async () => {
+    const installed = [];
+    try {
+      const doc = await opts.registry.load();
+      for (const a of doc.agents) {
+        const state = await agentInstallState(a);
+        if (state === "yes") {
+          installed.push(a.id);
+        }
+      }
+    } catch (err) {
+      log("warn", `registry load failed: ${err.message}`);
+      return opts.intervalMs;
+    }
+    if (installed.length === 0) {
+      return opts.intervalMs;
+    }
+    const idx = cursor % installed.length;
+    cursor = (cursor + 1) % installed.length;
+    const agentId = installed[idx];
+    try {
+      const { synced, skipped } = await opts.manager.syncFromAgent(agentId);
+      log(
+        "info",
+        `${agentId}: synced ${synced.length}, skipped ${skipped}`
+      );
+    } catch (err) {
+      log("warn", `${agentId}: ${err.message}`);
+    }
+    return Math.max(1, Math.floor(opts.intervalMs / installed.length));
+  };
+  const scheduleNext = (delayMs) => {
+    if (stopped) {
+      return;
+    }
+    timer = setTimeout(() => {
+      tick().then((nextDelay) => {
+        scheduleNext(nextDelay);
+      }).catch((err) => {
+        log("warn", `tick crashed: ${err.message}`);
+        scheduleNext(opts.intervalMs);
+      });
+    }, delayMs);
+    timer.unref();
+  };
+  scheduleNext(opts.intervalMs);
+  return () => {
+    stopped = true;
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+}
+
 // src/core/session-tokens.ts
 import * as fs13 from "fs/promises";
-import * as path10 from "path";
+import * as path11 from "path";
 import { createHash, randomBytes, timingSafeEqual } from "crypto";
 var TOKEN_PREFIX = "hydra_session_";
 var DEFAULT_TTL_SEC = 60 * 60 * 24 * 30;
@@ -8577,7 +8697,7 @@ var ID_LENGTH = 12;
 var TOKEN_BYTES = 32;
 var WRITE_DEBOUNCE_MS = 50;
 function tokensFilePath() {
-  return path10.join(paths.home(), "session-tokens.json");
+  return path11.join(paths.home(), "session-tokens.json");
 }
 function sha256Hex(input) {
   return createHash("sha256").update(input).digest("hex");
@@ -10284,15 +10404,20 @@ function registerSessionRoutes(app, manager, defaults) {
 function registerAgentRoutes(app, registry, manager, opts = {}) {
   app.get("/v1/agents", async () => {
     const doc = await registry.load();
-    return {
-      version: doc.version,
-      agents: doc.agents.map((a) => ({
+    const agents = await Promise.all(
+      doc.agents.map(async (a) => ({
         id: a.id,
         name: a.name,
         version: a.version,
         description: a.description,
-        distributions: Object.keys(a.distribution)
+        distributions: Object.keys(a.distribution),
+        installed: await agentInstallState(a)
       }))
+    );
+    return {
+      version: doc.version,
+      fetchedAt: registry.lastFetchedAt(),
+      agents
     };
   });
   app.get("/v1/registry", async () => {
@@ -10611,12 +10736,12 @@ import { z as z6 } from "zod";
 
 // src/core/password.ts
 import * as fs14 from "fs/promises";
-import * as path11 from "path";
+import * as path12 from "path";
 import { randomBytes as randomBytes2, scrypt, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { promisify } from "util";
 var scryptAsync = promisify(scrypt);
 function passwordHashPath() {
-  return path11.join(paths.home(), "password-hash");
+  return path12.join(paths.home(), "password-hash");
 }
 var DEFAULT_N = 1 << 15;
 var MAX_MEM = 128 * 1024 * 1024;
@@ -10805,13 +10930,13 @@ function wsToMessageStream(ws) {
         throw new Error("ws is closed");
       }
       const text = JSON.stringify(message);
-      await new Promise((resolve3, reject) => {
+      await new Promise((resolve4, reject) => {
         ws.send(text, (err) => {
           if (err) {
             reject(err);
             return;
           }
-          resolve3();
+          resolve4();
         });
       });
     },
@@ -10833,7 +10958,7 @@ function wsToMessageStream(ws) {
 
 // src/daemon/acp-ws.ts
 import * as os4 from "os";
-import * as path12 from "path";
+import * as path13 from "path";
 import { randomBytes as randomBytes3 } from "crypto";
 function registerAcpWsEndpoint(app, deps) {
   app.get("/acp", { websocket: true }, async (socket, request) => {
@@ -10916,6 +11041,50 @@ function registerAcpWsEndpoint(app, deps) {
         registry.clear(processIdentity.name);
       });
     }
+    if (processIdentity && deps.extensionMcp) {
+      const mcpRegistry = deps.extensionMcp;
+      connection.onRequest("hydra-acp/register_mcp_tools", async (raw) => {
+        const params = raw ?? {};
+        const instructions = typeof params.instructions === "string" ? params.instructions : void 0;
+        const tools = Array.isArray(params.tools) ? params.tools.map((t) => {
+          if (!t || typeof t !== "object") {
+            return void 0;
+          }
+          const obj = t;
+          if (typeof obj.name !== "string" || obj.name.length === 0) {
+            return void 0;
+          }
+          if (typeof obj.description !== "string") {
+            return void 0;
+          }
+          if (obj.inputSchema === null || typeof obj.inputSchema !== "object") {
+            return void 0;
+          }
+          const spec = {
+            name: obj.name,
+            description: obj.description,
+            inputSchema: obj.inputSchema
+          };
+          if (obj.outputSchema !== null && typeof obj.outputSchema === "object") {
+            spec.outputSchema = obj.outputSchema;
+          }
+          return spec;
+        }).filter((s) => s !== void 0) : [];
+        if (tools.length === 0) {
+          throw new Error("register_mcp_tools requires at least one tool");
+        }
+        mcpRegistry.register(
+          processIdentity.name,
+          connection,
+          instructions,
+          tools
+        );
+        return { ok: true, registered: tools.length };
+      });
+      connection.onClose(() => {
+        mcpRegistry.clear(processIdentity.name);
+      });
+    }
     if (processIdentity?.kind === "transformer") {
       connection.onRequest("transformer/initialize", async (raw) => {
         const params = raw ?? {};
@@ -11002,13 +11171,13 @@ function registerAcpWsEndpoint(app, deps) {
             { code: JsonRpcErrorCodes.SessionNotFound }
           );
         }
-        return new Promise((resolve3) => {
+        return new Promise((resolve4) => {
           const entries = [];
           let unsubscribe;
           const finish = () => {
             clearTimeout(timer);
             unsubscribe?.();
-            resolve3({ entries });
+            resolve4({ entries });
           };
           unsubscribe = child.onBroadcast((entry) => {
             entries.push(entry);
@@ -11060,12 +11229,12 @@ function registerAcpWsEndpoint(app, deps) {
       let stdinToken;
       let stdinReservation;
       let augmentedMcpServers = params.mcpServers;
-      if (hydraMeta.mcpStdin === true && deps.stdinMcpRegistry !== void 0 && deps.getDaemonOrigin !== void 0) {
+      if (hydraMeta.mcpStdin === true && deps.mcpTokenRegistry !== void 0 && deps.getDaemonOrigin !== void 0) {
         stdinToken = randomBytes3(32).toString("hex");
-        stdinReservation = deps.stdinMcpRegistry.reserve(stdinToken);
-        const url = `${deps.getDaemonOrigin()}/mcp/stdin`;
+        stdinReservation = deps.mcpTokenRegistry.reserve(stdinToken);
+        const url = `${deps.getDaemonOrigin()}/mcp/hydra-acp-stdin`;
         const descriptor = {
-          name: "hydra_stdin",
+          name: "hydra-acp-stdin",
           type: "http",
           url,
           headers: [
@@ -11074,6 +11243,28 @@ function registerAcpWsEndpoint(app, deps) {
         };
         augmentedMcpServers = [...params.mcpServers ?? [], descriptor];
       }
+      let extMcpToken;
+      let extMcpReservation;
+      if (deps.extensionMcp !== void 0 && deps.mcpTokenRegistry !== void 0 && deps.getDaemonOrigin !== void 0) {
+        const extNames = deps.extensionMcp.list();
+        if (extNames.length > 0) {
+          extMcpToken = randomBytes3(32).toString("hex");
+          extMcpReservation = deps.mcpTokenRegistry.reserve(extMcpToken);
+          const origin = deps.getDaemonOrigin();
+          const descriptors = extNames.map((name) => ({
+            name,
+            type: "http",
+            url: `${origin}/mcp/${name}`,
+            headers: [
+              { name: "Authorization", value: `Bearer ${extMcpToken}` }
+            ]
+          }));
+          augmentedMcpServers = [
+            ...augmentedMcpServers ?? [],
+            ...descriptors
+          ];
+        }
+      }
       let session;
       try {
         session = await deps.manager.create({
@@ -11091,16 +11282,27 @@ function registerAcpWsEndpoint(app, deps) {
         if (stdinReservation !== void 0) {
           stdinReservation.abandon(err instanceof Error ? err : void 0);
         }
+        if (extMcpReservation !== void 0) {
+          extMcpReservation.abandon(err instanceof Error ? err : void 0);
+        }
         throw err;
       }
-      if (stdinToken !== void 0 && stdinReservation !== void 0 && deps.stdinMcpRegistry !== void 0) {
+      if (stdinToken !== void 0 && stdinReservation !== void 0 && deps.mcpTokenRegistry !== void 0) {
         const token2 = stdinToken;
-        const registry = deps.stdinMcpRegistry;
+        const registry = deps.mcpTokenRegistry;
         stdinReservation.complete(session);
         session.onClose(() => {
           void registry.unbind(token2);
         });
       }
+      if (extMcpToken !== void 0 && extMcpReservation !== void 0 && deps.mcpTokenRegistry !== void 0) {
+        const token2 = extMcpToken;
+        const registry = deps.mcpTokenRegistry;
+        extMcpReservation.complete(session);
+        session.onClose(() => {
+          void registry.unbind(token2);
+        });
+      }
       const client = bindClientToSession(connection, session, state);
       const { entries: replay } = await session.attach(client, "full");
       state.attached.set(session.sessionId, {
@@ -11403,7 +11605,7 @@ function registerAcpWsEndpoint(app, deps) {
         openOpts.fileCapBytes = params.fileCapBytes;
       }
       if ((params.mode ?? "memory") === "file") {
-        openOpts.filePathFor = (sid) => path12.join(os4.tmpdir(), `hydra-stdin-${sid}.log`);
+        openOpts.filePathFor = (sid) => path13.join(os4.tmpdir(), `hydra-acp-stdin-${sid}.log`);
       }
       return session.openStream(openOpts);
     });
@@ -11821,26 +12023,25 @@ function bindClientToSession(connection, session, state, clientInfo, callerClien
   };
 }
 
-// src/daemon/mcp/stdin-registry.ts
-var StdinMcpRegistry = class {
+// src/daemon/mcp/token-registry.ts
+var McpTokenRegistry = class {
   byToken = /* @__PURE__ */ new Map();
-  // Reserve a token slot before the session exists. Used by acp-ws when
-  // we need to inject the bearer into the agent's mcpServers BEFORE
-  // manager.create() returns — claude-acp connects to /mcp/stdin during
-  // session/new initialization (eagerly), so the route handler must be
-  // able to find the token by the time the agent's first request lands.
   reserve(token) {
     if (this.byToken.has(token)) {
-      throw new Error(`stdin MCP token already bound`);
+      throw new Error("mcp token already bound");
     }
     let resolveSession;
     let rejectSession;
-    const sessionReady = new Promise((resolve3, reject) => {
-      resolveSession = resolve3;
+    const sessionReady = new Promise((resolve4, reject) => {
+      resolveSession = resolve4;
       rejectSession = reject;
     });
     sessionReady.catch(() => void 0);
-    const entry = { session: void 0, sessionReady };
+    const entry = {
+      session: void 0,
+      sessionReady,
+      disposers: []
+    };
     this.byToken.set(token, entry);
     return {
       complete: (session) => {
@@ -11849,7 +12050,7 @@ var StdinMcpRegistry = class {
       },
       abandon: (reason) => {
         this.byToken.delete(token);
-        rejectSession(reason ?? new Error("stdin MCP reservation abandoned"));
+        rejectSession(reason ?? new Error("mcp token reservation abandoned"));
       }
     };
   }
@@ -11862,29 +12063,26 @@ var StdinMcpRegistry = class {
   lookup(token) {
     return this.byToken.get(token);
   }
-  attachTransport(token, server, transport) {
-    const ep = this.byToken.get(token);
-    if (!ep) {
+  // Register a cleanup callback for this token. No-op if the token is
+  // not currently bound — late additions after unbind() would never fire
+  // anyway, so dropping them silently is safer than throwing into an
+  // unrelated cleanup path.
+  addDisposer(token, dispose) {
+    const entry = this.byToken.get(token);
+    if (entry === void 0) {
       return;
     }
-    ep.server = server;
-    ep.transport = transport;
+    entry.disposers.push(dispose);
   }
   async unbind(token) {
-    const ep = this.byToken.get(token);
-    if (!ep) {
+    const entry = this.byToken.get(token);
+    if (entry === void 0) {
       return;
     }
     this.byToken.delete(token);
-    if (ep.transport) {
-      try {
-        await ep.transport.close();
-      } catch {
-      }
-    }
-    if (ep.server) {
+    for (const dispose of entry.disposers) {
       try {
-        await ep.server.close();
+        await dispose();
       } catch {
       }
     }
@@ -11899,6 +12097,8 @@ import { randomUUID } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { z as z7 } from "zod";
+
+// src/daemon/mcp/bearer.ts
 var BEARER_PREFIX2 = "Bearer ";
 function extractBearer(req) {
   const header = req.headers.authorization;
@@ -11911,15 +12111,17 @@ function extractBearer(req) {
   const token = header.slice(BEARER_PREFIX2.length).trim();
   return token.length > 0 ? token : void 0;
 }
+
+// src/daemon/mcp/stdin-server.ts
 function buildMcpServer(session) {
   const server = new McpServer(
-    { name: "hydra-stdin", version: "1.0.0" },
+    { name: "hydra-acp-stdin", version: "1.0.0" },
     {
-      instructions: "Piped input from `hydra cat --stream` is exposed here as a byte stream. Use `tail_stdin` for the latest N bytes (good for finding the end of a log), `head_stdin` for the first N bytes (good for headers/preamble), `read_stdin` for windowed reads against an absolute byte cursor, `wait_for_more` to block until new bytes arrive past a cursor, and `stdin_info` for the current cursors/capacity/closed status. Byte payloads come back base64-encoded."
+      instructions: "Piped input from `hydra cat --stream` is exposed here as a byte stream. Use `tail` for the latest N bytes (good for finding the end of a log), `head` for the first N bytes (good for headers/preamble), `read` for windowed reads against an absolute byte cursor, `wait_for_more` to block until new bytes arrive past a cursor, and `info` for the current cursors/capacity/closed status. Byte payloads come back base64-encoded."
     }
   );
   server.registerTool(
-    "tail_stdin",
+    "tail",
     {
       description: "Return the most recent `bytes` bytes of piped stdin (capped server-side, default 64 KiB max). `truncated:true` means older bytes existed but have been evicted from the ring.",
       inputSchema: {
@@ -11940,7 +12142,7 @@ function buildMcpServer(session) {
     }
   );
   server.registerTool(
-    "head_stdin",
+    "head",
     {
       description: "Return the first `bytes` bytes of piped stdin (capped server-side, default 64 KiB max). `truncated:true` means the head has already been evicted from the ring and the returned bytes start at the oldest still-resident cursor.",
       inputSchema: {
@@ -11961,7 +12163,7 @@ function buildMcpServer(session) {
     }
   );
   server.registerTool(
-    "read_stdin",
+    "read",
     {
       description: "Read up to `max_bytes` bytes starting at absolute byte `cursor`. Returns `{bytes, nextCursor, gap?, eof?}` \u2014 `gap` is the number of bytes silently skipped because the ring had evicted them; `eof:true` means the producer closed and there is nothing left to read.",
       inputSchema: {
@@ -12014,9 +12216,9 @@ function buildMcpServer(session) {
     }
   );
   server.registerTool(
-    "grep_stdin",
+    "grep",
     {
-      description: "Scan piped stdin line-by-line and return lines matching `pattern`. Prefer this over `read_stdin` when the question is 'find lines that mention X' \u2014 it filters server-side so you don't pull and decode 64 KiB base64 windows. Returns `{matches: [{cursor, line, before?, after?}], truncated, nextCursor, gap?, scannedBytes, eof?}`. Lines come back as decoded UTF-8 strings (not base64). When `truncated:true`, re-call with `cursor: nextCursor` to resume.",
+      description: "Scan piped stdin line-by-line and return lines matching `pattern`. Prefer this over `read` when the question is 'find lines that mention X' \u2014 it filters server-side so you don't pull and decode 64 KiB base64 windows. Returns `{matches: [{cursor, line, before?, after?}], truncated, nextCursor, gap?, scannedBytes, eof?}`. Lines come back as decoded UTF-8 strings (not base64). When `truncated:true`, re-call with `cursor: nextCursor` to resume.",
       inputSchema: {
         pattern: z7.string().min(1).describe(
           "Search pattern. Treated as a JavaScript regular expression by default (set `regex:false` for a literal substring match)."
@@ -12068,7 +12270,7 @@ function buildMcpServer(session) {
     }
   );
   server.registerTool(
-    "stdin_info",
+    "info",
     {
       description: "Report cursor / capacity / closed state of the stdin ring. Cheap; safe to call repeatedly.",
       inputSchema: {}
@@ -12088,66 +12290,337 @@ function buildMcpServer(session) {
   );
   return server;
 }
-async function ensureTransport(token, session, registry) {
-  const existing = registry.lookup(token);
-  if (existing?.transport !== void 0) {
-    return existing.transport;
+var SESSION_READY_TIMEOUT_MS = 1e4;
+function registerStdinMcpRoutes(app, tokenRegistry) {
+  const builtPerToken = /* @__PURE__ */ new Map();
+  async function ensureTransport(token, session) {
+    const existing = builtPerToken.get(token);
+    if (existing !== void 0) {
+      return existing.transport;
+    }
+    const server = buildMcpServer(session);
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomUUID()
+    });
+    await server.connect(transport);
+    const pair = { server, transport };
+    builtPerToken.set(token, pair);
+    tokenRegistry.addDisposer(token, async () => {
+      builtPerToken.delete(token);
+      try {
+        await transport.close();
+      } catch {
+      }
+      try {
+        await server.close();
+      } catch {
+      }
+    });
+    return transport;
   }
-  const server = buildMcpServer(session);
-  const transport = new StreamableHTTPServerTransport({
-    sessionIdGenerator: () => randomUUID()
+  async function handle(req, reply) {
+    const token = extractBearer(req);
+    if (token === void 0) {
+      reply.code(401).send({ error: "missing bearer token" });
+      return;
+    }
+    const entry = tokenRegistry.lookup(token);
+    if (entry === void 0) {
+      reply.code(404).send({ error: "unknown stdin token" });
+      return;
+    }
+    let session;
+    if (entry.session !== void 0) {
+      session = entry.session;
+    } else {
+      let timer;
+      const timeout = new Promise((resolve4) => {
+        timer = setTimeout(() => resolve4(void 0), SESSION_READY_TIMEOUT_MS);
+      });
+      const resolved = await Promise.race([
+        entry.sessionReady.catch(() => void 0),
+        timeout
+      ]);
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+      if (resolved === void 0) {
+        reply.code(503).send({ error: "session not ready" });
+        return;
+      }
+      session = resolved;
+    }
+    const transport = await ensureTransport(token, session);
+    reply.hijack();
+    await transport.handleRequest(req.raw, reply.raw, req.body);
+  }
+  const opts = { config: { skipAuth: true } };
+  app.post("/mcp/hydra-acp-stdin", opts, async (req, reply) => {
+    await handle(req, reply);
+  });
+  app.get("/mcp/hydra-acp-stdin", opts, async (req, reply) => {
+    await handle(req, reply);
+  });
+  app.delete("/mcp/hydra-acp-stdin", opts, async (req, reply) => {
+    await handle(req, reply);
   });
-  await server.connect(transport);
-  registry.attachTransport(token, server, transport);
-  return transport;
 }
-var SESSION_READY_TIMEOUT_MS = 1e4;
-async function handle(req, reply, registry) {
-  const token = extractBearer(req);
-  if (token === void 0) {
-    reply.code(401).send({ error: "missing bearer token" });
-    return;
+
+// src/core/extension-mcp.ts
+var ExtensionMcpRegistry = class {
+  byName = /* @__PURE__ */ new Map();
+  changeHandlers = [];
+  // Set-the-whole-spec semantics, same as ExtensionCommandRegistry. A
+  // second register for the same extName overwrites tools + instructions
+  // wholesale; the change notification lets the route evict any cached
+  // transports built against the old spec.
+  register(extName, connection, instructions, tools) {
+    this.byName.set(extName, {
+      connection,
+      instructions,
+      tools: [...tools]
+    });
+    this.fireChanged(extName, "register");
   }
-  const ep = registry.lookup(token);
-  if (ep === void 0) {
-    reply.code(404).send({ error: "unknown stdin token" });
-    return;
+  clear(extName) {
+    if (this.byName.delete(extName)) {
+      this.fireChanged(extName, "clear");
+    }
   }
-  let session;
-  if (ep.session !== void 0) {
-    session = ep.session;
-  } else {
-    let timer;
-    const timeout = new Promise((resolve3) => {
-      timer = setTimeout(() => resolve3(void 0), SESSION_READY_TIMEOUT_MS);
-    });
-    const resolved = await Promise.race([
-      ep.sessionReady.catch(() => void 0),
+  lookup(extName) {
+    return this.byName.get(extName);
+  }
+  // List of currently-registered extension names. Used by session-create
+  // to decide whether to mint an extension-MCP token and which mcpServers
+  // entries to emit.
+  list() {
+    return Array.from(this.byName.keys());
+  }
+  onChange(handler) {
+    this.changeHandlers.push(handler);
+    return () => {
+      const i = this.changeHandlers.indexOf(handler);
+      if (i >= 0) {
+        this.changeHandlers.splice(i, 1);
+      }
+    };
+  }
+  fireChanged(extName, kind) {
+    for (const h of this.changeHandlers) {
+      try {
+        h(extName, kind);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/daemon/mcp/extension-route.ts
+import { StreamableHTTPServerTransport as StreamableHTTPServerTransport2 } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/daemon/mcp/build-extension-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var DEFAULT_INVOKE_TIMEOUT_MS = 6e4;
+function buildExtensionServer(extensionName, entry, options = {}) {
+  const invokeTimeoutMs = options.invokeTimeoutMs ?? DEFAULT_INVOKE_TIMEOUT_MS;
+  const server = new Server(
+    { name: extensionName, version: "1.0.0" },
+    {
+      capabilities: {
+        // listChanged: false matches the v1 strategy — the daemon closes
+        // transports on re-register; agents reconnect and re-list against
+        // the new spec naturally. Flipping to true is the upgrade path
+        // if any supported agent caches tools/list across reconnects.
+        tools: { listChanged: false }
+      },
+      ...entry.instructions !== void 0 ? { instructions: entry.instructions } : {}
+    }
+  );
+  const toolsByName = new Map(
+    entry.tools.map((t) => [t.name, t])
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: entry.tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema,
+      ...t.outputSchema !== void 0 ? { outputSchema: t.outputSchema } : {}
+    }))
+  }));
+  server.setRequestHandler(
+    CallToolRequestSchema,
+    async (req) => {
+      const toolName = req.params.name;
+      if (!toolsByName.has(toolName)) {
+        return errorResult(`unknown tool: ${toolName}`);
+      }
+      try {
+        const raw = await invokeWithTimeout(
+          entry.connection,
+          extensionName,
+          toolName,
+          req.params.arguments ?? {},
+          invokeTimeoutMs
+        );
+        return normalizeToolResult(raw, toolName);
+      } catch (err) {
+        return errorResult(
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+    }
+  );
+  return server;
+}
+async function invokeWithTimeout(connection, server, tool, args, timeoutMs) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`extension timeout after ${timeoutMs}ms`)),
+      timeoutMs
+    );
+  });
+  try {
+    return await Promise.race([
+      connection.request("hydra-acp/invoke_mcp_tool", {
+        server,
+        tool,
+        args
+      }),
       timeout
     ]);
+  } finally {
     if (timer !== void 0) {
       clearTimeout(timer);
     }
-    if (resolved === void 0) {
-      reply.code(503).send({ error: "session not ready" });
+  }
+}
+function normalizeToolResult(raw, toolName) {
+  if (raw === null || typeof raw !== "object") {
+    return errorResult(`extension ${toolName} returned non-object`);
+  }
+  const obj = raw;
+  if (!Array.isArray(obj.content)) {
+    return errorResult(`extension ${toolName} omitted content array`);
+  }
+  return obj;
+}
+function errorResult(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+
+// src/daemon/mcp/extension-route.ts
+var SESSION_READY_TIMEOUT_MS2 = 1e4;
+function registerExtensionMcpRoutes(app, tokenRegistry, extensionMcp, options = {}) {
+  const built = /* @__PURE__ */ new Map();
+  async function disposeBuiltPair(pair) {
+    try {
+      await pair.transport.close();
+    } catch {
+    }
+    try {
+      await pair.server.close();
+    } catch {
+    }
+  }
+  function evictExtension(extName) {
+    for (const tokenScope of built.values()) {
+      const pair = tokenScope.get(extName);
+      if (pair !== void 0) {
+        tokenScope.delete(extName);
+        void disposeBuiltPair(pair);
+      }
+    }
+  }
+  extensionMcp.onChange((extName) => {
+    evictExtension(extName);
+  });
+  async function ensureTransport(token, extName) {
+    let tokenScope = built.get(token);
+    if (tokenScope === void 0) {
+      tokenScope = /* @__PURE__ */ new Map();
+      built.set(token, tokenScope);
+      tokenRegistry.addDisposer(token, async () => {
+        const scope = built.get(token);
+        if (scope === void 0) {
+          return;
+        }
+        built.delete(token);
+        for (const pair of scope.values()) {
+          await disposeBuiltPair(pair);
+        }
+      });
+    }
+    const existing = tokenScope.get(extName);
+    if (existing !== void 0) {
+      return existing.transport;
+    }
+    const entry = extensionMcp.lookup(extName);
+    if (entry === void 0) {
+      return void 0;
+    }
+    const server = buildExtensionServer(extName, entry, options.buildOptions);
+    const transport = new StreamableHTTPServerTransport2({
+      sessionIdGenerator: () => randomUUID2()
+    });
+    await server.connect(transport);
+    tokenScope.set(extName, { server, transport });
+    return transport;
+  }
+  async function handle(req, reply) {
+    const token = extractBearer(req);
+    if (token === void 0) {
+      reply.code(401).send({ error: "missing bearer token" });
+      return;
+    }
+    const entry = tokenRegistry.lookup(token);
+    if (entry === void 0) {
+      reply.code(404).send({ error: "unknown mcp token" });
+      return;
+    }
+    if (entry.session === void 0) {
+      let timer;
+      const timeout = new Promise((resolve4) => {
+        timer = setTimeout(() => resolve4(void 0), SESSION_READY_TIMEOUT_MS2);
+      });
+      const resolved = await Promise.race([
+        entry.sessionReady.catch(() => void 0),
+        timeout
+      ]);
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+      if (resolved === void 0) {
+        reply.code(503).send({ error: "session not ready" });
+        return;
+      }
+    }
+    const extName = req.params.name;
+    const transport = await ensureTransport(token, extName);
+    if (transport === void 0) {
+      reply.code(404).send({ error: `unknown mcp server: ${extName}` });
       return;
     }
-    session = resolved;
+    reply.hijack();
+    await transport.handleRequest(req.raw, reply.raw, req.body);
   }
-  const transport = await ensureTransport(token, session, registry);
-  reply.hijack();
-  await transport.handleRequest(req.raw, reply.raw, req.body);
-}
-function registerStdinMcpRoutes(app, registry) {
   const opts = { config: { skipAuth: true } };
-  app.post("/mcp/stdin", opts, async (req, reply) => {
-    await handle(req, reply, registry);
+  app.post("/mcp/:name", opts, async (req, reply) => {
+    await handle(req, reply);
   });
-  app.get("/mcp/stdin", opts, async (req, reply) => {
-    await handle(req, reply, registry);
+  app.get("/mcp/:name", opts, async (req, reply) => {
+    await handle(req, reply);
   });
-  app.delete("/mcp/stdin", opts, async (req, reply) => {
-    await handle(req, reply, registry);
+  app.delete("/mcp/:name", opts, async (req, reply) => {
+    await handle(req, reply);
   });
 }
 
@@ -12256,8 +12729,10 @@ async function startDaemon(config, serviceToken) {
     store: sessionTokenStore,
     rateLimiter: authRateLimiter
   });
-  const stdinMcpRegistry = new StdinMcpRegistry();
-  registerStdinMcpRoutes(app, stdinMcpRegistry);
+  const mcpTokenRegistry = new McpTokenRegistry();
+  const extensionMcp = new ExtensionMcpRegistry();
+  registerStdinMcpRoutes(app, mcpTokenRegistry);
+  registerExtensionMcpRoutes(app, mcpTokenRegistry, extensionMcp);
   let daemonOriginCached;
   const getDaemonOrigin = () => {
     if (daemonOriginCached !== void 0) {
@@ -12278,7 +12753,8 @@ async function startDaemon(config, serviceToken) {
     onTransformerVersion: (name, version) => transformers.reportVersion(name, version),
     transformers,
     extensionCommands,
-    stdinMcpRegistry,
+    mcpTokenRegistry,
+    extensionMcp,
     getDaemonOrigin
   });
   await app.listen({ host: config.daemon.host, port: config.daemon.port });
@@ -12314,7 +12790,17 @@ async function startDaemon(config, serviceToken) {
       `queue replay scan failed: ${err.message}`
     );
   });
+  const intervalMs = config.daemon.agentSyncIntervalMinutes * 60 * 1e3;
+  const stopAgentSync = intervalMs > 0 ? startAgentSyncScheduler({
+    registry,
+    manager,
+    intervalMs,
+    logger: agentLogger
+  }) : void 0;
   const shutdown = async () => {
+    if (stopAgentSync) {
+      stopAgentSync();
+    }
     clearInterval(sweepInterval);
     await sessionTokenStore.flush();
     await extensions.stop();
@@ -12334,7 +12820,17 @@ async function startDaemon(config, serviceToken) {
     } catch {
     }
   };
-  return { app, manager, registry, extensions, transformers, shutdown };
+  return {
+    app,
+    manager,
+    registry,
+    extensions,
+    transformers,
+    mcpTokenRegistry,
+    extensionMcp,
+    processRegistry,
+    shutdown
+  };
 }
 async function buildLogStream(level) {
   const fileStream = await createPinoRoll({