@agentproto/cli 0.1.0 → 0.1.2

package/dist/cli.mjs

@@ -1,22 +1,23 @@
 #!/usr/bin/env node
 import { promises, existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
 import { homedir, userInfo, hostname, platform, tmpdir } from 'os';
-import { resolve, basename, join, dirname, isAbsolute, normalize, relative } from 'path';
+import { resolve, isAbsolute, join, dirname, basename, normalize as normalize$1, relative } from 'path';
 import * as childProc from 'child_process';
 import { execFile, spawn } from 'child_process';
 import { promisify, parseArgs } from 'util';
-import { unlink, readFile, chmod, readdir, writeFile, mkdir, stat, mkdtemp, rm, appendFile } from 'fs/promises';
+import { rm, readFile, mkdir, writeFile, readdir, unlink, chmod, stat, mkdtemp, appendFile } from 'fs/promises';
 import { randomUUID, randomBytes, createHash } from 'crypto';
+import { fileURLToPath, pathToFileURL } from 'url';
 import { createInterface } from 'readline/promises';
 import { stdout, stdin } from 'process';
 import { createRequire } from 'module';
-import { pathToFileURL } from 'url';
 import { z } from 'zod';
 import { createAgentCliRuntime } from '@agentproto/driver-agent-cli';
 import matter3 from 'gray-matter';
-import { wrapWebSocket, createTunnelServer } from '@agentproto/acp/tunnel';
+import { wrapWebSocket, createTunnelServer, DEFAULT_WS_DIAL_TIMEOUT_MS, DEFAULT_HTTP_FORWARD_TIMEOUT_MS } from '@agentproto/acp/tunnel';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import '@modelcontextprotocol/sdk/server/stdio.js';
+import { driverSpec } from '@agentproto/driver';
 import { EventEmitter } from 'events';
 import http, { createServer } from 'http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
@@ -28,7 +29,7 @@ import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import https from 'https';
 
 /**
- * @agentproto/cli v0.1.0-alpha
+ * @agentproto/cli v0.1.2
  * The `agentproto` binary — install / run / serve AIP-45 agent CLIs.
  */
 var __defProp = Object.defineProperty;
@@ -389,7 +390,7 @@ function xmlEscape(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 function launchctl(args) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const child = spawn("launchctl", args, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -397,9 +398,9 @@ function launchctl(args) {
     child.stderr?.setEncoding("utf8").on("data", (c) => stderr += c);
     child.on(
       "error",
-      (err) => resolve9({ code: 127, stdout, stderr: err.message })
+      (err) => resolve10({ code: 127, stdout, stderr: err.message })
     );
-    child.on("exit", (code) => resolve9({ code: code ?? 1, stdout, stderr }));
+    child.on("exit", (code) => resolve10({ code: code ?? 1, stdout, stderr }));
   });
 }
 function humaniseUptime(ms) {
@@ -844,7 +845,7 @@ async function postForm(url, body) {
   return await res.json();
 }
 function sleep(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 function formatDuration(ms) {
   if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
@@ -855,16 +856,16 @@ function openBrowser(url) {
   const p = platform();
   const cmd = p === "darwin" ? "open" : p === "win32" ? "cmd" : "xdg-open";
   const args = p === "win32" ? ["/c", "start", url] : [url];
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     try {
       const child = spawn(cmd, args, { stdio: "ignore", detached: true });
-      child.once("error", () => resolve9());
+      child.once("error", () => resolve10());
       child.once("spawn", () => {
         child.unref();
-        resolve9();
+        resolve10();
       });
     } catch {
-      resolve9();
+      resolve10();
     }
   });
 }
@@ -993,7 +994,7 @@ async function runEdit() {
   const cfg = await loadConfig();
   await saveConfig(cfg);
   const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const child = spawn(editor, [CONFIG_FILE_PATH()], {
       stdio: "inherit"
     });
@@ -1002,9 +1003,9 @@ async function runEdit() {
         `agentproto config edit: failed to launch ${editor}: ${err.message}
 `
       );
-      resolve9(1);
+      resolve10(1);
     });
-    child.on("exit", (code) => resolve9(code ?? 0));
+    child.on("exit", (code) => resolve10(code ?? 0));
   });
 }
 function parseValue(raw) {
@@ -1031,27 +1032,40 @@ async function resolveAdapter(slug) {
     );
   }
   const packageName = `@agentproto/adapter-${slug}`;
+  const camel = slugToCamel(slug);
   let mod;
+  let resolvedPackageName = packageName;
   try {
     mod = await import(packageName);
-  } catch (err) {
-    const cause = err instanceof Error ? err.message : String(err);
+  } catch (primaryErr) {
+    const hyphen = slug.lastIndexOf("-");
+    if (hyphen > 0) {
+      const parentPkg = `@agentproto/adapter-${slug.slice(0, hyphen)}`;
+      try {
+        const parentMod = await import(parentPkg);
+        const parentCandidate = parentMod[camel];
+        if (parentCandidate && typeof parentCandidate === "object" && "name" in parentCandidate) {
+          return { slug, handle: parentCandidate, source: "npm", packageName: parentPkg };
+        }
+      } catch {
+      }
+    }
+    const cause = primaryErr instanceof Error ? primaryErr.message : String(primaryErr);
     throw new Error(
       `agentproto: could not load adapter '${slug}'. Tried '${packageName}'. Install it with: npm i -g ${packageName}
   cause: ${cause}`
     );
   }
-  const camel = slugToCamel(slug);
   const candidate = mod[camel] ?? mod.default ?? mod.handle;
   if (!candidate || typeof candidate !== "object" || !("name" in candidate)) {
     throw new Error(
-      `agentproto: adapter '${packageName}' does not export an AgentCliHandle (looked for export '${camel}', 'default', or 'handle').`
+      `agentproto: adapter '${resolvedPackageName}' does not export an AgentCliHandle (looked for export '${camel}', 'default', or 'handle').`
     );
   }
-  return { slug, handle: candidate, source: "npm", packageName };
+  return { slug, handle: candidate, source: "npm", packageName: resolvedPackageName };
 }
 async function listInstalledAdapters(opts) {
-  const roots = await collectAgentprotoNamespaceRoots(opts?.searchRoot);
+  const roots = await collectAgentprotoNamespaceRoots();
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const root of roots) {
@@ -1069,6 +1083,7 @@ async function listInstalledAdapters(opts) {
       try {
         const resolved = await resolveAdapter(slug);
         const handle = resolved.handle;
+        const modelsField = handle.models?.allowed;
         const info = {
           slug,
           name: typeof handle.name === "string" ? handle.name : slug,
@@ -1076,7 +1091,9 @@ async function listInstalledAdapters(opts) {
           description: typeof handle.description === "string" ? handle.description : "",
           protocol: typeof handle.protocol === "string" ? handle.protocol : "unknown",
           streaming: !!handle.capabilities?.streaming,
-          packageName: resolved.packageName ?? `@agentproto/adapter-${slug}`
+          packageName: resolved.packageName ?? `@agentproto/adapter-${slug}`,
+          commands: Array.isArray(handle.commands) ? handle.commands : [],
+          models: Array.isArray(modelsField) ? modelsField.filter((m) => typeof m === "string") : []
         };
         out.push(info);
       } catch (err) {
@@ -1092,26 +1109,95 @@ async function listInstalledAdapters(opts) {
   return out.sort((a, b) => a.slug.localeCompare(b.slug));
 }
 async function collectAgentprotoNamespaceRoots(start) {
+  const seen = /* @__PURE__ */ new Set();
   const roots = [];
-  let cur = start ?? process.cwd();
   const candidatesAt = (dir) => [
     resolve(dir, "node_modules", "@agentproto"),
     resolve(dir, "node_modules", ".pnpm", "node_modules", "@agentproto")
   ];
-  for (let depth = 0; depth < 16; depth++) {
-    for (const candidate of candidatesAt(cur)) {
-      try {
-        const stat5 = await promises.stat(candidate);
-        if (stat5.isDirectory()) roots.push(candidate);
-      } catch {
+  async function walkUp(from) {
+    let cur = from;
+    for (let depth = 0; depth < 20; depth++) {
+      if (seen.has(cur)) break;
+      seen.add(cur);
+      for (const candidate of candidatesAt(cur)) {
+        try {
+          const s = await promises.stat(candidate);
+          if (s.isDirectory() && !roots.includes(candidate)) roots.push(candidate);
+        } catch {
+        }
       }
+      const parent = resolve(cur, "..");
+      if (parent === cur) break;
+      cur = parent;
     }
-    const parent = resolve(cur, "..");
-    if (parent === cur) break;
-    cur = parent;
+  }
+  await walkUp(process.cwd());
+  try {
+    await walkUp(dirname(fileURLToPath(import.meta.url)));
+  } catch {
   }
   return roots;
 }
+async function listAdaptersWithCatalog(catalog) {
+  const seenSlugs = /* @__PURE__ */ new Set();
+  const out = [];
+  const agentprotoHome = process.env["AGENTPROTO_HOME"] ?? join(homedir(), ".agentproto");
+  async function hasSetupLedger(slug) {
+    try {
+      await promises.access(join(agentprotoHome, "setup", `${slug}.json`));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  for (const entry of catalog) {
+    seenSlugs.add(entry.slug);
+    try {
+      const resolved = await resolveAdapter(entry.slug);
+      const handle = resolved.handle;
+      const setupSteps = Array.isArray(handle.setup) ? handle.setup : [];
+      const ledgerPresent = await hasSetupLedger(entry.slug);
+      const status = setupSteps.length === 0 || ledgerPresent ? "ready" : "available";
+      const catalogModels = handle.models?.allowed;
+      out.push({
+        slug: entry.slug,
+        name: typeof handle.name === "string" ? handle.name : entry.name,
+        version: typeof handle.version === "string" ? handle.version : "?",
+        description: typeof handle.description === "string" ? handle.description : entry.description,
+        protocol: typeof handle.protocol === "string" ? handle.protocol : "unknown",
+        streaming: !!handle.capabilities?.streaming,
+        packageName: resolved.packageName ?? entry.packageName,
+        commands: Array.isArray(handle.commands) ? handle.commands : [],
+        models: Array.isArray(catalogModels) ? catalogModels.filter((m) => typeof m === "string") : [],
+        status,
+        hint: entry.hint
+      });
+    } catch {
+      out.push({
+        slug: entry.slug,
+        name: entry.name,
+        version: "not installed",
+        description: entry.description,
+        protocol: "unknown",
+        streaming: false,
+        packageName: entry.packageName,
+        commands: [],
+        models: [],
+        status: "supported",
+        hint: entry.hint
+      });
+    }
+  }
+  const installed = await listInstalledAdapters();
+  for (const info of installed) {
+    if (seenSlugs.has(info.slug)) continue;
+    seenSlugs.add(info.slug);
+    const ledgerPresent = await hasSetupLedger(info.slug);
+    out.push({ ...info, status: ledgerPresent ? "ready" : "available" });
+  }
+  return out;
+}
 async function runSetup(opts) {
   const steps = opts.handle.setup ?? [];
   if (steps.length === 0) {
@@ -1285,10 +1371,10 @@ async function runExternalStep(step, ledger, head) {
 `);
   const opener = platform() === "darwin" ? "open" : platform() === "win32" ? "cmd" : "xdg-open";
   const args = platform() === "win32" ? ["/c", "start", step.url] : [step.url];
-  await new Promise((resolve9) => {
+  await new Promise((resolve10) => {
     const child = spawn(opener, args, { stdio: "ignore", detached: true });
-    child.once("error", () => resolve9());
-    child.once("spawn", () => resolve9());
+    child.once("error", () => resolve10());
+    child.once("spawn", () => resolve10());
   });
   let value = "";
   if (step.callback?.param) {
@@ -1361,7 +1447,7 @@ async function promptString(question, opts) {
     process.stdin.setRawMode?.(true);
     let buf = "";
     process.stdout.write(prompt);
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       const onData = (chunk) => {
         for (const code of chunk) {
           if (code === 13 || code === 10) {
@@ -1369,7 +1455,7 @@ async function promptString(question, opts) {
             process.stdin.setRawMode?.(false);
             process.stdout.write("\n");
             rl.close();
-            resolve9(buf || opts.defaultValue || "");
+            resolve10(buf || opts.defaultValue || "");
             return;
           }
           if (code === 3) {
@@ -1451,7 +1537,7 @@ async function resolveSelectOptions(options) {
   });
 }
 async function runShellCapturing(cmd, opts) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const child = spawn("bash", ["-lc", cmd], {
       stdio: opts.interactive ? "inherit" : ["ignore", "pipe", "pipe"]
     });
@@ -1469,11 +1555,11 @@ async function runShellCapturing(cmd, opts) {
     }, opts.timeoutMs);
     child.once("error", () => {
       clearTimeout(timer);
-      resolve9({ exitCode: 127, stdout, stderr: stderr || "spawn error" });
+      resolve10({ exitCode: 127, stdout, stderr: stderr || "spawn error" });
     });
     child.once("exit", (code) => {
       clearTimeout(timer);
-      resolve9({ exitCode: code ?? 0, stdout, stderr });
+      resolve10({ exitCode: code ?? 0, stdout, stderr });
     });
   });
 }
@@ -2108,7 +2194,7 @@ async function runDownloadInstaller(opts) {
     }
     if (extractCode !== 0) return extractCode;
     const srcBin = join(extractDir, opts.extractBin);
-    const binDir = process.env["AGENTPROTO_BIN_DIR"] ?? join(homedir5(), ".local", "bin");
+    const binDir = process.env["AGENTPROTO_BIN_DIR"] ?? join(homedir6(), ".local", "bin");
     await mkdir(binDir, { recursive: true });
     const destBin = join(binDir, opts.extractBin.split("/").pop());
     const cpCode = await spawnInherit("cp", ["-p", srcBin, destBin]);
@@ -2134,19 +2220,19 @@ async function runDownloadInstaller(opts) {
     });
   }
 }
-function homedir5() {
+function homedir6() {
   return process.env["HOME"] ?? process.env["USERPROFILE"] ?? "/";
 }
 function spawnInherit(cmd, argv) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const child = spawn(cmd, argv, { stdio: "inherit" });
     child.once("error", reject);
-    child.once("exit", (code) => resolve9(code ?? 0));
+    child.once("exit", (code) => resolve10(code ?? 0));
   });
 }
 async function runVersionCheck(check) {
   if (!check) return { ok: false, message: "no version_check declared" };
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const child = spawn("bash", ["-lc", check.cmd], {
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -2154,19 +2240,19 @@ async function runVersionCheck(check) {
     child.stdout.on("data", (c) => {
       buf += c.toString("utf8");
     });
-    child.once("error", () => resolve9({ ok: false, message: "check failed" }));
+    child.once("error", () => resolve10({ ok: false, message: "check failed" }));
     child.once("exit", (code) => {
       if (code !== 0) {
-        resolve9({ ok: false, message: `check exited ${code}` });
+        resolve10({ ok: false, message: `check exited ${code}` });
         return;
       }
       const re = new RegExp(check.parse);
       const m = buf.match(re);
       if (!m || !m[1]) {
-        resolve9({ ok: false, message: "could not parse version" });
+        resolve10({ ok: false, message: "could not parse version" });
         return;
       }
-      resolve9({ ok: true, message: `version ${m[1]}` });
+      resolve10({ ok: true, message: `version ${m[1]}` });
     });
   });
 }
@@ -3017,6 +3103,7 @@ var FileSubstrate = class {
   constructor(opts) {
     this.opts = opts;
   }
+  opts;
   kind = "file";
   async append(input2) {
     const timestamp = input2.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
@@ -3142,6 +3229,7 @@ var FileStateStore = class {
   constructor(opts) {
     this.opts = opts;
   }
+  opts;
   kind = "fs";
   async read(participantId) {
     const path = this.pathFor(participantId);
@@ -3177,10 +3265,84 @@ async function ensureDir3(dir) {
 function isNotFound2(err) {
   return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
+function spawnWithStdin(opts) {
+  const {
+    command,
+    args = [],
+    stdin,
+    cwd,
+    timeoutMs = 9e4,
+    signal,
+    killSignal = "SIGTERM"
+  } = opts;
+  return new Promise((resolve10, reject) => {
+    if (signal?.aborted) {
+      reject(new Error(`${command} aborted before start`));
+      return;
+    }
+    const child = spawn(command, [...args], {
+      stdio: ["pipe", "pipe", "pipe"],
+      ...cwd ? { cwd } : {}
+    });
+    let out = "";
+    let err = "";
+    let settled = false;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      fn();
+    };
+    const onAbort = () => {
+      child.kill(killSignal);
+      finish(() => reject(new Error(`${command} aborted`)));
+    };
+    const timer = setTimeout(() => {
+      child.kill(killSignal);
+      finish(() => reject(new Error(`${command} timed out after ${timeoutMs}ms`)));
+    }, timeoutMs);
+    signal?.addEventListener("abort", onAbort);
+    child.stdout.on("data", (d) => out += d);
+    child.stderr.on("data", (d) => err += d);
+    child.on(
+      "error",
+      (e) => finish(() => reject(new Error(`${command} not runnable: ${e.message}`)))
+    );
+    child.on(
+      "close",
+      (code) => finish(() => {
+        if (code === 0) resolve10(out);
+        else
+          reject(
+            new Error(`${command} exited with code ${code}: ${err.trim().slice(0, 200) || "(no stderr)"}`)
+          );
+      })
+    );
+    child.stdin.on("error", () => {
+    });
+    child.stdin.write(stdin);
+    child.stdin.end();
+  });
+}
+function parseClaudeJsonOutput(stdout) {
+  try {
+    const parsed = JSON.parse(stdout);
+    if (typeof parsed === "object" && parsed !== null && "result" in parsed && typeof parsed.result === "string") {
+      return parsed.result;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// ../agent-runtime/dist/adapters/participant-agent-cli.mjs
 var AgentCliParticipant = class {
   constructor(opts) {
     this.opts = opts;
   }
+  opts;
   kind = "agent-cli";
   async executeTurn(input2) {
     const prompt = await assemblePrompt(input2);
@@ -3232,58 +3394,6 @@ function looksLikeRoleFile(s) {
   const lower = s.toLowerCase();
   return ROLE_FILE_EXTENSIONS.some((ext) => lower.endsWith(ext));
 }
-async function spawnWithStdin(args) {
-  return new Promise((resolveP, rejectP) => {
-    const proc = spawn(args.command, [...args.args], {
-      cwd: args.cwd,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    const onAbort = () => proc.kill("SIGTERM");
-    args.signal?.addEventListener("abort", onAbort);
-    const timer = setTimeout(() => {
-      proc.kill("SIGTERM");
-    }, args.timeoutMs);
-    proc.stdout.on("data", (chunk) => {
-      stdout += chunk.toString("utf8");
-    });
-    proc.stderr.on("data", (chunk) => {
-      stderr += chunk.toString("utf8");
-    });
-    proc.on("error", (err) => {
-      clearTimeout(timer);
-      args.signal?.removeEventListener("abort", onAbort);
-      rejectP(err);
-    });
-    proc.on("close", (code) => {
-      clearTimeout(timer);
-      args.signal?.removeEventListener("abort", onAbort);
-      if (code === 0) {
-        resolveP(stdout);
-        return;
-      }
-      rejectP(
-        new Error(
-          `agent-cli participant "${args.command}" exited with code ${code}: ${stderr.trim() || "(no stderr)"}`
-        )
-      );
-    });
-    proc.stdin.write(args.stdin);
-    proc.stdin.end();
-  });
-}
-function parseClaudeJsonOutput(stdout) {
-  try {
-    const parsed = JSON.parse(stdout);
-    if (typeof parsed === "object" && parsed !== null && "result" in parsed && typeof parsed.result === "string") {
-      return parsed.result;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
 
 // src/registry/builtins.ts
 function registerBuiltins() {
@@ -3700,6 +3810,48 @@ function normalizeConfig(parsed) {
   if (active !== void 0) out.active = active;
   return out;
 }
+var IMPORTED_MCPS_PATH = () => resolve(homedir(), ".agentproto", "imported-mcps.json");
+var IMPORTED_MCPS_VERSION = 1;
+var EMPTY = {
+  version: IMPORTED_MCPS_VERSION,
+  imports: []
+};
+async function loadImportedMcps(path = IMPORTED_MCPS_PATH()) {
+  let raw;
+  try {
+    raw = await promises.readFile(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return EMPTY;
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `agentproto: ${path} is not valid JSON (${err instanceof Error ? err.message : String(err)}). Delete or fix manually.`
+    );
+  }
+  return normalize(parsed);
+}
+function normalize(parsed) {
+  if (!parsed || typeof parsed !== "object") return EMPTY;
+  const obj = parsed;
+  const imports = [];
+  if (Array.isArray(obj.imports)) {
+    for (const entry of obj.imports) {
+      if (!entry || typeof entry !== "object") continue;
+      const e = entry;
+      const id = typeof e.id === "string" ? e.id : "";
+      const alias = typeof e.alias === "string" ? e.alias : id;
+      const addedAt = typeof e.addedAt === "string" ? e.addedAt : (/* @__PURE__ */ new Date()).toISOString();
+      const snapshot = e.snapshot;
+      if (!id || !snapshot) continue;
+      imports.push({ id, alias, addedAt, snapshot });
+    }
+  }
+  return { version: IMPORTED_MCPS_VERSION, imports };
+}
 
 // ../define-doctype/dist/index.mjs
 var DEFAULT_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{1,79}$/;
@@ -3835,7 +3987,7 @@ function createVerbs(spec) {
     }
     return { path, handle: newHandle, rendered };
   }
-  async function resolve9(block, ctx = {}) {
+  async function resolve10(block, ctx = {}) {
     if ("inline" in block) {
       return spec.define(block.inline);
     }
@@ -3861,7 +4013,7 @@ function createVerbs(spec) {
   async function deleteFn(path) {
     await rm(path, { force: true });
   }
-  return { create, load, list, update, resolve: resolve9, delete: deleteFn };
+  return { create, load, list, update, resolve: resolve10, delete: deleteFn };
 }
 function defaultBody(spec, frontmatter) {
   const id = typeof frontmatter.name === "string" ? frontmatter.name : typeof frontmatter.id === "string" ? frontmatter.id : typeof frontmatter.slug === "string" ? frontmatter.slug : spec.name;
@@ -3999,8 +4151,374 @@ function resolvePathTemplate(template, handle, doctypeSlug) {
   const identity = typeof handle.id === "string" && handle.id || typeof handle.slug === "string" && handle.slug || typeof handle.name === "string" && handle.name || "unknown";
   return template.replace(/<slug>/g, identity).replace(/<DOCTYPE>/g, doctypeSlug.toUpperCase());
 }
+var agentFrontmatterSchema = z.object({ "schema": z.literal("agent/v1"), "id": z.string().regex(new RegExp("^[a-z0-9@][a-z0-9.@/_-]*$")).min(2).max(80).describe("Machine identifier. Optional @<owner>/ prefix. Unique within the registry that hosts the agent."), "description": z.string().min(1).max(2e3).describe("One-paragraph purpose."), "version": z.string().regex(new RegExp("^\\d+\\.\\d+\\.\\d+(?:[-+][\\w.\\-]+)?$")).describe("Spec version of THIS file.").default("1.0.0"), "extends": z.any().describe("Parent AGENT this extends. Inherits all fields; child overrides win.").optional(), "model": z.any().describe("The brain \u2014 provider/model id string or structured ref."), "identity": z.any().describe("AIP-23 identity ref. Defaults to host policy.").optional(), "persona": z.any().describe("AIP-25 persona ref.").optional(), "runner": z.any().describe("AIP-17 runtime engine ref.").optional(), "tools": z.array(z.any()).describe("AIP-14 tool refs.").default([]), "actions": z.object({ "granted": z.array(z.any()).default([]) }).strict().describe("Explicit action allow-list. POLICY checks union of this + tools' implements.").optional(), "skills": z.array(z.any()).describe("AIP-3 skill refs.").default([]), "workflows": z.array(z.any()).describe("AIP-15 workflow refs.").default([]), "routines": z.array(z.any()).describe("AIP-41 routine refs that auto-fire this agent.").default([]), "delegates_to": z.array(z.any()).describe("Sub-agents this agent may dispatch to (council pattern, AIP-24).").default([]), "memory": z.any().describe("Memory configuration.").optional(), "governance": z.any().describe("AIP-7 governance binding.").optional(), "policy": z.any().describe("AIP-38 POLICY binding.").optional(), "traits": z.record(z.string(), z.number().gte(0).lte(10)).describe("Free-form numeric trait scores (0-10).").default({}), "autonomy": z.number().int().gte(0).lte(10).describe("How much the agent acts vs asks. 0 = always asks, 10 = full autonomy.").default(5), "boundaries": z.array(z.string().min(1)).describe("Hard rules the agent MUST decline / escalate. Surfaced into system prompt.").default([]), "on": z.record(z.string(), z.any().superRefine((x, ctx) => {
+  const schemas = [z.any(), z.array(z.any())];
+  const { errors, failed } = schemas.reduce(
+    ({ errors: errors2, failed: failed2 }, schema) => ((result) => result.error ? {
+      errors: [...errors2, ...result.error.issues],
+      failed: failed2 + 1
+    } : { errors: errors2, failed: failed2 })(
+      schema.safeParse(x)
+    ),
+    { errors: [], failed: 0 }
+  );
+  const passed = schemas.length - failed;
+  if (passed !== 1) {
+    ctx.addIssue(errors.length ? {
+      path: [],
+      code: "invalid_union",
+      errors: [errors],
+      message: "Invalid input: Should pass single schema. Passed " + passed
+    } : {
+      path: [],
+      code: "custom",
+      errors: [errors],
+      message: "Invalid input: Should pass single schema. Passed " + passed
+    });
+  }
+})).describe("Lifecycle hooks. AIP-37 event name -> action-ref(s) to invoke.").default({}), "publish": z.object({ "visibility": z.enum(["private", "unlisted", "public"]).default("private"), "registry": z.string().optional() }).strict().default({ "visibility": "private" }), "tags": z.array(z.string()).default([]), "metadata": z.record(z.string(), z.any()).optional() }).strict().describe("Validates the YAML frontmatter portion of an AIP-42 AGENT.md manifest. Composes identity, persona, model, tools, actions, skills, workflows, runner, memory, governance, policy, routines into a single runnable definition.");
+var defineAgent = createDoctype({
+  aip: 42,
+  name: "agent",
+  // AIP-42 ids accept an optional `@<owner>/` prefix for namespacing
+  // across registries (e.g. `@agentik/writer`). Bare ids stay valid.
+  idPattern: /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]{0,79}$/,
+  validate(def) {
+    const result = agentFrontmatterSchema.safeParse(def);
+    if (!result.success) {
+      throw new Error(
+        `defineAgent (AIP-42): ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+      );
+    }
+  },
+  build(def) {
+    return { ...def };
+  }
+});
+function parseAgentManifest(source) {
+  const parsed = matter3(source);
+  if (Object.keys(parsed.data).length === 0) {
+    throw new Error("parseAgentManifest: missing or empty frontmatter");
+  }
+  const result = agentFrontmatterSchema.safeParse(parsed.data);
+  if (!result.success) {
+    throw new Error(
+      `parseAgentManifest: invalid frontmatter \u2014 ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+  }
+  return { frontmatter: result.data, body: parsed.content };
+}
 
-// ../mcp-server/dist/index.mjs
+// ../agent/dist/index.mjs
+var agentSpec = {
+  name: "agent",
+  aip: 42,
+  schemaLiteral: "agent/v1",
+  pathOf: (h) => `.agents/${h.id}/AGENT.md`,
+  define: defineAgent,
+  parse: (source) => {
+    const m = parseAgentManifest(source);
+    return {
+      frontmatter: m.frontmatter,
+      body: m.body
+    };
+  }
+};
+var agentVerbs = createVerbs(agentSpec);
+var PROVIDER_KINDS = [
+  "cli",
+  "http",
+  "mcp",
+  "sdk",
+  "builtin"
+];
+var constructTool = createDoctype({
+  aip: 14,
+  name: "tool",
+  validate(def) {
+    if ("execute" in def) {
+      throw new Error(
+        `defineTool: id='${def.id}' carries an 'execute' property. Bodies live on AIP-30 PROVIDER manifests, not on the TOOL contract. See https://agentproto.sh/docs/aip-30 for migration.`
+      );
+    }
+  },
+  build(def) {
+    return {
+      id: def.id,
+      name: def.name ?? def.id,
+      description: def.description,
+      version: def.version,
+      inputSchema: def.inputSchema,
+      outputSchema: def.outputSchema,
+      contextSchema: def.contextSchema,
+      mutates: Object.freeze([...def.mutates ?? []]),
+      requires: freezeCapabilities(def.requires),
+      approval: defaultApproval(def.approval, def.mutates),
+      riskLevel: def.riskLevel ?? 0,
+      costClass: def.costClass ?? "trivial",
+      timeoutMs: def.timeoutMs ?? 3e4,
+      retry: def.retry,
+      tags: Object.freeze([...def.tags ?? []]),
+      metadata: Object.freeze({ ...def.metadata ?? {} }),
+      idempotent: def.idempotent ?? false,
+      defaultImplementation: def.defaultImplementation,
+      driverConstraints: freezeProviderConstraints(def.driverConstraints)
+    };
+  }
+});
+function defineTool(definition) {
+  return constructTool(
+    definition
+  );
+}
+function defaultApproval(declared, mutates) {
+  if (declared) return declared;
+  return mutates && mutates.length > 0 ? "on-mutate" : "auto";
+}
+function freezeCapabilities(caps) {
+  return Object.freeze({
+    network: Object.freeze([...caps?.network ?? []]),
+    secrets: Object.freeze([...caps?.secrets ?? []]),
+    tools: Object.freeze([...caps?.tools ?? []])
+  });
+}
+function freezeProviderConstraints(c) {
+  const forbid = (c?.forbid ?? []).filter(
+    (k) => PROVIDER_KINDS.includes(k)
+  );
+  const requireKind = (c?.requireKind ?? []).filter(
+    (k) => PROVIDER_KINDS.includes(k)
+  );
+  return Object.freeze({
+    forbid: Object.freeze(forbid),
+    requireKind: Object.freeze(requireKind)
+  });
+}
+var toolManifestFrontmatterSchema = z.object({
+  schema: z.literal("agentproto/tool/v1").optional(),
+  name: z.string().min(1).max(80),
+  id: z.string().regex(/^[a-z][a-z0-9._-]{1,63}$/),
+  description: z.string().min(1).max(2e3),
+  version: z.string().regex(/^\d+\.\d+\.\d+/),
+  // Optional metadata
+  mutates: z.array(z.string()).optional(),
+  requires: z.object({
+    network: z.array(z.string()).optional(),
+    secrets: z.array(z.string()).optional(),
+    tools: z.array(z.string()).optional()
+  }).optional(),
+  // `ApprovalClass` is `"auto" | "always" | "on-mutate" | \`policy:${string}\``.
+  // z.union widens the regex branch to plain `string` (zod can't express
+  // template literal types), so we use `z.custom` to keep the inferred
+  // type exact — matters because `defineTool` accepts `ApprovalClass`.
+  approval: z.custom(
+    (v) => typeof v === "string" && (v === "auto" || v === "always" || v === "on-mutate" || /^policy:/.test(v)),
+    { message: "expected 'auto' | 'always' | 'on-mutate' | 'policy:<name>'" }
+  ).optional(),
+  risk_level: z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3)]).optional(),
+  cost_class: z.enum(["trivial", "metered", "expensive"]).optional(),
+  timeout_ms: z.number().int().positive().optional(),
+  idempotent: z.boolean().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  // AIP-26 / AIP-17 / AIP-19 references — kept loose; validated by their
+  // respective AIPs' adapters when consumed.
+  code: z.unknown().optional(),
+  run: z.unknown().optional(),
+  runner: z.unknown().optional(),
+  secrets: z.unknown().optional(),
+  network: z.unknown().optional()
+});
+function parseToolManifest(source) {
+  const parsed = matter3(source);
+  if (Object.keys(parsed.data).length === 0) {
+    throw new Error("parseToolManifest: missing or empty frontmatter");
+  }
+  const result = toolManifestFrontmatterSchema.safeParse(parsed.data);
+  if (!result.success) {
+    throw new Error(
+      `parseToolManifest: invalid frontmatter \u2014 ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+  }
+  return { frontmatter: result.data, body: parsed.content };
+}
+var toolSpec = {
+  name: "tool",
+  aip: 14,
+  schemaLiteral: "agentproto/tool/v1",
+  pathOf: (h) => `${h.id}/TOOL.md`,
+  define: (params) => defineTool(params),
+  parse: (source) => {
+    const m = parseToolManifest(source);
+    return {
+      frontmatter: m.frontmatter,
+      body: m.body
+    };
+  }
+};
+var toolVerbs = createVerbs(toolSpec);
+var routineFrontmatterSchema = z.object({ "schema": z.literal("routine/v1"), "id": z.string().regex(new RegExp("^[a-z0-9@][a-z0-9.@/_-]*$")).min(2).max(80).describe("Machine identifier. Lowercase, digits, dashes, dots, optional @owner/ prefix. Unique within the registry that hosts the routine."), "description": z.string().min(1).max(2e3).describe("One-paragraph purpose."), "version": z.string().regex(new RegExp("^\\d+\\.\\d+\\.\\d+(?:[-+][\\w.\\-]+)?$")).describe("Spec version of THIS file.").default("1.0.0"), "schedule": z.any().describe("When the routine fires."), "target": z.any().describe("What the routine invokes when it fires."), "identity": z.any().describe("Identity that owns the routine fire (AIP-23). Defaults to host policy.").optional(), "retry": z.any().describe("Retry behaviour on failure.").optional(), "on_failure": z.any().describe("Where to route failures after retries exhaust.").optional(), "history": z.any().describe("Run history retention.").optional(), "fires_events": z.array(z.string().min(1)).describe("AIP-37 LIFECYCLE event names this routine fires.").default(["routine-triggered", "routine-completed", "routine-failed"]), "enabled": z.boolean().describe("If false, routine registers but does not fire. Useful for staging.").default(true), "tags": z.array(z.string()).describe("Free-form discovery tags.").default([]), "metadata": z.record(z.string(), z.any()).describe("Free-form, namespaced.").optional() }).strict().describe("Validates the YAML frontmatter portion of an AIP-41 ROUTINE.md manifest. Decouples 'when' (schedule) from 'what' (target action/workflow/tool).");
+var defineRoutine = createDoctype({
+  aip: 41,
+  name: "routine",
+  validate(def) {
+    const result = routineFrontmatterSchema.safeParse(def);
+    if (!result.success) {
+      throw new Error(
+        `defineRoutine (AIP-41): ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+      );
+    }
+  },
+  build(def) {
+    return { ...def };
+  }
+});
+function parseRoutineManifest(source) {
+  const parsed = matter3(source);
+  if (Object.keys(parsed.data).length === 0) {
+    throw new Error("parseRoutineManifest: missing or empty frontmatter");
+  }
+  const result = routineFrontmatterSchema.safeParse(parsed.data);
+  if (!result.success) {
+    throw new Error(
+      `parseRoutineManifest: invalid frontmatter \u2014 ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+  }
+  return { frontmatter: result.data, body: parsed.content };
+}
+
+// ../routine/dist/index.mjs
+var routineSpec = {
+  name: "routine",
+  aip: 41,
+  schemaLiteral: "routine/v1",
+  pathOf: (h) => `.routines/${h.id}/ROUTINE.md`,
+  define: defineRoutine,
+  parse: (source) => {
+    const m = parseRoutineManifest(source);
+    return {
+      frontmatter: m.frontmatter,
+      body: m.body
+    };
+  }
+};
+var routineVerbs = createVerbs(routineSpec);
+async function summarizeToolRef(raw, workspace) {
+  if (typeof raw === "string") {
+    return { id: raw, description: "(string ref \u2014 not locally resolved)" };
+  }
+  if (typeof raw !== "object" || raw === null) {
+    return { id: String(raw), description: "(unknown ref shape)" };
+  }
+  const block = raw;
+  if (block.file) {
+    try {
+      const handle = await toolVerbs.resolve(
+        { file: block.file },
+        { baseDir: workspace }
+      );
+      return { id: handle.id, description: handle.description ?? "" };
+    } catch {
+      return { id: block.file, description: "(file ref \u2014 could not load)" };
+    }
+  }
+  if (block.inline) {
+    return {
+      id: String(block.inline.id ?? ""),
+      description: String(block.inline.description ?? "")
+    };
+  }
+  if (block.ref) {
+    return { id: block.ref, description: "(ref \u2014 not locally resolved)" };
+  }
+  return { id: JSON.stringify(raw), description: "(unknown ref shape)" };
+}
+async function summarizeRoutineRef(raw, workspace) {
+  if (typeof raw === "string") {
+    return { id: raw, description: "(string ref \u2014 not locally resolved)" };
+  }
+  if (typeof raw !== "object" || raw === null) {
+    return { id: String(raw), description: "(unknown ref shape)" };
+  }
+  const block = raw;
+  if (block.file) {
+    try {
+      const handle = await routineVerbs.resolve(
+        { file: block.file },
+        { baseDir: workspace }
+      );
+      return { id: handle.id, description: handle.description ?? "" };
+    } catch {
+      return { id: block.file, description: "(file ref \u2014 could not load)" };
+    }
+  }
+  if (block.inline) {
+    return {
+      id: String(block.inline.id ?? ""),
+      description: String(block.inline.description ?? "")
+    };
+  }
+  if (block.ref) {
+    return { id: block.ref, description: "(ref \u2014 not locally resolved)" };
+  }
+  return { id: JSON.stringify(raw), description: "(unknown ref shape)" };
+}
+async function selfInspect(agentId, workspace) {
+  const agentPath = join(workspace, ".agents", agentId, "AGENT.md");
+  let handle;
+  try {
+    const result = await agentVerbs.load(agentPath);
+    handle = result.handle;
+  } catch (err) {
+    const e = new Error(
+      `No AGENT.md found for agent '${agentId}' at '${agentPath}'. Ensure an AGENT.md exists at <workspace>/.agents/${agentId}/AGENT.md.`
+    );
+    e.code = "agent_not_found";
+    throw e;
+  }
+  const rawTools = handle.tools ?? [];
+  const rawRoutines = handle.routines ?? [];
+  const [tools, routines] = await Promise.all([
+    Promise.all(rawTools.map((r) => summarizeToolRef(r, workspace))),
+    Promise.all(rawRoutines.map((r) => summarizeRoutineRef(r, workspace)))
+  ]);
+  return { agentPath, tools, routines };
+}
+function registerSelfInspectTool(server, opts) {
+  server.tool(
+    "self_inspect",
+    "Return this agent's AIP-42 manifest summary (tools + routines) without requiring knowledge of disk paths. Pass the agent's logical `id` (the `id:` field in its AGENT.md frontmatter); the runtime resolves it to `<workspace>/.agents/<agentId>/AGENT.md`. Returns `{ agentPath, tools, routines }` \u2014 each item has at minimum `{ id, description }`. File refs are loaded; string/ref refs are surfaced as-is.",
+    {
+      agentId: z.string().min(1).describe(
+        "The agent's logical id (e.g. 'writer'). Matches the `id:` field in the AGENT.md frontmatter. The runtime resolves this to `<workspace>/.agents/<agentId>/AGENT.md` \u2014 you do not need to know the absolute disk path."
+      )
+    },
+    async ({ agentId }) => {
+      try {
+        const result = await selfInspect(agentId, opts.workspace);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ error: "agent_not_found", message }, null, 2)
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
 async function createMcpServer(opts) {
   const server = new McpServer({
     name: opts.name ?? "agentproto-mcp-server",
@@ -4015,6 +4533,9 @@ async function createMcpServer(opts) {
   for (const spec of allSpecs) {
     registerVerbs(server, spec, anchor);
   }
+  if (opts.workspace) {
+    registerSelfInspectTool(server, { workspace: opts.workspace });
+  }
   return {
     server,
     registered: allSpecs.map((s) => s.name)
@@ -4042,7 +4563,7 @@ function registerVerbs(server, spec, anchor) {
         body,
         dryRun
       });
-      return contentText({
+      return contentText2({
         path: result.path,
         rendered: result.rendered
       });
@@ -4056,7 +4577,7 @@ function registerVerbs(server, spec, anchor) {
     },
     async ({ path }) => {
       const result = await verbs.load(anchor(path));
-      return contentText({ path: result.path, handle: result.handle });
+      return contentText2({ path: result.path, handle: result.handle });
     }
   );
   server.tool(
@@ -4071,7 +4592,7 @@ function registerVerbs(server, spec, anchor) {
     },
     async ({ dir, skipDirs }) => {
       const handles = await verbs.list(anchor(dir), { skipDirs });
-      return contentText({ count: handles.length, handles });
+      return contentText2({ count: handles.length, handles });
     }
   );
   server.tool(
@@ -4091,7 +4612,7 @@ function registerVerbs(server, spec, anchor) {
         (existing) => ({ ...existing, ...patch }),
         { body }
       );
-      return contentText({ path: result.path, rendered: result.rendered });
+      return contentText2({ path: result.path, rendered: result.rendered });
     }
   );
   server.tool(
@@ -4105,14 +4626,16 @@ function registerVerbs(server, spec, anchor) {
         z.object({ inline: z.record(z.string(), z.unknown()) }),
         z.object({ ref: z.string() }),
         z.object({ file: z.string() })
-      ]).describe("The composition block."),
+      ]).describe(
+        'The composition block. Exactly one of: { "inline": {...params} } | { "ref": "@scope/id" } | { "file": "relative/path.md" }. Omitting the wrapping key causes invalid_union.'
+      ),
       baseDir: z.string().optional().describe("Base dir for `file:` references.")
     },
     async ({ block, baseDir }) => {
       const handle = await verbs.resolve(block, {
         baseDir: baseDir ? anchor(baseDir) : void 0
       });
-      return contentText({ handle });
+      return contentText2({ handle });
     }
   );
   server.tool(
@@ -4124,7 +4647,7 @@ function registerVerbs(server, spec, anchor) {
     async ({ path }) => {
       const target = anchor(path);
       await verbs.delete(target);
-      return contentText({ deleted: target });
+      return contentText2({ deleted: target });
     }
   );
 }
@@ -4168,7 +4691,7 @@ async function loadExtensions(workspace, specs) {
   }
   return out;
 }
-function contentText(payload) {
+function contentText2(payload) {
   return {
     content: [
       {
@@ -4270,7 +4793,7 @@ function makeCwdAnchor(workspace) {
   const root = resolve(workspace);
   return (input2) => {
     if (!input2 || input2.length === 0) return root;
-    const candidate = isAbsolute(input2) ? normalize(input2) : normalize(join(root, input2));
+    const candidate = isAbsolute(input2) ? normalize$1(input2) : normalize$1(join(root, input2));
     const rel = relative(root, candidate);
     if (rel.startsWith("..") || isAbsolute(rel)) {
       throw new Error(
@@ -4565,7 +5088,7 @@ function makeAnchor(workspace) {
     if (typeof input2 !== "string" || input2.length === 0) {
       throw new FsPathError("path must be a non-empty string");
     }
-    const candidate = isAbsolute(input2) ? normalize(input2) : normalize(join(root, input2));
+    const candidate = isAbsolute(input2) ? normalize$1(input2) : normalize$1(join(root, input2));
     const rel = relative(root, candidate);
     if (rel.startsWith("..") || isAbsolute(rel)) {
       throw new FsPathError(`path escapes the workspace: '${input2}'`);
@@ -4946,18 +5469,18 @@ function stringifyValues(raw) {
   }
   return out;
 }
-var IMPORTED_MCPS_PATH = () => resolve(homedir(), ".agentproto", "imported-mcps.json");
-var IMPORTED_MCPS_VERSION = 1;
-var EMPTY = {
-  version: IMPORTED_MCPS_VERSION,
+var IMPORTED_MCPS_PATH2 = () => resolve(homedir(), ".agentproto", "imported-mcps.json");
+var IMPORTED_MCPS_VERSION2 = 1;
+var EMPTY2 = {
+  version: IMPORTED_MCPS_VERSION2,
   imports: []
 };
-async function loadImportedMcps(path = IMPORTED_MCPS_PATH()) {
+async function loadImportedMcps2(path = IMPORTED_MCPS_PATH2()) {
   let raw;
   try {
     raw = await promises.readFile(path, "utf8");
   } catch (err) {
-    if (err.code === "ENOENT") return EMPTY;
+    if (err.code === "ENOENT") return EMPTY2;
     throw err;
   }
   let parsed;
@@ -4970,7 +5493,7 @@ async function loadImportedMcps(path = IMPORTED_MCPS_PATH()) {
   }
   return normalize3(parsed);
 }
-async function saveImportedMcps(config, path = IMPORTED_MCPS_PATH()) {
+async function saveImportedMcps(config, path = IMPORTED_MCPS_PATH2()) {
   await promises.mkdir(dirname(path), { recursive: true });
   const tmp = `${path}.tmp.${process.pid}`;
   await promises.writeFile(tmp, JSON.stringify(config, null, 2) + "\n", "utf8");
@@ -4995,7 +5518,7 @@ function removeImport(config, id) {
   return { ...config, imports: config.imports.filter((e) => e.id !== id) };
 }
 function normalize3(parsed) {
-  if (!parsed || typeof parsed !== "object") return EMPTY;
+  if (!parsed || typeof parsed !== "object") return EMPTY2;
   const obj = parsed;
   const imports = [];
   if (Array.isArray(obj.imports)) {
@@ -5010,7 +5533,7 @@ function normalize3(parsed) {
       imports.push({ id, alias, addedAt, snapshot });
     }
   }
-  return { version: IMPORTED_MCPS_VERSION, imports };
+  return { version: IMPORTED_MCPS_VERSION2, imports };
 }
 function registerSessionTools(server, opts) {
   const { registry, resolveAgentAdapter, listAgentAdapters, mcpProxy } = opts;
@@ -5300,7 +5823,7 @@ function registerSessionTools(server, opts) {
     {},
     async () => {
       try {
-        const config = await loadImportedMcps();
+        const config = await loadImportedMcps2();
         return {
           content: [
             { type: "text", text: JSON.stringify(config, null, 2) }
@@ -5345,7 +5868,7 @@ function registerSessionTools(server, opts) {
             isError: true
           };
         }
-        const cfg = await loadImportedMcps();
+        const cfg = await loadImportedMcps2();
         const next = addImport(cfg, {
           snapshot,
           ...input2.alias ? { alias: input2.alias } : {}
@@ -5378,7 +5901,7 @@ function registerSessionTools(server, opts) {
     },
     async (input2) => {
       try {
-        const cfg = await loadImportedMcps();
+        const cfg = await loadImportedMcps2();
         if (!cfg.imports.some((e) => e.id === input2.id)) {
           return {
             content: [
@@ -6260,7 +6783,7 @@ async function startHttpServer(opts) {
           return;
         }
         if (path === "/mcps/imports" && req.method === "GET") {
-          const config = await loadImportedMcps();
+          const config = await loadImportedMcps2();
           res.writeHead(200, { "content-type": "application/json" });
           res.end(JSON.stringify(config));
           return;
@@ -6284,7 +6807,7 @@ async function startHttpServer(opts) {
             );
             return;
           }
-          const cfg = await loadImportedMcps();
+          const cfg = await loadImportedMcps2();
           const next = addImport(cfg, {
             snapshot,
             ...body.alias ? { alias: body.alias } : {}
@@ -6297,7 +6820,7 @@ async function startHttpServer(opts) {
         const importMatch = path.match(/^\/mcps\/imports\/(.+)$/);
         if (importMatch && req.method === "DELETE") {
           const id = decodeURIComponent(importMatch[1] ?? "");
-          const cfg = await loadImportedMcps();
+          const cfg = await loadImportedMcps2();
           if (!cfg.imports.some((e) => e.id === id)) {
             res.writeHead(404, { "content-type": "application/json" });
             res.end(JSON.stringify({ error: "import_not_found", id }));
@@ -7715,13 +8238,13 @@ var McpProxyRegistry = class {
   async ensureCurrent() {
     let mtimeMs = 0;
     try {
-      const st = await promises.stat(IMPORTED_MCPS_PATH());
+      const st = await promises.stat(IMPORTED_MCPS_PATH2());
       mtimeMs = st.mtimeMs;
     } catch {
       mtimeMs = 0;
     }
     if (this.hasReadOnce && mtimeMs === this.lastMtimeMs) return;
-    const config = await loadImportedMcps().catch(() => ({
+    const config = await loadImportedMcps2().catch(() => ({
       version: 1,
       imports: []
     }));
@@ -8290,7 +8813,7 @@ function createWorkspaceFs(opts) {
         "absolute paths are not allowed; use a workspace-relative path"
       );
     }
-    const joined = normalize(join(root, path));
+    const joined = normalize$1(join(root, path));
     const rel = relative(root, joined);
     if (rel.startsWith("..") || isAbsolute(rel)) {
       throw new WorkspacePathError(
@@ -8494,6 +9017,51 @@ async function runBoot(workspace, opts, conversations, events) {
     durationMs: 0
   });
 }
+
+// src/registry/catalog.ts
+var CATALOG = [
+  // ── Agent CLIs ────────────────────────────────────────────────────────
+  {
+    type: "agent-cli",
+    slug: "claude-code",
+    name: "Claude Code",
+    description: "Anthropic's Claude Code via @agentclientprotocol/claude-agent-acp ACP wrapper.",
+    packageName: "@agentproto/adapter-claude-code",
+    hint: "anthropic \xB7 ACP \xB7 resumable"
+  },
+  {
+    type: "agent-cli",
+    slug: "opencode",
+    name: "OpenCode",
+    description: "sst/opencode with first-party ACP mode. Multi-provider: Anthropic, OpenAI, OpenRouter, Groq.",
+    packageName: "@agentproto/adapter-opencode",
+    hint: "multi-provider \xB7 ACP \xB7 resumable"
+  },
+  {
+    type: "agent-cli",
+    slug: "codex",
+    name: "Codex",
+    description: "OpenAI Codex coding agent via Zed's @zed-industries/codex-acp ACP wrapper.",
+    packageName: "@agentproto/adapter-codex",
+    hint: "openai \xB7 ACP \xB7 resumable"
+  },
+  {
+    type: "agent-cli",
+    slug: "hermes",
+    name: "Hermes",
+    description: "Nous Research Hermes agent with skills, sandboxes, and memory plugin surface.",
+    packageName: "@agentproto/adapter-hermes",
+    hint: "nous \xB7 ACP \xB7 sub-agents"
+  },
+  {
+    type: "agent-cli",
+    slug: "openclaw",
+    name: "OpenClaw",
+    description: "OpenClaw coding-agent platform with native ACP bridge and plugin surface.",
+    packageName: "@agentproto/adapter-openclaw",
+    hint: "gateway \xB7 ACP \xB7 plugins"
+  }
+];
 async function runServe(args) {
   const { values } = parseArgs({
     args: [...args],
@@ -8600,10 +9168,11 @@ async function runServe(args) {
       const adapter = await resolveAdapter(slug);
       const runtime = createAgentCliRuntime(adapter.handle);
       return {
-        async startSession({ cwd, resumeSessionId }) {
+        async startSession({ cwd, resumeSessionId, model }) {
           return runtime.start({
             cwd,
-            ...resumeSessionId ? { resumeSessionId } : {}
+            ...resumeSessionId ? { resumeSessionId } : {},
+            ...model ? { config: { options: { model } } } : {}
           });
         },
         commandPreview: `${adapter.handle.bin} ${(adapter.handle.bin_args ?? []).join(" ")}`.trim()
@@ -8622,15 +9191,15 @@ async function runServe(args) {
       workspace: opts.workspace,
       port: opts.port,
       bind: opts.bind,
-      specs: [],
+      specs: [driverSpec],
       name: "agentproto-serve",
       // BOOT.md is silly for a tunnel daemon — skip it.
       boot: false,
       resolveAgentAdapter,
       // Discovery for UIs / operators — `GET /adapters` + `list_adapters`
-      // MCP tool. Walks node_modules @agentproto/adapter-* on each call;
-      // cheap enough that we don't bother caching here.
-      listAgentAdapters: listInstalledAdapters,
+      // MCP tool. Starts from the bundled catalog so known adapters always
+      // appear (with status "supported") even when not yet installed.
+      listAgentAdapters: () => listAdaptersWithCatalog(CATALOG),
       ...spawnPty ? { spawnPty } : {},
       ...opts.allowedOrigins ? { allowedOrigins: opts.allowedOrigins } : {},
       ...opts.strictOrigins ? { strictOrigins: true } : {}
@@ -8642,6 +9211,10 @@ async function runServe(args) {
     );
     return 1;
   }
+  const installedAdapterSlugs = await listAdaptersWithCatalog(CATALOG).then((list) => list.filter((a) => a.status !== "supported").map((a) => a.slug)).catch(() => []);
+  const announcedTools = [
+    .../* @__PURE__ */ new Set([...gateway.registered, ...installedAdapterSlugs])
+  ];
   printBootBanner({
     url: gateway.url,
     workspace: gateway.workspace,
@@ -8699,8 +9272,8 @@ ${color.dim}\u2500\u2500 shutting down (${signal}) \u2500\u2500${color.reset}
         AGENTPROTO_DAEMON_TOKEN: gateway.token
       }
     });
-    await new Promise((resolve9) => {
-      child.once("exit", () => resolve9());
+    await new Promise((resolve10) => {
+      child.once("exit", () => resolve10());
       aborter.signal.addEventListener("abort", () => {
         try {
           child.kill("SIGTERM");
@@ -8720,8 +9293,8 @@ ${color.dim}\u2500\u2500 shutting down (${signal}) \u2500\u2500${color.reset}
       `${color.dim}Press Ctrl-C to stop.${color.reset}
 `
     );
-    await new Promise((resolve9) => {
-      aborter.signal.addEventListener("abort", () => resolve9());
+    await new Promise((resolve10) => {
+      aborter.signal.addEventListener("abort", () => resolve10());
     });
     return 0;
   }
@@ -8734,7 +9307,14 @@ ${color.dim}\u2500\u2500 shutting down (${signal}) \u2500\u2500${color.reset}
   const reconnectState = { immediate: false };
   while (!aborter.signal.aborted) {
     try {
-      await runOneTunnel(opts, gateway, spawnPty, aborter.signal, reconnectState);
+      await runOneTunnel(
+        opts,
+        gateway,
+        announcedTools,
+        spawnPty,
+        aborter.signal,
+        reconnectState
+      );
       backoffMs = opts.reconnectMinMs ?? 1e3;
       if (reconnectState.immediate) {
         reconnectState.immediate = false;
@@ -8755,17 +9335,17 @@ ${color.dim}\u2500\u2500 shutting down (${signal}) \u2500\u2500${color.reset}
   }
   return 0;
 }
-async function runOneTunnel(opts, gateway, spawnPty, signal, reconnectState) {
+async function runOneTunnel(opts, gateway, announcedTools, spawnPty, signal, reconnectState) {
   if (!opts.connect) throw new Error("runOneTunnel: --connect not set");
   const headers = {
-    "user-agent": "agentproto/0.1.0-alpha"
+    "user-agent": `agentproto/${"0.1.2"}`
   };
   if (opts.token) headers.authorization = `Bearer ${opts.token}`;
   const ws = new WebSocket2(opts.connect, { headers });
-  await new Promise((resolve9, reject) => {
+  await new Promise((resolve10, reject) => {
     const onOpen = () => {
       ws.off("error", onError);
-      resolve9();
+      resolve10();
     };
     const onError = (err) => {
       ws.off("open", onOpen);
@@ -8796,18 +9376,34 @@ async function runOneTunnel(opts, gateway, spawnPty, signal, reconnectState) {
     label: opts.label,
     pty: spawnPty !== null,
     ...spawnPty ? { spawnPty } : {},
+    // Announce what this daemon serves (doctypes + installed agent adapters)
+    // so a multi-daemon host can enumerate + route by capability.
+    ...announcedTools.length ? { tools: announcedTools } : {},
     // Generic HTTP-relay upstream for tunnel `http_request` frames.
     // Cloud-side callers (e.g. the API's local-daemon filesystem
     // provider) can now route MCP JSON-RPC + any other HTTP through
     // the daemon without needing a public URL. We point at the local
     // gateway since that's where `/mcp`, `/sessions`, `/events` live.
     httpUpstream: gateway.url,
+    // Forward bounds, stated explicitly so they're visible and tunable here
+    // (the local gateway is fast, so the package defaults fit; bump these if
+    // this daemon ever fronts a slower upstream):
+    //  - connect + buffered-body / connect + stream-headers ceiling
+    httpForwardTimeoutMs: DEFAULT_HTTP_FORWARD_TIMEOUT_MS,
+    //  - WS upgrade dial ceiling
+    wsDialTimeoutMs: DEFAULT_WS_DIAL_TIMEOUT_MS,
+    // Bound a streaming forward against a silent upstream: if an SSE/ndjson
+    // stream sends headers then stalls with no bytes for 2 min, end it instead
+    // of holding the reqId open forever. The window resets per chunk, so a
+    // well-behaved stream (events or heartbeat comments) is never cut — only a
+    // genuinely dead upstream trips it.
+    httpStreamIdleTimeoutMs: 12e4,
     // WS forwarding upstream — daemon dials the local gateway's WS
     // endpoints (/sessions/:id/pty, etc) and pipes frames to the host.
     // Used by the cloud tunnel pod so browsers on mobile can attach to
     // interactive PTY sessions even though the daemon is only reachable
     // through the host (not directly).
-    dialUpstreamWs: async ({ url, protocols, headers: headers2 }) => {
+    dialUpstreamWs: async ({ url, protocols, headers: headers2, signal: signal2 }) => {
       const upstreamHeaders = {
         ...headers2
       };
@@ -8819,14 +9415,28 @@ async function runOneTunnel(opts, gateway, spawnPty, signal, reconnectState) {
         } catch {
         }
       }
-      return await new Promise((resolve9, reject) => {
+      return await new Promise((resolve10, reject) => {
         const sock = new WebSocket2(url, protocols ? [...protocols] : void 0, {
           headers: upstreamHeaders
         });
+        const onAbort = () => {
+          sock.off("open", onceOpen);
+          sock.off("error", onceError);
+          sock.off("unexpected-response", onceUnexpected);
+          try {
+            sock.terminate();
+          } catch {
+          }
+          reject(
+            signal2?.reason instanceof Error ? signal2.reason : new Error("ws dial aborted")
+          );
+        };
+        const detachAbort = () => signal2?.removeEventListener("abort", onAbort);
         const onceOpen = () => {
+          detachAbort();
           sock.off("error", onceError);
           sock.off("unexpected-response", onceUnexpected);
-          resolve9({
+          resolve10({
             protocol: sock.protocol ?? "",
             send: (data, sendOpts) => {
               sock.send(data, { binary: sendOpts.binary });
@@ -8853,18 +9463,43 @@ async function runOneTunnel(opts, gateway, spawnPty, signal, reconnectState) {
           });
         };
         const onceError = (err) => {
+          detachAbort();
           sock.off("open", onceOpen);
           reject(err);
         };
         const onceUnexpected = (_req, res) => {
+          detachAbort();
           sock.off("open", onceOpen);
           reject(new Error(`Unexpected server response: ${res.statusCode ?? 0}`));
         };
+        if (signal2) {
+          if (signal2.aborted) {
+            onAbort();
+            return;
+          }
+          signal2.addEventListener("abort", onAbort, { once: true });
+        }
         sock.once("open", onceOpen);
         sock.once("error", onceError);
         sock.once("unexpected-response", onceUnexpected);
       });
     },
+    // Resolve a named WS upstream to a registered import's origin. A host
+    // can watch a tab on an imported capability server (e.g. a browser
+    // daemon) by aliasing the import instead of the default gateway — the
+    // path rides the import's own origin (`http://127.0.0.1:<port>`), the
+    // daemon never accepts a raw origin from the host.
+    resolveWsUpstream: async (alias) => {
+      const cfg = await loadImportedMcps();
+      const entry = cfg.imports.find((e) => e.alias === alias);
+      const url = entry?.snapshot.url;
+      if (!url) return void 0;
+      try {
+        return new URL(url).origin;
+      } catch {
+        return void 0;
+      }
+    },
     // v0 authorize hook: trust the bearer-authenticated host completely.
     // Token possession proves the host was provisioned for this daemon.
     // Per-spawn policy filtering will land alongside the policy.toml.
@@ -8900,31 +9535,31 @@ async function runOneTunnel(opts, gateway, spawnPty, signal, reconnectState) {
       }
     }
   });
-  await new Promise((resolve9) => {
+  await new Promise((resolve10) => {
     const offClose = sink.onClose(() => {
       clearInterval(keepaliveInterval);
       offClose();
-      resolve9();
+      resolve10();
     });
     if (signal.aborted) {
       clearInterval(keepaliveInterval);
-      server.close().finally(() => resolve9());
+      server.close().finally(() => resolve10());
     }
     signal.addEventListener("abort", () => {
       clearInterval(keepaliveInterval);
-      server.close().finally(() => resolve9());
+      server.close().finally(() => resolve10());
     });
   });
   process.stderr.write(`agentproto serve: tunnel closed.
 `);
 }
 function sleep3(ms, signal) {
-  return new Promise((resolve9) => {
-    if (signal.aborted) return resolve9();
-    const timer = setTimeout(resolve9, ms);
+  return new Promise((resolve10) => {
+    if (signal.aborted) return resolve10();
+    const timer = setTimeout(resolve10, ms);
     signal.addEventListener("abort", () => {
       clearTimeout(timer);
-      resolve9();
+      resolve10();
     });
   });
 }
@@ -10384,7 +11019,7 @@ function stripAnsi(s) {
   return s.replace(/\x1b\[[0-9;]*m/g, "");
 }
 function httpDelete(url, token) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const u = new URL(url);
     const lib = u.protocol === "https:" ? https : http;
     const headers = {};
@@ -10400,7 +11035,7 @@ function httpDelete(url, token) {
           return;
         }
         try {
-          resolve9(raw ? JSON.parse(raw) : {});
+          resolve10(raw ? JSON.parse(raw) : {});
         } catch (err) {
           reject(err instanceof Error ? err : new Error(String(err)));
         }
@@ -10967,21 +11602,21 @@ async function runPtyAttach(endpoint, desc, _colour) {
   });
 }
 async function probeDaemonHealth(baseUrl) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     try {
       const u = new URL(`${baseUrl}/health`);
       const lib = u.protocol === "https:" ? https : http;
       const req = lib.get(u, { timeout: 500 }, (res) => {
-        resolve9((res.statusCode ?? 0) >= 200 && (res.statusCode ?? 0) < 300);
+        resolve10((res.statusCode ?? 0) >= 200 && (res.statusCode ?? 0) < 300);
         res.resume();
       });
-      req.on("error", () => resolve9(false));
+      req.on("error", () => resolve10(false));
       req.on("timeout", () => {
         req.destroy();
-        resolve9(false);
+        resolve10(false);
       });
     } catch {
-      resolve9(false);
+      resolve10(false);
     }
   });
 }
@@ -11021,7 +11656,7 @@ async function explain401(endpoint, verb) {
   return lines.join("\n");
 }
 function httpPostJson(url, body, token) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const u = new URL(url);
     const payload = Buffer.from(JSON.stringify(body), "utf8");
     const lib = u.protocol === "https:" ? https : http;
@@ -11044,7 +11679,7 @@ function httpPostJson(url, body, token) {
             return;
           }
           try {
-            resolve9(JSON.parse(raw));
+            resolve10(JSON.parse(raw));
           } catch (err) {
             reject(err instanceof Error ? err : new Error(String(err)));
           }
@@ -11060,7 +11695,7 @@ async function httpGetJson(url) {
   return await httpGetJsonImpl(url);
 }
 function httpGetJsonImpl(url) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const u = new URL(url);
     const lib = u.protocol === "https:" ? https : http;
     lib.get(u, (res) => {
@@ -11073,7 +11708,7 @@ function httpGetJsonImpl(url) {
           return;
         }
         try {
-          resolve9(JSON.parse(body));
+          resolve10(JSON.parse(body));
         } catch (err) {
           reject(err instanceof Error ? err : new Error(String(err)));
         }
@@ -11146,7 +11781,8 @@ async function main(argv) {
   const verbIdx = argv.findIndex((a) => VERBS.has(a));
   if (verbIdx === -1) {
     if (argv.includes("--version") || argv.includes("-v")) {
-      process.stdout.write("agentproto 0.1.0-alpha\n");
+      process.stdout.write(`agentproto ${"0.1.2"}
+`);
       return 0;
     }
     if (argv.includes("--help") || argv.includes("-h") || argv.length === 0) {