@agentproto/cli 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -1,19 +1,21 @@
 import * as childProc from 'child_process';
 import { execFile, spawn } from 'child_process';
 import { createHash, randomUUID, randomBytes } from 'crypto';
-import { mkdtemp, writeFile, chmod, rm, mkdir, readFile, unlink, readdir, stat } from 'fs/promises';
+import { rm, readFile, mkdir, writeFile, readdir, mkdtemp, chmod, unlink, stat } from 'fs/promises';
 import { tmpdir, userInfo, hostname, homedir, platform } from 'os';
-import { resolve, join, dirname, isAbsolute, normalize, relative, basename } from 'path';
+import { isAbsolute, join, dirname, resolve, normalize as normalize$1, relative, basename } from 'path';
 import { promisify, parseArgs } from 'util';
 import { promises, existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
 import { createInterface } from 'readline/promises';
 import { stdout, stdin } from 'process';
 import { createAgentCliRuntime } from '@agentproto/driver-agent-cli';
-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 { z } from 'zod';
 import matter from 'gray-matter';
+import { driverSpec } from '@agentproto/driver';
 import { EventEmitter } from 'events';
 import { createServer } from 'http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
@@ -24,7 +26,7 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 
 /**
- * @agentproto/cli v0.1.0-alpha
+ * @agentproto/cli v0.1.2
  * The `agentproto` binary — install / run / serve AIP-45 agent CLIs.
  */
 
@@ -36,24 +38,37 @@ 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);
@@ -74,6 +89,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,
@@ -81,7 +97,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) {
@@ -97,26 +115,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 stat3 = await promises.stat(candidate);
-        if (stat3.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(start ?? 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) {
@@ -263,10 +350,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((resolve4) => {
+  await new Promise((resolve5) => {
     const child = spawn(opener, args, { stdio: "ignore", detached: true });
-    child.once("error", () => resolve4());
-    child.once("spawn", () => resolve4());
+    child.once("error", () => resolve5());
+    child.once("spawn", () => resolve5());
   });
   let value = "";
   if (step.callback?.param) {
@@ -339,7 +426,7 @@ async function promptString(question, opts) {
     process.stdin.setRawMode?.(true);
     let buf = "";
     process.stdout.write(prompt);
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       const onData = (chunk) => {
         for (const code of chunk) {
           if (code === 13 || code === 10) {
@@ -347,7 +434,7 @@ async function promptString(question, opts) {
             process.stdin.setRawMode?.(false);
             process.stdout.write("\n");
             rl.close();
-            resolve4(buf || opts.defaultValue || "");
+            resolve5(buf || opts.defaultValue || "");
             return;
           }
           if (code === 3) {
@@ -429,7 +516,7 @@ async function resolveSelectOptions(options) {
   });
 }
 async function runShellCapturing(cmd, opts) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const child = spawn("bash", ["-lc", cmd], {
       stdio: opts.interactive ? "inherit" : ["ignore", "pipe", "pipe"]
     });
@@ -447,11 +534,11 @@ async function runShellCapturing(cmd, opts) {
     }, opts.timeoutMs);
     child.once("error", () => {
       clearTimeout(timer);
-      resolve4({ exitCode: 127, stdout, stderr: stderr || "spawn error" });
+      resolve5({ exitCode: 127, stdout, stderr: stderr || "spawn error" });
     });
     child.once("exit", (code) => {
       clearTimeout(timer);
-      resolve4({ exitCode: code ?? 0, stdout, stderr });
+      resolve5({ exitCode: code ?? 0, stdout, stderr });
     });
   });
 }
@@ -1086,7 +1173,7 @@ async function runDownloadInstaller(opts) {
     }
     if (extractCode !== 0) return extractCode;
     const srcBin = join(extractDir, opts.extractBin);
-    const binDir = process.env["AGENTPROTO_BIN_DIR"] ?? join(homedir3(), ".local", "bin");
+    const binDir = process.env["AGENTPROTO_BIN_DIR"] ?? join(homedir4(), ".local", "bin");
     await mkdir(binDir, { recursive: true });
     const destBin = join(binDir, opts.extractBin.split("/").pop());
     const cpCode = await spawnInherit("cp", ["-p", srcBin, destBin]);
@@ -1112,19 +1199,19 @@ async function runDownloadInstaller(opts) {
     });
   }
 }
-function homedir3() {
+function homedir4() {
   return process.env["HOME"] ?? process.env["USERPROFILE"] ?? "/";
 }
 function spawnInherit(cmd, argv) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const child = spawn(cmd, argv, { stdio: "inherit" });
     child.once("error", reject);
-    child.once("exit", (code) => resolve4(code ?? 0));
+    child.once("exit", (code) => resolve5(code ?? 0));
   });
 }
 async function runVersionCheck(check) {
   if (!check) return { ok: false, message: "no version_check declared" };
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const child = spawn("bash", ["-lc", check.cmd], {
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -1132,19 +1219,19 @@ async function runVersionCheck(check) {
     child.stdout.on("data", (c) => {
       buf += c.toString("utf8");
     });
-    child.once("error", () => resolve4({ ok: false, message: "check failed" }));
+    child.once("error", () => resolve5({ ok: false, message: "check failed" }));
     child.once("exit", (code) => {
       if (code !== 0) {
-        resolve4({ ok: false, message: `check exited ${code}` });
+        resolve5({ ok: false, message: `check exited ${code}` });
         return;
       }
       const re = new RegExp(check.parse);
       const m = buf.match(re);
       if (!m || !m[1]) {
-        resolve4({ ok: false, message: "could not parse version" });
+        resolve5({ ok: false, message: "could not parse version" });
         return;
       }
-      resolve4({ ok: true, message: `version ${m[1]}` });
+      resolve5({ ok: true, message: `version ${m[1]}` });
     });
   });
 }
@@ -1456,6 +1543,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}$/;
@@ -1591,7 +1720,7 @@ function createVerbs(spec) {
     }
     return { path, handle: newHandle, rendered };
   }
-  async function resolve4(block, ctx = {}) {
+  async function resolve5(block, ctx = {}) {
     if ("inline" in block) {
       return spec.define(block.inline);
     }
@@ -1617,7 +1746,7 @@ function createVerbs(spec) {
   async function deleteFn(path) {
     await rm(path, { force: true });
   }
-  return { create, load, list, update, resolve: resolve4, delete: deleteFn };
+  return { create, load, list, update, resolve: resolve5, 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;
@@ -1755,8 +1884,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 = matter(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 = matter(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 = matter(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",
@@ -1771,6 +2266,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)
@@ -1798,7 +2296,7 @@ function registerVerbs(server, spec, anchor) {
         body,
         dryRun
       });
-      return contentText({
+      return contentText2({
         path: result.path,
         rendered: result.rendered
       });
@@ -1812,7 +2310,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(
@@ -1827,7 +2325,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(
@@ -1847,7 +2345,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(
@@ -1861,14 +2359,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(
@@ -1880,7 +2380,7 @@ function registerVerbs(server, spec, anchor) {
     async ({ path }) => {
       const target = anchor(path);
       await verbs.delete(target);
-      return contentText({ deleted: target });
+      return contentText2({ deleted: target });
     }
   );
 }
@@ -1924,7 +2424,7 @@ async function loadExtensions(workspace, specs) {
   }
   return out;
 }
-function contentText(payload) {
+function contentText2(payload) {
   return {
     content: [
       {
@@ -2026,7 +2526,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(
@@ -2321,7 +2821,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}'`);
@@ -2702,18 +3202,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;
@@ -2726,7 +3226,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");
@@ -2751,7 +3251,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)) {
@@ -2766,7 +3266,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;
@@ -3056,7 +3556,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) }
@@ -3101,7 +3601,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 } : {}
@@ -3134,7 +3634,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: [
@@ -4016,7 +4516,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;
@@ -4040,7 +4540,7 @@ async function startHttpServer(opts) {
             );
             return;
           }
-          const cfg = await loadImportedMcps();
+          const cfg = await loadImportedMcps2();
           const next = addImport(cfg, {
             snapshot,
             ...body.alias ? { alias: body.alias } : {}
@@ -4053,7 +4553,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 }));
@@ -5471,13 +5971,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: []
     }));
@@ -6046,7 +6546,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(
@@ -6250,6 +6750,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],
@@ -6356,10 +6901,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()
@@ -6378,15 +6924,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 } : {}
@@ -6398,6 +6944,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,
@@ -6455,8 +7005,8 @@ ${color.dim}\u2500\u2500 shutting down (${signal}) \u2500\u2500${color.reset}
         AGENTPROTO_DAEMON_TOKEN: gateway.token
       }
     });
-    await new Promise((resolve4) => {
-      child.once("exit", () => resolve4());
+    await new Promise((resolve5) => {
+      child.once("exit", () => resolve5());
       aborter.signal.addEventListener("abort", () => {
         try {
           child.kill("SIGTERM");
@@ -6476,8 +7026,8 @@ ${color.dim}\u2500\u2500 shutting down (${signal}) \u2500\u2500${color.reset}
       `${color.dim}Press Ctrl-C to stop.${color.reset}
 `
     );
-    await new Promise((resolve4) => {
-      aborter.signal.addEventListener("abort", () => resolve4());
+    await new Promise((resolve5) => {
+      aborter.signal.addEventListener("abort", () => resolve5());
     });
     return 0;
   }
@@ -6490,7 +7040,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;
@@ -6511,17 +7068,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 WebSocket(opts.connect, { headers });
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     const onOpen = () => {
       ws.off("error", onError);
-      resolve4();
+      resolve5();
     };
     const onError = (err) => {
       ws.off("open", onOpen);
@@ -6552,18 +7109,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
       };
@@ -6575,14 +7148,28 @@ async function runOneTunnel(opts, gateway, spawnPty, signal, reconnectState) {
         } catch {
         }
       }
-      return await new Promise((resolve4, reject) => {
+      return await new Promise((resolve5, reject) => {
         const sock = new WebSocket(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);
-          resolve4({
+          resolve5({
             protocol: sock.protocol ?? "",
             send: (data, sendOpts) => {
               sock.send(data, { binary: sendOpts.binary });
@@ -6609,18 +7196,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.
@@ -6656,31 +7268,31 @@ async function runOneTunnel(opts, gateway, spawnPty, signal, reconnectState) {
       }
     }
   });
-  await new Promise((resolve4) => {
+  await new Promise((resolve5) => {
     const offClose = sink.onClose(() => {
       clearInterval(keepaliveInterval);
       offClose();
-      resolve4();
+      resolve5();
     });
     if (signal.aborted) {
       clearInterval(keepaliveInterval);
-      server.close().finally(() => resolve4());
+      server.close().finally(() => resolve5());
     }
     signal.addEventListener("abort", () => {
       clearInterval(keepaliveInterval);
-      server.close().finally(() => resolve4());
+      server.close().finally(() => resolve5());
     });
   });
   process.stderr.write(`agentproto serve: tunnel closed.
 `);
 }
 function sleep(ms, signal) {
-  return new Promise((resolve4) => {
-    if (signal.aborted) return resolve4();
-    const timer = setTimeout(resolve4, ms);
+  return new Promise((resolve5) => {
+    if (signal.aborted) return resolve5();
+    const timer = setTimeout(resolve5, ms);
     signal.addEventListener("abort", () => {
       clearTimeout(timer);
-      resolve4();
+      resolve5();
     });
   });
 }