@agentproto/cli 0.1.0-alpha.8 → 0.1.0-alpha.9

package/dist/cli.mjs

@@ -5,16 +5,18 @@ import { resolve, basename, join, dirname, isAbsolute, normalize, relative } fro
 import * as childProc from 'child_process';
 import { execFile, spawn } from 'child_process';
 import { promisify, parseArgs } from 'util';
-import { unlink, readFile, readdir, writeFile, mkdir, stat, chmod, mkdtemp, rm } from 'fs/promises';
+import { unlink, readFile, chmod, readdir, writeFile, mkdir, stat, mkdtemp, rm, appendFile } from 'fs/promises';
 import { randomUUID, randomBytes, createHash } from 'crypto';
 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 { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import '@modelcontextprotocol/sdk/server/stdio.js';
-import { z } from 'zod';
-import matter from 'gray-matter';
 import { EventEmitter } from 'events';
 import http, { createServer } from 'http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
@@ -114,7 +116,7 @@ __export(daemon_exports, {
 });
 async function runDaemon(args) {
   if (args.includes("--help") || args.includes("-h") || args.length === 0) {
-    process.stdout.write(USAGE5);
+    process.stdout.write(USAGE6);
     return args.length === 0 ? 2 : 0;
   }
   if (platform() !== "darwin") {
@@ -128,9 +130,9 @@ async function runDaemon(args) {
   const rest = args.slice(1);
   switch (sub) {
     case "install":
-      return runInstall2(rest);
+      return runInstall3(rest);
     case "uninstall":
-      return runUninstall();
+      return runUninstall2();
     case "start":
       return runStart2();
     case "stop":
@@ -143,7 +145,7 @@ async function runDaemon(args) {
       process.stderr.write(
         `agentproto daemon: unknown sub-verb "${sub}".
 
-${USAGE5}`
+${USAGE6}`
       );
       return 2;
   }
@@ -162,7 +164,7 @@ function paths() {
     ]
   };
 }
-async function runInstall2(args) {
+async function runInstall3(args) {
   const { values } = parseArgs({
     args: [...args],
     allowPositionals: false,
@@ -226,7 +228,7 @@ ${boot.stderr}
   );
   return 0;
 }
-async function runUninstall() {
+async function runUninstall2() {
   const p = paths();
   const target = `gui/${process.getuid?.() ?? 0}/${LABEL}`;
   const out = await launchctl(["bootout", target]);
@@ -387,7 +389,7 @@ function xmlEscape(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 function launchctl(args) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     const child = spawn("launchctl", args, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -395,9 +397,9 @@ function launchctl(args) {
     child.stderr?.setEncoding("utf8").on("data", (c) => stderr += c);
     child.on(
       "error",
-      (err) => resolve7({ code: 127, stdout, stderr: err.message })
+      (err) => resolve9({ code: 127, stdout, stderr: err.message })
     );
-    child.on("exit", (code) => resolve7({ code: code ?? 1, stdout, stderr }));
+    child.on("exit", (code) => resolve9({ code: code ?? 1, stdout, stderr }));
   });
 }
 function humaniseUptime(ms) {
@@ -410,12 +412,12 @@ function humaniseUptime(ms) {
 function indent(s, prefix) {
   return s.split("\n").map((l) => prefix + l).join("\n");
 }
-var LABEL, USAGE5;
+var LABEL, USAGE6;
 var init_daemon = __esm({
   "src/commands/daemon.ts"() {
     init_config();
     LABEL = "sh.agentproto";
-    USAGE5 = `agentproto daemon \u2014 run agentproto serve as a background service
+    USAGE6 = `agentproto daemon \u2014 run agentproto serve as a background service
 
 Usage:
   agentproto daemon install [--dry-run]   register service + start it (macOS launchd today)
@@ -842,7 +844,7 @@ async function postForm(url, body) {
   return await res.json();
 }
 function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 function formatDuration(ms) {
   if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
@@ -853,16 +855,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((resolve7) => {
+  return new Promise((resolve9) => {
     try {
       const child = spawn(cmd, args, { stdio: "ignore", detached: true });
-      child.once("error", () => resolve7());
+      child.once("error", () => resolve9());
       child.once("spawn", () => {
         child.unref();
-        resolve7();
+        resolve9();
       });
     } catch {
-      resolve7();
+      resolve9();
     }
   });
 }
@@ -991,7 +993,7 @@ async function runEdit() {
   const cfg = await loadConfig();
   await saveConfig(cfg);
   const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     const child = spawn(editor, [CONFIG_FILE_PATH()], {
       stdio: "inherit"
     });
@@ -1000,9 +1002,9 @@ async function runEdit() {
         `agentproto config edit: failed to launch ${editor}: ${err.message}
 `
       );
-      resolve7(1);
+      resolve9(1);
     });
-    child.on("exit", (code) => resolve7(code ?? 0));
+    child.on("exit", (code) => resolve9(code ?? 0));
   });
 }
 function parseValue(raw) {
@@ -1099,8 +1101,8 @@ async function collectAgentprotoNamespaceRoots(start) {
   for (let depth = 0; depth < 16; depth++) {
     for (const candidate of candidatesAt(cur)) {
       try {
-        const stat2 = await promises.stat(candidate);
-        if (stat2.isDirectory()) roots.push(candidate);
+        const stat5 = await promises.stat(candidate);
+        if (stat5.isDirectory()) roots.push(candidate);
       } catch {
       }
     }
@@ -1283,10 +1285,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((resolve7) => {
+  await new Promise((resolve9) => {
     const child = spawn(opener, args, { stdio: "ignore", detached: true });
-    child.once("error", () => resolve7());
-    child.once("spawn", () => resolve7());
+    child.once("error", () => resolve9());
+    child.once("spawn", () => resolve9());
   });
   let value = "";
   if (step.callback?.param) {
@@ -1359,7 +1361,7 @@ async function promptString(question, opts) {
     process.stdin.setRawMode?.(true);
     let buf = "";
     process.stdout.write(prompt);
-    return new Promise((resolve7) => {
+    return new Promise((resolve9) => {
       const onData = (chunk) => {
         for (const code of chunk) {
           if (code === 13 || code === 10) {
@@ -1367,7 +1369,7 @@ async function promptString(question, opts) {
             process.stdin.setRawMode?.(false);
             process.stdout.write("\n");
             rl.close();
-            resolve7(buf || opts.defaultValue || "");
+            resolve9(buf || opts.defaultValue || "");
             return;
           }
           if (code === 3) {
@@ -1449,7 +1451,7 @@ async function resolveSelectOptions(options) {
   });
 }
 async function runShellCapturing(cmd, opts) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     const child = spawn("bash", ["-lc", cmd], {
       stdio: opts.interactive ? "inherit" : ["ignore", "pipe", "pipe"]
     });
@@ -1467,11 +1469,11 @@ async function runShellCapturing(cmd, opts) {
     }, opts.timeoutMs);
     child.once("error", () => {
       clearTimeout(timer);
-      resolve7({ exitCode: 127, stdout, stderr: stderr || "spawn error" });
+      resolve9({ exitCode: 127, stdout, stderr: stderr || "spawn error" });
     });
     child.once("exit", (code) => {
       clearTimeout(timer);
-      resolve7({ exitCode: code ?? 0, stdout, stderr });
+      resolve9({ exitCode: code ?? 0, stdout, stderr });
     });
   });
 }
@@ -1505,9 +1507,315 @@ async function saveLedger(path, ledger) {
   await chmod(path, 384).catch(() => {
   });
 }
+async function runInstallProfile(slug, args) {
+  const { values } = parseArgs({
+    args: [...args],
+    allowPositionals: true,
+    strict: true,
+    options: {
+      force: { type: "boolean", short: "f" },
+      "dry-run": { type: "boolean" },
+      "skip-setup": { type: "boolean" },
+      cwd: { type: "string" },
+      package: { type: "string" }
+    }
+  });
+  if (!slug.startsWith("runtime-profile/")) {
+    process.stderr.write(
+      `agentproto install: expected slug starting with 'runtime-profile/', got '${slug}'.
+`
+    );
+    return 2;
+  }
+  const profileName = slug.slice("runtime-profile/".length);
+  if (!/^[a-z][a-z0-9-]*$/.test(profileName)) {
+    process.stderr.write(
+      `agentproto install: invalid profile name '${profileName}'. Lower-kebab only.
+`
+    );
+    return 2;
+  }
+  let packageName;
+  if (typeof values.package === "string" && values.package) {
+    packageName = values.package;
+  } else {
+    const aliased = await readProfileAlias(profileName);
+    packageName = aliased ?? `@agentproto/runtime-profile-${profileName}`;
+  }
+  let mod;
+  try {
+    mod = await import(packageName);
+  } catch (err) {
+    const cause = err instanceof Error ? err.message : String(err);
+    process.stderr.write(
+      `agentproto install: could not load profile package '${packageName}'. Install it first with: npm i -g ${packageName}
+  cause: ${cause}
+`
+    );
+    return 1;
+  }
+  const filesDir = typeof mod.FILES_DIR === "string" ? mod.FILES_DIR : null;
+  const loadProfileManifest = mod.loadProfileManifest;
+  if (!filesDir || !loadProfileManifest) {
+    process.stderr.write(
+      `agentproto install: profile package '${packageName}' does not export FILES_DIR + loadProfileManifest.
+`
+    );
+    return 1;
+  }
+  const manifest = await loadProfileManifest();
+  const cwd = values.cwd ? resolve(values.cwd) : process.cwd();
+  const dryRun = values["dry-run"] === true;
+  const force = values.force === true;
+  process.stdout.write(
+    `agentproto install ${slug} v${manifest.version} \u2192 ${cwd}
+  ${manifest.description}
+`
+  );
+  const ledgerPath = ledgerPathFor2(profileName);
+  const prevLedger = await loadLedger2(ledgerPath);
+  const newLedger = {
+    slug,
+    version: manifest.version,
+    installedAt: prevLedger?.installedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: []
+  };
+  let applied = 0;
+  let skipped = 0;
+  let failed = 0;
+  for (const entry of manifest.files) {
+    const src = resolve(filesDir, entry.src);
+    const dest = resolve(cwd, entry.dest);
+    const prev = prevLedger?.files.find((f) => f.dest === entry.dest) ?? null;
+    try {
+      const srcBuf = await readFile(src);
+      const result = await applyStrategy({
+        strategy: entry.strategy,
+        srcBuf,
+        dest,
+        prev,
+        force,
+        dryRun
+      });
+      newLedger.files.push({
+        dest: entry.dest,
+        strategy: entry.strategy,
+        hashAfter: result.hashAfter,
+        appliedAt: result.wrote ? (/* @__PURE__ */ new Date()).toISOString() : prev?.appliedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (result.wrote) {
+        applied += 1;
+        process.stdout.write(`  ${result.action.padEnd(10)} ${entry.dest}
+`);
+        if (entry.executable && !dryRun) {
+          await chmod(dest, 493);
+        }
+      } else {
+        skipped += 1;
+        process.stdout.write(`  ${result.action.padEnd(10)} ${entry.dest}
+`);
+      }
+    } catch (err) {
+      failed += 1;
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`  FAIL       ${entry.dest} \u2014 ${msg}
+`);
+    }
+  }
+  if (!dryRun) {
+    await saveLedger2(ledgerPath, newLedger);
+  }
+  process.stdout.write(
+    `agentproto install ${slug}: ${applied} applied, ${skipped} skipped, ${failed} failed${dryRun ? " (dry-run)" : ""}
+`
+  );
+  return failed === 0 ? 0 : 1;
+}
+async function applyStrategy(opts) {
+  const { strategy, srcBuf, dest, prev, force, dryRun } = opts;
+  const destExists = await fileExists(dest);
+  if (strategy === "preserve") {
+    if (destExists) {
+      const currentHash = await hashFile(dest);
+      return { wrote: false, action: "preserve", hashAfter: currentHash };
+    }
+    if (!dryRun) {
+      await ensureDir(dirname(dest));
+      await writeFile(dest, srcBuf);
+    }
+    return { wrote: true, action: "create", hashAfter: sha256(srcBuf) };
+  }
+  if (strategy === "overwrite") {
+    const srcHash = sha256(srcBuf);
+    if (destExists && !force) {
+      const destHash = await hashFile(dest);
+      if (destHash === srcHash) {
+        return { wrote: false, action: "unchanged", hashAfter: destHash };
+      }
+      if (prev && prev.hashAfter !== destHash) {
+        return {
+          wrote: false,
+          action: "user-edit",
+          hashAfter: destHash
+        };
+      }
+    }
+    if (!dryRun) {
+      await ensureDir(dirname(dest));
+      await writeFile(dest, srcBuf);
+    }
+    return {
+      wrote: true,
+      action: destExists ? "update" : "create",
+      hashAfter: srcHash
+    };
+  }
+  if (strategy === "merge-json-deep") {
+    const srcJson = parseJsonOrThrow(srcBuf.toString("utf8"), "src");
+    let merged = srcJson;
+    if (destExists) {
+      const destRaw = await readFile(dest, "utf8");
+      const destJson = parseJsonOrThrow(destRaw, "dest");
+      merged = deepMerge(destJson, srcJson);
+    }
+    const out = `${JSON.stringify(merged, null, 2)}
+`;
+    const outBuf = Buffer.from(out, "utf8");
+    const outHash = sha256(outBuf);
+    if (destExists) {
+      const destHash = await hashFile(dest);
+      if (destHash === outHash) {
+        return { wrote: false, action: "unchanged", hashAfter: destHash };
+      }
+    }
+    if (!dryRun) {
+      await ensureDir(dirname(dest));
+      await writeFile(dest, outBuf);
+    }
+    return {
+      wrote: true,
+      action: destExists ? "merge" : "create",
+      hashAfter: outHash
+    };
+  }
+  if (strategy === "append") {
+    const srcText = srcBuf.toString("utf8");
+    if (destExists) {
+      const destText = await readFile(dest, "utf8");
+      if (destText.includes(srcText)) {
+        return {
+          wrote: false,
+          action: "unchanged",
+          hashAfter: sha256(Buffer.from(destText, "utf8"))
+        };
+      }
+      const out = `${destText.endsWith("\n") ? destText : `${destText}
+`}${srcText}`;
+      const outBuf = Buffer.from(out, "utf8");
+      if (!dryRun) {
+        await ensureDir(dirname(dest));
+        await writeFile(dest, outBuf);
+      }
+      return { wrote: true, action: "append", hashAfter: sha256(outBuf) };
+    }
+    if (!dryRun) {
+      await ensureDir(dirname(dest));
+      await writeFile(dest, srcBuf);
+    }
+    return { wrote: true, action: "create", hashAfter: sha256(srcBuf) };
+  }
+  throw new Error(`Unknown strategy: ${strategy}`);
+}
+function deepMerge(target, source) {
+  if (target && source && typeof target === "object" && typeof source === "object" && !Array.isArray(target) && !Array.isArray(source)) {
+    const out = { ...target };
+    for (const [k, v] of Object.entries(source)) {
+      out[k] = deepMerge(target[k], v);
+    }
+    return out;
+  }
+  if (Array.isArray(target) && Array.isArray(source)) {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const item of [...target, ...source]) {
+      const key = JSON.stringify(item);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(item);
+    }
+    return out;
+  }
+  return source ?? target;
+}
+function parseJsonOrThrow(raw, side) {
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`merge-json-deep ${side} not valid JSON: ${msg}`);
+  }
+}
+function sha256(buf) {
+  return createHash("sha256").update(buf).digest("hex");
+}
+async function hashFile(path) {
+  const buf = await readFile(path);
+  return sha256(buf);
+}
+async function fileExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(dir) {
+  try {
+    await stat(dir);
+  } catch {
+    await mkdir(dir, { recursive: true });
+  }
+}
+function ledgerPathFor2(profileName) {
+  return join(homedir(), ".agentproto", "profiles", `${profileName}.json`);
+}
+async function loadLedger2(path) {
+  try {
+    const raw = await readFile(path, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function saveLedger2(path, ledger) {
+  await ensureDir(dirname(path));
+  await writeFile(path, `${JSON.stringify(ledger, null, 2)}
+`);
+}
+async function readProfileAlias(profileName) {
+  const base = process.env["AGENTPROTO_HOME"] ?? join(homedir(), ".agentproto");
+  const path = join(base, "config.json");
+  try {
+    const raw = await readFile(path, "utf8");
+    const parsed = JSON.parse(raw);
+    const aliased = parsed.profileAliases?.[profileName];
+    return typeof aliased === "string" ? aliased : null;
+  } catch {
+    return null;
+  }
+}
 
 // src/commands/install.ts
 async function runInstall(args) {
+  const slugPeek = args.find((a) => !a.startsWith("-"));
+  if (slugPeek?.startsWith("runtime-profile/")) {
+    return runInstallProfile(
+      slugPeek,
+      args.filter((a) => a !== slugPeek)
+    );
+  }
   const { values, positionals } = parseArgs({
     args: [...args],
     allowPositionals: true,
@@ -1800,7 +2108,7 @@ async function runDownloadInstaller(opts) {
     }
     if (extractCode !== 0) return extractCode;
     const srcBin = join(extractDir, opts.extractBin);
-    const binDir = process.env["AGENTPROTO_BIN_DIR"] ?? join(homedir4(), ".local", "bin");
+    const binDir = process.env["AGENTPROTO_BIN_DIR"] ?? join(homedir5(), ".local", "bin");
     await mkdir(binDir, { recursive: true });
     const destBin = join(binDir, opts.extractBin.split("/").pop());
     const cpCode = await spawnInherit("cp", ["-p", srcBin, destBin]);
@@ -1826,174 +2134,1402 @@ async function runDownloadInstaller(opts) {
     });
   }
 }
-function homedir4() {
+function homedir5() {
   return process.env["HOME"] ?? process.env["USERPROFILE"] ?? "/";
 }
 function spawnInherit(cmd, argv) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve9, reject) => {
     const child = spawn(cmd, argv, { stdio: "inherit" });
     child.once("error", reject);
-    child.once("exit", (code) => resolve7(code ?? 0));
+    child.once("exit", (code) => resolve9(code ?? 0));
   });
 }
 async function runVersionCheck(check) {
   if (!check) return { ok: false, message: "no version_check declared" };
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     const child = spawn("bash", ["-lc", check.cmd], {
       stdio: ["ignore", "pipe", "ignore"]
     });
-    let buf = "";
-    child.stdout.on("data", (c) => {
-      buf += c.toString("utf8");
+    let buf = "";
+    child.stdout.on("data", (c) => {
+      buf += c.toString("utf8");
+    });
+    child.once("error", () => resolve9({ ok: false, message: "check failed" }));
+    child.once("exit", (code) => {
+      if (code !== 0) {
+        resolve9({ 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" });
+        return;
+      }
+      resolve9({ ok: true, message: `version ${m[1]}` });
+    });
+  });
+}
+var PLUGIN_MANIFEST_SCHEMA = "agentproto/plugin/v1";
+var AdapterEntrySchema = z.object({
+  /** The `kind` string the manifest's substrate/dispatcher/etc. block uses. */
+  kind: z.string().min(1),
+  /**
+   * Path to the entry module, relative to the plugin package root.
+   * Resolved via the plugin's `package.json#main`/`exports` (i.e. you
+   * can use a subpath like `./dist/substrates.mjs` or an export name
+   * like `.` if the plugin re-exports everything from its root).
+   */
+  entry: z.string().min(1),
+  /** Named export inside `entry` — the factory function. */
+  export: z.string().min(1),
+  /** Free-form description; shown by `agentproto plugins show`. */
+  description: z.string().optional()
+}).loose();
+var SubstrateEntrySchema = AdapterEntrySchema.extend({
+  /**
+   * Free-form capability tags. Not gated by the kernel yet, but
+   * surfaced by `agentproto plugins show` so users can see what the
+   * substrate claims to support (mentions, reactions, visibility, …).
+   */
+  capabilities: z.array(z.string()).optional()
+});
+var PluginManifestSchema = z.object({
+  schema: z.literal(PLUGIN_MANIFEST_SCHEMA),
+  substrates: z.array(SubstrateEntrySchema).default([]),
+  dispatchers: z.array(AdapterEntrySchema).default([]),
+  executors: z.array(AdapterEntrySchema).default([]),
+  stateStores: z.array(AdapterEntrySchema).default([])
+}).loose();
+
+// src/registry/runtime.ts
+var substrates = /* @__PURE__ */ new Map();
+var dispatchers = /* @__PURE__ */ new Map();
+var executors = /* @__PURE__ */ new Map();
+var stateStores = /* @__PURE__ */ new Map();
+function registerSubstrate(kind, factory) {
+  substrates.set(kind, factory);
+}
+function registerDispatcher(kind, factory) {
+  dispatchers.set(kind, factory);
+}
+function registerExecutor(kind, factory) {
+  executors.set(kind, factory);
+}
+function registerStateStore(kind, factory) {
+  stateStores.set(kind, factory);
+}
+function getSubstrateFactory(kind) {
+  return substrates.get(kind);
+}
+function getDispatcherFactory(kind) {
+  return dispatchers.get(kind);
+}
+function getExecutorFactory(kind) {
+  return executors.get(kind);
+}
+function getStateStoreFactory(kind) {
+  return stateStores.get(kind);
+}
+function listRegisteredKinds() {
+  return {
+    substrates: [...substrates.keys()],
+    dispatchers: [...dispatchers.keys()],
+    executors: [...executors.keys()],
+    stateStores: [...stateStores.keys()]
+  };
+}
+
+// src/registry/manifest-loader.ts
+async function loadPluginFromManifest(pluginId) {
+  const result = await readPluginManifest(pluginId);
+  if (!result) return null;
+  const { manifest, packageRoot } = result;
+  for (const sub of manifest.substrates) {
+    const factory = await importFactory(
+      packageRoot,
+      pluginId,
+      sub.entry,
+      sub.export
+    );
+    registerSubstrate(sub.kind, factory);
+  }
+  for (const dis of manifest.dispatchers) {
+    const factory = await importFactory(
+      packageRoot,
+      pluginId,
+      dis.entry,
+      dis.export
+    );
+    registerDispatcher(dis.kind, factory);
+  }
+  for (const exe of manifest.executors) {
+    const factory = await importFactory(
+      packageRoot,
+      pluginId,
+      exe.entry,
+      exe.export
+    );
+    registerExecutor(exe.kind, factory);
+  }
+  for (const st of manifest.stateStores) {
+    const factory = await importFactory(
+      packageRoot,
+      pluginId,
+      st.entry,
+      st.export
+    );
+    registerStateStore(st.kind, factory);
+  }
+  return manifest;
+}
+async function readPluginManifest(pluginId) {
+  const packageJsonPath = resolvePluginPackageJson(pluginId);
+  if (!packageJsonPath) return null;
+  const packageRoot = dirname(packageJsonPath);
+  const standalonePath = join(packageRoot, "agentproto.json");
+  const standalone = await readJsonIfExists(standalonePath);
+  if (standalone !== void 0) {
+    return {
+      manifest: PluginManifestSchema.parse(standalone),
+      packageRoot
+    };
+  }
+  const pkgJson = await readJsonIfExists(packageJsonPath);
+  if (pkgJson && typeof pkgJson === "object" && pkgJson.agentproto) {
+    return {
+      manifest: PluginManifestSchema.parse(pkgJson.agentproto),
+      packageRoot
+    };
+  }
+  return null;
+}
+async function importFactory(packageRoot, pluginId, entry, exportName) {
+  const abs = entry.startsWith(".") ? join(packageRoot, entry) : entry;
+  const url = entry.startsWith(".") ? pathToFileURL(abs).href : entry;
+  const mod = await import(url);
+  const exported = mod[exportName];
+  if (typeof exported !== "function") {
+    throw new Error(
+      `agentproto plugin '${pluginId}': manifest entry '${entry}' has no callable export '${exportName}' (got ${typeof exported}).`
+    );
+  }
+  return exported;
+}
+function resolvePluginPackageJson(pluginId) {
+  const candidates = [
+    import.meta.url,
+    pathToFileURL(join(process.cwd(), "package.json")).href
+  ];
+  for (const root of candidates) {
+    try {
+      return createRequire(root).resolve(`${pluginId}/package.json`);
+    } catch {
+    }
+  }
+  return null;
+}
+async function readJsonIfExists(path) {
+  try {
+    const raw = await readFile(path, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  }
+}
+
+// src/commands/plugins.ts
+var USAGE3 = `agentproto plugins \u2014 manage runtime plugins
+
+Usage:
+  agentproto plugins list                  Show enabled plugins + adapters
+  agentproto plugins show <pkg>            Print a plugin's manifest
+  agentproto plugins install <pkg>         npm i -g + add to config
+  agentproto plugins uninstall <pkg>       Remove from config (+ npm rm)
+  agentproto plugins enable <pkg>          Add to config (assume installed)
+  agentproto plugins disable <pkg>         Remove from config (keep installed)
+  agentproto plugins --help
+
+Plugin list lives in ~/.agentproto/config.json under \`plugins[]\`.
+`;
+async function runPlugins(args) {
+  const sub = args[0];
+  const rest = args.slice(1);
+  switch (sub) {
+    case void 0:
+    case "-h":
+    case "--help":
+      process.stdout.write(USAGE3);
+      return 0;
+    case "list":
+      return runList(rest);
+    case "show":
+      return runShow2(rest);
+    case "install":
+      return runInstall2(rest);
+    case "uninstall":
+      return runUninstall(rest);
+    case "enable":
+      return runEnable(rest);
+    case "disable":
+      return runDisable(rest);
+    default:
+      process.stderr.write(
+        `agentproto plugins: unknown subcommand '${sub}'.
+
+${USAGE3}`
+      );
+      return 2;
+  }
+}
+async function runList(args) {
+  const { values } = parseArgs({
+    args: [...args],
+    options: { json: { type: "boolean" } },
+    strict: true
+  });
+  const cfg = await loadConfig2();
+  const plugins = cfg.plugins ?? [];
+  if (plugins.length === 0) {
+    if (values.json) process.stdout.write("[]\n");
+    else
+      process.stdout.write(
+        "agentproto plugins: no plugins enabled. Try `agentproto plugins install <pkg>`.\n"
+      );
+    return 0;
+  }
+  const entries = [];
+  for (const id of plugins) {
+    try {
+      const result = await readPluginManifest(id);
+      entries.push({ id, manifest: result?.manifest ?? null });
+    } catch (err) {
+      entries.push({
+        id,
+        manifest: null,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  if (values.json) {
+    process.stdout.write(`${JSON.stringify(entries, null, 2)}
+`);
+    return 0;
+  }
+  for (const e of entries) {
+    process.stdout.write(`\u2022 ${e.id}
+`);
+    if (e.error) {
+      process.stdout.write(`    error: ${e.error}
+`);
+      continue;
+    }
+    if (!e.manifest) {
+      process.stdout.write(`    (no manifest \u2014 legacy side-effect plugin)
+`);
+      continue;
+    }
+    printAdapterSummary("substrates", e.manifest.substrates);
+    printAdapterSummary("dispatchers", e.manifest.dispatchers);
+    printAdapterSummary("executors", e.manifest.executors);
+    printAdapterSummary("state stores", e.manifest.stateStores);
+  }
+  return 0;
+}
+function printAdapterSummary(label, entries) {
+  if (entries.length === 0) return;
+  const kinds = entries.map((e) => e.kind).join(", ");
+  process.stdout.write(`    ${label}: ${kinds}
+`);
+}
+async function runShow2(args) {
+  const { values, positionals } = parseArgs({
+    args: [...args],
+    allowPositionals: true,
+    options: { json: { type: "boolean" } },
+    strict: true
+  });
+  const pkg = positionals[0];
+  if (!pkg) {
+    process.stderr.write(
+      "agentproto plugins show: missing <pkg>. Try: agentproto plugins show @guilde/agentproto-bridge\n"
+    );
+    return 2;
+  }
+  let result;
+  try {
+    result = await readPluginManifest(pkg);
+  } catch (err) {
+    process.stderr.write(
+      `agentproto plugins show: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return 1;
+  }
+  if (!result) {
+    process.stderr.write(
+      `agentproto plugins show: '${pkg}' is not installed (or doesn't declare an agentproto manifest).
+`
+    );
+    return 1;
+  }
+  if (values.json) {
+    process.stdout.write(`${JSON.stringify(result.manifest, null, 2)}
+`);
+    return 0;
+  }
+  const m = result.manifest;
+  process.stdout.write(`${pkg}
+`);
+  process.stdout.write(`  schema: ${m.schema}
+`);
+  printAdapterDetail("substrates", m.substrates);
+  printAdapterDetail("dispatchers", m.dispatchers);
+  printAdapterDetail("executors", m.executors);
+  printAdapterDetail("state stores", m.stateStores);
+  return 0;
+}
+function printAdapterDetail(label, entries) {
+  if (entries.length === 0) return;
+  process.stdout.write(`  ${label}:
+`);
+  for (const e of entries) {
+    process.stdout.write(`    \u2022 kind: ${e.kind}
+`);
+    process.stdout.write(`      entry: ${e.entry} \u2192 ${e.export}
+`);
+    const caps = "capabilities" in e ? e.capabilities : void 0;
+    if (Array.isArray(caps) && caps.length > 0) {
+      process.stdout.write(`      capabilities: ${caps.join(", ")}
+`);
+    }
+    if (e.description) {
+      process.stdout.write(`      ${e.description}
+`);
+    }
+  }
+}
+async function runInstall2(args) {
+  const { values, positionals } = parseArgs({
+    args: [...args],
+    allowPositionals: true,
+    options: {
+      local: { type: "boolean" },
+      "skip-npm": { type: "boolean" }
+    },
+    strict: true
+  });
+  const pkg = positionals[0];
+  if (!pkg) {
+    process.stderr.write("agentproto plugins install: missing <pkg>.\n");
+    return 2;
+  }
+  if (!values["skip-npm"]) {
+    const code = await spawnInherit2("npm", [
+      "install",
+      values.local ? "" : "-g",
+      pkg
+    ].filter(Boolean));
+    if (code !== 0) {
+      process.stderr.write(
+        `agentproto plugins install: npm failed with exit ${code}; config not modified.
+`
+      );
+      return code;
+    }
+  }
+  await addToConfig(pkg);
+  process.stdout.write(`agentproto plugins: enabled '${pkg}'.
+`);
+  return 0;
+}
+async function runUninstall(args) {
+  const { values, positionals } = parseArgs({
+    args: [...args],
+    allowPositionals: true,
+    options: {
+      local: { type: "boolean" },
+      "skip-npm": { type: "boolean" }
+    },
+    strict: true
+  });
+  const pkg = positionals[0];
+  if (!pkg) {
+    process.stderr.write("agentproto plugins uninstall: missing <pkg>.\n");
+    return 2;
+  }
+  await removeFromConfig(pkg);
+  if (!values["skip-npm"]) {
+    const code = await spawnInherit2("npm", [
+      "uninstall",
+      values.local ? "" : "-g",
+      pkg
+    ].filter(Boolean));
+    if (code !== 0) {
+      process.stderr.write(
+        `agentproto plugins uninstall: removed from config but npm uninstall failed with exit ${code}.
+`
+      );
+      return code;
+    }
+  }
+  process.stdout.write(`agentproto plugins: disabled '${pkg}'.
+`);
+  return 0;
+}
+async function runEnable(args) {
+  const [pkg] = args;
+  if (!pkg) {
+    process.stderr.write("agentproto plugins enable: missing <pkg>.\n");
+    return 2;
+  }
+  await addToConfig(pkg);
+  process.stdout.write(`agentproto plugins: enabled '${pkg}'.
+`);
+  return 0;
+}
+async function runDisable(args) {
+  const [pkg] = args;
+  if (!pkg) {
+    process.stderr.write("agentproto plugins disable: missing <pkg>.\n");
+    return 2;
+  }
+  await removeFromConfig(pkg);
+  process.stdout.write(`agentproto plugins: disabled '${pkg}'.
+`);
+  return 0;
+}
+function configPath() {
+  const base = process.env["AGENTPROTO_HOME"] ?? join(homedir(), ".agentproto");
+  return join(base, "config.json");
+}
+async function loadConfig2() {
+  try {
+    const raw = await readFile(configPath(), "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+}
+async function saveConfig2(cfg) {
+  const path = configPath();
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(cfg, null, 2)}
+`);
+}
+async function addToConfig(pkg) {
+  const cfg = await loadConfig2();
+  const plugins = cfg.plugins ?? [];
+  if (!plugins.includes(pkg)) plugins.push(pkg);
+  cfg.plugins = plugins;
+  await saveConfig2(cfg);
+}
+async function removeFromConfig(pkg) {
+  const cfg = await loadConfig2();
+  cfg.plugins = (cfg.plugins ?? []).filter((p) => p !== pkg);
+  await saveConfig2(cfg);
+}
+function spawnInherit2(cmd, argv) {
+  return new Promise((resolveP, rejectP) => {
+    const child = spawn(cmd, argv, { stdio: "inherit" });
+    child.once("error", rejectP);
+    child.once("exit", (code) => resolveP(code ?? 0));
+  });
+}
+
+// src/util/stdin.ts
+async function readStdinIfPiped() {
+  if (process.stdin.isTTY) return null;
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const text3 = Buffer.concat(chunks).toString("utf8").trim();
+  return text3.length > 0 ? text3 : null;
+}
+
+// src/commands/run.ts
+async function runRun(args) {
+  const { values, positionals } = parseArgs({
+    args: [...args],
+    allowPositionals: true,
+    strict: true,
+    options: {
+      cwd: { type: "string" },
+      prompt: { type: "string", short: "p" },
+      resume: { type: "string" },
+      json: { type: "boolean" }
+    }
+  });
+  const slug = positionals[0];
+  if (!slug) {
+    process.stderr.write(
+      "agentproto run: missing adapter slug. Try: agentproto run claude-code\n"
+    );
+    return 2;
+  }
+  const cwd = values.cwd ? resolve(values.cwd) : process.cwd();
+  const promptArg = values.prompt ?? await readStdinIfPiped();
+  if (!promptArg) {
+    process.stderr.write(
+      "agentproto run: no prompt provided. Pass --prompt or pipe one over stdin.\n"
+    );
+    return 2;
+  }
+  const adapter = await resolveAdapter(slug);
+  const runtime = createAgentCliRuntime(adapter.handle);
+  const controller = new AbortController();
+  const onSignal = (sig) => {
+    process.stderr.write(`
+agentproto: received ${sig}, cancelling\u2026
+`);
+    controller.abort();
+  };
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  let session = null;
+  try {
+    session = await runtime.start({
+      cwd,
+      signal: controller.signal,
+      resumeSessionId: values.resume
+    });
+    const printer = values.json ? printJson : printPretty;
+    let exit = 0;
+    for await (const ev of session.send(promptArg)) {
+      printer(ev);
+      if (ev.kind === "turn-end" && ev.reason !== "completed") exit = 1;
+      if (ev.kind === "error") exit = 1;
+    }
+    return exit;
+  } finally {
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+    if (session) await session.close().catch(() => {
+    });
+  }
+}
+function printJson(ev) {
+  process.stdout.write(`${JSON.stringify(ev)}
+`);
+}
+function printPretty(ev) {
+  switch (ev.kind) {
+    case "text-delta":
+      process.stdout.write(ev.text);
+      break;
+    case "thought":
+      process.stderr.write(`\x1B[2m[thought] ${ev.text}\x1B[0m
+`);
+      break;
+    case "tool-call":
+      process.stderr.write(`\x1B[36m[tool] ${ev.toolName}\x1B[0m
+`);
+      break;
+    case "tool-result":
+      if (ev.isError)
+        process.stderr.write(`\x1B[31m[tool-error]\x1B[0m
+`);
+      break;
+    case "agent-prompt":
+      process.stderr.write(`\x1B[33m[agent-prompt: needs input]\x1B[0m
+`);
+      break;
+    case "turn-end":
+      process.stdout.write(`
+\x1B[2m[turn-end: ${ev.reason}]\x1B[0m
+`);
+      break;
+    case "error": {
+      const code = typeof ev.error.code === "number" ? ` (code ${ev.error.code})` : "";
+      process.stderr.write(
+        `\x1B[31m[error]${code} ${ev.error.message}\x1B[0m
+`
+      );
+      const data = ev.error.data;
+      if (data && typeof data === "object") {
+        const stderr = data.stderr;
+        if (typeof stderr === "string" && stderr.trim()) {
+          process.stderr.write(`\x1B[2m\u2500\u2500 child stderr \u2500\u2500
+${stderr}\x1B[0m
+`);
+        }
+        const rest = { ...data };
+        delete rest.stderr;
+        if (Object.keys(rest).length > 0) {
+          process.stderr.write(
+            `\x1B[2m\u2500\u2500 error.data \u2500\u2500
+${JSON.stringify(rest, null, 2)}\x1B[0m
+`
+          );
+        }
+      }
+      break;
+    }
+  }
+}
+async function runTurn(ports, options = {}) {
+  const historyLimit = options.historyLimit ?? 30;
+  const cycleId = newCycleId();
+  const cycleStart = Date.now();
+  emit(ports.telemetry, {
+    kind: "cycle.started",
+    cycleId,
+    at: nowIso(),
+    ...options.since !== void 0 ? { since: options.since } : {}
+  });
+  const readStart = Date.now();
+  const all = await ports.substrate.read(options.since);
+  const recentTurns = all.slice(-historyLimit);
+  emit(ports.telemetry, {
+    kind: "substrate.read",
+    cycleId,
+    at: nowIso(),
+    substrateKind: ports.substrate.kind,
+    turnCount: recentTurns.length,
+    durationMs: Date.now() - readStart
+  });
+  const dispatchStart = Date.now();
+  const selected = await ports.dispatcher.selectNext({
+    recentTurns,
+    participants: ports.participants
+  });
+  emit(ports.telemetry, {
+    kind: "dispatch.decided",
+    cycleId,
+    at: nowIso(),
+    dispatcherKind: ports.dispatcher.kind,
+    selected,
+    durationMs: Date.now() - dispatchStart
+  });
+  if (selected.length === 0) {
+    await ports.lifecycle?.onIdle?.();
+    emit(ports.telemetry, { kind: "cycle.idle", cycleId, at: nowIso() });
+    emit(ports.telemetry, {
+      kind: "cycle.finished",
+      cycleId,
+      at: nowIso(),
+      outcome: "idle",
+      turnsAppended: 0,
+      durationMs: Date.now() - cycleStart
+    });
+    return { cycle: "idle", selected: [], turnsAppended: [] };
+  }
+  const triggerTurn = recentTurns[recentTurns.length - 1];
+  if (!triggerTurn) {
+    await ports.lifecycle?.onIdle?.();
+    emit(ports.telemetry, { kind: "cycle.idle", cycleId, at: nowIso() });
+    emit(ports.telemetry, {
+      kind: "cycle.finished",
+      cycleId,
+      at: nowIso(),
+      outcome: "idle",
+      turnsAppended: 0,
+      durationMs: Date.now() - cycleStart
+    });
+    return { cycle: "idle", selected: [], turnsAppended: [] };
+  }
+  const appended = [];
+  for (const participantId of selected) {
+    const participant = findParticipant(ports.participants, participantId);
+    if (!participant) {
+      continue;
+    }
+    const executor = ports.executors.get(participant.executor);
+    if (!executor) {
+      continue;
+    }
+    await ports.lifecycle?.onMention?.(participantId, triggerTurn);
+    const state = await ports.state.read(participantId);
+    emit(ports.telemetry, {
+      kind: "participant.started",
+      cycleId,
+      at: nowIso(),
+      participantId,
+      executorKind: participant.executor
+    });
+    const execStart = Date.now();
+    let output2;
+    try {
+      output2 = await executor.executeTurn({
+        participant,
+        recentTurns,
+        triggerTurn,
+        state,
+        signal: options.signal
+      });
+    } catch (err) {
+      emit(ports.telemetry, {
+        kind: "participant.failed",
+        cycleId,
+        at: nowIso(),
+        participantId,
+        executorKind: participant.executor,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
+    emit(ports.telemetry, {
+      kind: "participant.finished",
+      cycleId,
+      at: nowIso(),
+      participantId,
+      executorKind: participant.executor,
+      durationMs: Date.now() - execStart,
+      contentLength: output2.content.length
+    });
+    const turn = await ports.substrate.append({
+      participantId,
+      content: output2.content,
+      meta: output2.meta
+    });
+    appended.push(turn);
+    emit(ports.telemetry, {
+      kind: "substrate.appended",
+      cycleId,
+      at: nowIso(),
+      turnId: turn.id,
+      participantId
+    });
+    if (output2.stateUpdate) {
+      await ports.state.write(participantId, output2.stateUpdate);
+      emit(ports.telemetry, {
+        kind: "state.written",
+        cycleId,
+        at: nowIso(),
+        participantId
+      });
+    }
+    await ports.lifecycle?.onTurnEnd?.(turn);
+  }
+  emit(ports.telemetry, {
+    kind: "cycle.finished",
+    cycleId,
+    at: nowIso(),
+    outcome: "executed",
+    turnsAppended: appended.length,
+    durationMs: Date.now() - cycleStart
+  });
+  return { cycle: "executed", selected, turnsAppended: appended };
+}
+function findParticipant(participants, id) {
+  for (const p of participants) {
+    if (p.id === id) return p;
+  }
+  return void 0;
+}
+function emit(telemetry, event) {
+  if (!telemetry) return;
+  try {
+    telemetry.emit(event);
+  } catch {
+  }
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function newCycleId() {
+  return `c_${randomBytes(6).toString("hex")}`;
+}
+var MULTI_AGENT_RUNTIME_SCHEMA = "agentruntimes/v1";
+var MULTI_AGENT_RUNTIME_KIND = "MultiAgentRuntime";
+var AdapterConfigSchema = z.object({
+  kind: z.string().min(1)
+}).loose();
+var ParticipantManifestSchema = z.object({
+  id: z.string().min(1),
+  executor: z.string().min(1),
+  displayName: z.string().min(1).optional(),
+  role: z.string().optional(),
+  meta: z.record(z.string(), z.unknown()).optional()
+}).loose();
+var MultiAgentRuntimeManifestSchema = z.object({
+  schema: z.literal(MULTI_AGENT_RUNTIME_SCHEMA),
+  kind: z.literal(MULTI_AGENT_RUNTIME_KIND),
+  id: z.string().min(1),
+  participants: z.array(ParticipantManifestSchema).min(1),
+  substrate: AdapterConfigSchema,
+  dispatcher: AdapterConfigSchema,
+  state: AdapterConfigSchema.optional(),
+  lifecycle: z.object({
+    onTurnEnd: z.boolean().optional(),
+    onMention: z.boolean().optional(),
+    onIdle: z.boolean().optional()
+  }).optional()
+}).loose();
+async function loadManifest(path) {
+  const abs = resolve(path);
+  const raw = await readFile(abs, "utf8");
+  const parsed = matter3(raw);
+  const manifest = MultiAgentRuntimeManifestSchema.parse(parsed.data);
+  return {
+    manifest,
+    body: parsed.content,
+    path: abs,
+    baseDir: dirname(abs)
+  };
+}
+
+// ../agent-runtime/dist/adapters/telemetry.mjs
+function stderrTelemetry(options = {}) {
+  const prefix = options.prefix ?? "agentproto: ";
+  return {
+    emit(event) {
+      if (options.exclude?.has(event.kind)) return;
+      if (options.include && !options.include.has(event.kind)) return;
+      process.stderr.write(`${prefix}${formatEvent(event)}
+`);
+    }
+  };
+}
+function formatEvent(event) {
+  switch (event.kind) {
+    case "cycle.started":
+      return `${event.cycleId} cycle.started${event.since !== void 0 ? ` since=${event.since}` : ""}`;
+    case "substrate.read":
+      return `${event.cycleId} substrate.read ${event.substrateKind} turns=${event.turnCount} ${event.durationMs}ms`;
+    case "dispatch.decided":
+      return `${event.cycleId} dispatch.decided ${event.dispatcherKind} selected=[${event.selected.join(",") || "(none)"}] ${event.durationMs}ms`;
+    case "participant.started":
+      return `${event.cycleId} participant.started ${event.participantId} (${event.executorKind})`;
+    case "participant.finished":
+      return `${event.cycleId} participant.finished ${event.participantId} ${event.durationMs}ms content=${event.contentLength}b`;
+    case "participant.failed":
+      return `${event.cycleId} participant.failed ${event.participantId} \u2014 ${event.error}`;
+    case "substrate.appended":
+      return `${event.cycleId} substrate.appended turn=${event.turnId} by=${event.participantId}`;
+    case "state.written":
+      return `${event.cycleId} state.written ${event.participantId}`;
+    case "cycle.idle":
+      return `${event.cycleId} cycle.idle`;
+    case "cycle.finished":
+      return `${event.cycleId} cycle.finished ${event.outcome} appended=${event.turnsAppended} ${event.durationMs}ms`;
+    default: {
+      const _exhaustive = event;
+      return JSON.stringify(_exhaustive);
+    }
+  }
+}
+var HEADER_RE = /^=== TURN id=([^\s]+) participant=([^\s]+) ts=([^\s]+) ===$/;
+var FileSubstrate = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  kind = "file";
+  async append(input2) {
+    const timestamp = input2.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+    const id = hashTurnId(input2.participantId, timestamp, input2.content);
+    const turn = {
+      id,
+      participantId: input2.participantId,
+      timestamp,
+      content: input2.content,
+      meta: input2.meta
+    };
+    await ensureDir2(this.opts.path);
+    const block = formatTurnBlock(turn);
+    await appendFile(this.opts.path, block, "utf8");
+    return turn;
+  }
+  async read(since) {
+    let raw;
+    try {
+      raw = await readFile(this.opts.path, "utf8");
+    } catch (err) {
+      if (isNotFound(err)) return [];
+      throw err;
+    }
+    const turns = parseJournal(raw);
+    if (since === void 0) return turns;
+    const cutoff = turns.findIndex((t) => t.id === since);
+    if (cutoff === -1) return turns;
+    return turns.slice(cutoff + 1);
+  }
+};
+function formatTurnBlock(turn) {
+  const header = `=== TURN id=${turn.id} participant=${turn.participantId} ts=${turn.timestamp} ===
+`;
+  const body = turn.content.endsWith("\n") ? turn.content : `${turn.content}
+`;
+  return `${header}${body}`;
+}
+function parseJournal(raw) {
+  const lines = raw.split("\n");
+  const turns = [];
+  let current = null;
+  for (const line of lines) {
+    const match = HEADER_RE.exec(line);
+    if (match && match[1] && match[2] && match[3]) {
+      if (current) turns.push(materialise(current));
+      current = { id: match[1], pid: match[2], ts: match[3], buf: [] };
+      continue;
+    }
+    if (current) current.buf.push(line);
+  }
+  if (current) turns.push(materialise(current));
+  return turns;
+}
+function materialise(c) {
+  let body = c.buf.join("\n");
+  while (body.endsWith("\n")) body = body.slice(0, -1);
+  return {
+    id: c.id,
+    participantId: c.pid,
+    timestamp: c.ts,
+    content: body
+  };
+}
+function hashTurnId(pid, ts, content) {
+  const h = createHash("sha256");
+  h.update(pid);
+  h.update("\0");
+  h.update(ts);
+  h.update("\0");
+  h.update(content);
+  return `t_${h.digest("hex").slice(0, 12)}`;
+}
+async function ensureDir2(path) {
+  const dir = dirname(path);
+  try {
+    await stat(dir);
+  } catch (err) {
+    if (isNotFound(err)) {
+      await mkdir(dir, { recursive: true });
+      return;
+    }
+    throw err;
+  }
+}
+function isNotFound(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+
+// ../agent-runtime/dist/adapters/dispatcher-mention.mjs
+function textContainsMention(text3, name) {
+  if (text3.includes(`@${name}`)) return true;
+  if (name.includes(" ")) {
+    const firstName = name.split(" ")[0]?.trim();
+    if (!firstName) return false;
+    const regex = new RegExp(`@${firstName}(?!\\w)`, "i");
+    return regex.test(text3);
+  }
+  return false;
+}
+var MentionDispatcher = class {
+  kind = "mention";
+  lastProcessedTriggerId;
+  async selectNext(input2) {
+    const trigger = input2.recentTurns[input2.recentTurns.length - 1];
+    if (!trigger) return [];
+    if (trigger.id === this.lastProcessedTriggerId) return [];
+    const text3 = trigger.content;
+    const selected = [];
+    for (const p of input2.participants) {
+      if (p.id === trigger.participantId) continue;
+      if (textContainsMention(text3, p.displayName)) {
+        selected.push(p.id);
+      }
+    }
+    if (selected.length > 0) {
+      this.lastProcessedTriggerId = trigger.id;
+    }
+    return selected;
+  }
+};
+var FileStateStore = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  kind = "fs";
+  async read(participantId) {
+    const path = this.pathFor(participantId);
+    try {
+      const raw = await readFile(path, "utf8");
+      return JSON.parse(raw);
+    } catch (err) {
+      if (isNotFound2(err)) return Object.freeze({});
+      throw err;
+    }
+  }
+  async write(participantId, state) {
+    await ensureDir3(this.opts.dir);
+    const path = this.pathFor(participantId);
+    await writeFile(path, JSON.stringify(state, null, 2), "utf8");
+  }
+  pathFor(participantId) {
+    const safe = participantId.replace(/[^a-zA-Z0-9._-]/g, "_");
+    return resolve(this.opts.dir, `${safe}.json`);
+  }
+};
+async function ensureDir3(dir) {
+  try {
+    await stat(dir);
+  } catch (err) {
+    if (isNotFound2(err)) {
+      await mkdir(dir, { recursive: true });
+      return;
+    }
+    throw err;
+  }
+}
+function isNotFound2(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+var AgentCliParticipant = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  kind = "agent-cli";
+  async executeTurn(input2) {
+    const prompt = await assemblePrompt(input2);
+    const stdout = await spawnWithStdin({
+      command: this.opts.command,
+      args: this.opts.args ?? [],
+      cwd: this.opts.cwd ?? process.cwd(),
+      timeoutMs: this.opts.timeoutMs ?? 9e4,
+      stdin: prompt,
+      signal: input2.signal
+    });
+    const parsed = this.opts.parseOutput?.(stdout) ?? null;
+    const content = parsed ?? stdout.trimEnd();
+    return { content };
+  }
+};
+async function assemblePrompt(input2) {
+  const roleText = input2.participant.role ? await loadRole(input2.participant.role) : "";
+  const transcript = input2.recentTurns.map((t) => `[${t.participantId}] ${t.content}`).join("\n\n");
+  return [
+    roleText && `# Your role
+
+${roleText}`,
+    `# Recent conversation
+
+${transcript}`,
+    `# Your turn
+
+You are ${input2.participant.displayName}. The latest message in the conversation triggered you (most likely because it mentions you). Read the transcript above and reply in character. Keep it conversational unless the trigger asks for detailed work. Output only your reply \u2014 no preamble, no role labels, no quotes around the response.`
+  ].filter(Boolean).join("\n\n");
+}
+var ROLE_FILE_EXTENSIONS = [".md", ".markdown", ".txt"];
+async function loadRole(roleField) {
+  if (!looksLikeRoleFile(roleField)) return roleField;
+  try {
+    const raw = await readFile(roleField, "utf8");
+    const parsed = matter3(raw);
+    return parsed.content.trim();
+  } catch (err) {
+    const code = err.code;
+    process.stderr.write(
+      `agent-cli participant: role path '${roleField}' not readable (${code ?? "unknown"}); using the literal string as inline role text.
+`
+    );
+    return roleField;
+  }
+}
+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");
     });
-    child.once("error", () => resolve7({ ok: false, message: "check failed" }));
-    child.once("exit", (code) => {
-      if (code !== 0) {
-        resolve7({ ok: false, message: `check exited ${code}` });
-        return;
-      }
-      const re = new RegExp(check.parse);
-      const m = buf.match(re);
-      if (!m || !m[1]) {
-        resolve7({ ok: false, message: "could not parse version" });
+    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;
       }
-      resolve7({ ok: true, message: `version ${m[1]}` });
+      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/util/stdin.ts
-async function readStdinIfPiped() {
-  if (process.stdin.isTTY) return null;
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+// src/registry/builtins.ts
+function registerBuiltins() {
+  registerSubstrate("file", (cfg, ctx) => {
+    const path = typeof cfg.path === "string" ? cfg.path : ".runtime/conversation.md";
+    return new FileSubstrate({ path: resolve(ctx.baseDir, path) });
+  });
+  registerDispatcher("mention", () => new MentionDispatcher());
+  registerStateStore("fs", (cfg, ctx) => {
+    const dir = typeof cfg.dir === "string" ? cfg.dir : ".runtime/state";
+    return new FileStateStore({ dir: resolve(ctx.baseDir, dir) });
+  });
+  registerExecutor("agent-cli", (cfg) => buildAgentCli(cfg));
+}
+function buildAgentCli(cfg) {
+  const command = typeof cfg.command === "string" ? cfg.command : "claude";
+  const args = Array.isArray(cfg.args) ? cfg.args.filter((a) => typeof a === "string") : ["--print", "--output-format=json"];
+  const useClaudeJson = cfg.parseJson !== false && command === "claude";
+  return new AgentCliParticipant({
+    command,
+    args,
+    parseOutput: useClaudeJson ? parseClaudeJsonOutput : void 0
+  });
+}
+async function loadPluginsFromConfig() {
+  const path = configPath2();
+  try {
+    const raw = await readFile(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.plugins ?? [];
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    process.stderr.write(
+      `agentproto: failed to read ${path} \u2014 ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return [];
+  }
+}
+async function loadPlugins(moduleIds) {
+  for (const id of moduleIds) {
+    try {
+      const manifest = await loadPluginFromManifest(id);
+      if (manifest === null) {
+        await import(id);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(
+        `agentproto: plugin '${id}' failed to load \u2014 ${msg}
+`
+      );
+    }
   }
-  const text3 = Buffer.concat(chunks).toString("utf8").trim();
-  return text3.length > 0 ? text3 : null;
+}
+function configPath2() {
+  const base = process.env["AGENTPROTO_HOME"] ?? join(homedir(), ".agentproto");
+  return join(base, "config.json");
 }
 
-// src/commands/run.ts
-async function runRun(args) {
-  const { values, positionals } = parseArgs({
+// src/commands/run-swarm.ts
+async function runRunSwarm(args) {
+  const { values } = parseArgs({
     args: [...args],
-    allowPositionals: true,
+    allowPositionals: false,
     strict: true,
     options: {
-      cwd: { type: "string" },
-      prompt: { type: "string", short: "p" },
-      resume: { type: "string" },
-      json: { type: "boolean" }
+      manifest: { type: "string", short: "m" },
+      once: { type: "boolean" },
+      interval: { type: "string" },
+      verbose: { type: "boolean", short: "v" },
+      plugin: { type: "string", multiple: true }
     }
   });
-  const slug = positionals[0];
-  if (!slug) {
+  if (!values.manifest) {
     process.stderr.write(
-      "agentproto run: missing adapter slug. Try: agentproto run claude-code\n"
+      "agentproto run-swarm: --manifest <path> is required.\n"
     );
     return 2;
   }
-  const cwd = values.cwd ? resolve(values.cwd) : process.cwd();
-  const promptArg = values.prompt ?? await readStdinIfPiped();
-  if (!promptArg) {
+  registerBuiltins();
+  const cliPlugins = values.plugin ?? [];
+  const configPlugins = await loadPluginsFromConfig();
+  await loadPlugins([...configPlugins, ...cliPlugins]);
+  const loaded = await loadManifest(resolve(values.manifest));
+  const verbose = values.verbose === true;
+  const cleanups = [];
+  const ctx = {
+    baseDir: loaded.baseDir,
+    registerCleanup: (fn) => cleanups.push(fn)
+  };
+  const telemetry = verbose ? stderrTelemetry({ prefix: "agentproto run-swarm: " }) : void 0;
+  let ports;
+  try {
+    ports = await buildPorts(loaded, ctx, telemetry);
+  } catch (err) {
     process.stderr.write(
-      "agentproto run: no prompt provided. Pass --prompt or pipe one over stdin.\n"
+      `agentproto run-swarm: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    await runCleanups(cleanups);
+    return 1;
+  }
+  const onceMode = values.once === true;
+  const intervalMs = parseInterval(values.interval) ?? 2e3;
+  if (verbose) {
+    logVerbose(`loaded manifest "${loaded.manifest.id}" from ${loaded.path}`);
+    logVerbose(
+      `participants: ${ports.participants.map((p) => p.displayName).join(", ")}`
+    );
+    logVerbose(
+      `substrate=${ports.substrate.kind} dispatcher=${ports.dispatcher.kind} state=${ports.state.kind}`
+    );
+    const registered = listRegisteredKinds();
+    logVerbose(
+      `registered: substrates=[${registered.substrates.join(",")}] dispatchers=[${registered.dispatchers.join(",")}] executors=[${registered.executors.join(",")}] stateStores=[${registered.stateStores.join(",")}]`
     );
-    return 2;
   }
-  const adapter = await resolveAdapter(slug);
-  const runtime = createAgentCliRuntime(adapter.handle);
   const controller = new AbortController();
-  const onSignal = (sig) => {
-    process.stderr.write(`
-agentproto: received ${sig}, cancelling\u2026
-`);
+  process.once("SIGINT", () => {
+    if (verbose) logVerbose("SIGINT received, draining current cycle\u2026");
     controller.abort();
-  };
-  process.once("SIGINT", onSignal);
-  process.once("SIGTERM", onSignal);
-  let session = null;
+  });
   try {
-    session = await runtime.start({
-      cwd,
-      signal: controller.signal,
-      resumeSessionId: values.resume
-    });
-    const printer = values.json ? printJson : printPretty;
-    let exit = 0;
-    for await (const ev of session.send(promptArg)) {
-      printer(ev);
-      if (ev.kind === "turn-end" && ev.reason !== "completed") exit = 1;
-      if (ev.kind === "error") exit = 1;
-    }
-    return exit;
+    do {
+      if (controller.signal.aborted) break;
+      try {
+        await runTurn(ports, { signal: controller.signal });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`agentproto run-swarm: cycle failed \u2014 ${msg}
+`);
+      }
+      if (onceMode) break;
+      await sleep2(intervalMs, controller.signal);
+    } while (!controller.signal.aborted);
   } finally {
-    process.off("SIGINT", onSignal);
-    process.off("SIGTERM", onSignal);
-    if (session) await session.close().catch(() => {
-    });
+    await runCleanups(cleanups);
   }
+  return 0;
 }
-function printJson(ev) {
-  process.stdout.write(`${JSON.stringify(ev)}
-`);
+async function buildPorts(loaded, ctx, telemetry) {
+  const manifest = loaded.manifest;
+  const substrate = await buildSubstrate(manifest, ctx);
+  const dispatcher = await buildDispatcher(manifest, ctx);
+  const state = await buildState(manifest, ctx);
+  const participants = buildParticipants(manifest);
+  const executors2 = await buildExecutors(manifest, ctx);
+  return {
+    substrate,
+    dispatcher,
+    state,
+    participants,
+    executors: executors2,
+    ...telemetry ? { telemetry } : {}
+  };
 }
-function printPretty(ev) {
-  switch (ev.kind) {
-    case "text-delta":
-      process.stdout.write(ev.text);
-      break;
-    case "thought":
-      process.stderr.write(`\x1B[2m[thought] ${ev.text}\x1B[0m
-`);
-      break;
-    case "tool-call":
-      process.stderr.write(`\x1B[36m[tool] ${ev.toolName}\x1B[0m
-`);
-      break;
-    case "tool-result":
-      if (ev.isError)
-        process.stderr.write(`\x1B[31m[tool-error]\x1B[0m
-`);
-      break;
-    case "agent-prompt":
-      process.stderr.write(`\x1B[33m[agent-prompt: needs input]\x1B[0m
-`);
-      break;
-    case "turn-end":
-      process.stdout.write(`
-\x1B[2m[turn-end: ${ev.reason}]\x1B[0m
-`);
-      break;
-    case "error": {
-      const code = typeof ev.error.code === "number" ? ` (code ${ev.error.code})` : "";
-      process.stderr.write(
-        `\x1B[31m[error]${code} ${ev.error.message}\x1B[0m
-`
+async function buildSubstrate(manifest, ctx) {
+  const cfg = manifest.substrate;
+  const factory = getSubstrateFactory(cfg.kind);
+  if (!factory) {
+    throw new Error(
+      `unknown substrate kind '${cfg.kind}'. Registered kinds: [${listRegisteredKinds().substrates.join(", ") || "(none)"}]. Pass --plugin <module-id> or add it to ~/.agentproto/config.json plugins[] to register a third-party substrate.`
+    );
+  }
+  return factory(cfg, ctx);
+}
+async function buildDispatcher(manifest, ctx) {
+  const cfg = manifest.dispatcher;
+  const factory = getDispatcherFactory(cfg.kind);
+  if (!factory) {
+    throw new Error(
+      `unknown dispatcher kind '${cfg.kind}'. Registered kinds: [${listRegisteredKinds().dispatchers.join(", ") || "(none)"}].`
+    );
+  }
+  return factory(cfg, ctx);
+}
+async function buildState(manifest, ctx) {
+  const cfg = manifest.state ?? { kind: "fs" };
+  const factory = getStateStoreFactory(cfg.kind);
+  if (!factory) {
+    throw new Error(
+      `unknown state-store kind '${cfg.kind}'. Registered kinds: [${listRegisteredKinds().stateStores.join(", ") || "(none)"}].`
+    );
+  }
+  return factory(cfg, ctx);
+}
+function buildParticipants(manifest) {
+  return manifest.participants.map((p) => ({
+    id: p.id,
+    displayName: p.displayName ?? p.id,
+    executor: p.executor,
+    role: p.role,
+    meta: p.meta
+  }));
+}
+async function buildExecutors(manifest, ctx) {
+  const map = /* @__PURE__ */ new Map();
+  const kinds = new Set(manifest.participants.map((p) => p.executor));
+  for (const kind of kinds) {
+    const factory = getExecutorFactory(kind);
+    if (!factory) {
+      throw new Error(
+        `unknown executor kind '${kind}'. Registered kinds: [${listRegisteredKinds().executors.join(", ") || "(none)"}]. Pass --plugin <module-id> or add the executor's package to ~/.agentproto/config.json plugins[].`
       );
-      const data = ev.error.data;
-      if (data && typeof data === "object") {
-        const stderr = data.stderr;
-        if (typeof stderr === "string" && stderr.trim()) {
-          process.stderr.write(`\x1B[2m\u2500\u2500 child stderr \u2500\u2500
-${stderr}\x1B[0m
+    }
+    map.set(kind, await factory({ kind }, ctx));
+  }
+  return map;
+}
+async function runCleanups(cleanups) {
+  for (const fn of cleanups) {
+    try {
+      await fn();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`agentproto run-swarm: cleanup failed \u2014 ${msg}
 `);
-        }
-        const rest = { ...data };
-        delete rest.stderr;
-        if (Object.keys(rest).length > 0) {
-          process.stderr.write(
-            `\x1B[2m\u2500\u2500 error.data \u2500\u2500
-${JSON.stringify(rest, null, 2)}\x1B[0m
-`
-          );
-        }
-      }
-      break;
     }
   }
 }
+function parseInterval(value) {
+  if (!value) return void 0;
+  const match = /^(\d+)(ms|s)?$/.exec(value);
+  if (!match) return void 0;
+  const n = Number(match[1]);
+  const unit = match[2] ?? "ms";
+  return unit === "s" ? n * 1e3 : n;
+}
+function sleep2(ms, signal) {
+  return new Promise((resolveP) => {
+    if (signal.aborted) {
+      resolveP();
+      return;
+    }
+    const t = setTimeout(() => resolveP(), ms);
+    signal.addEventListener("abort", () => {
+      clearTimeout(t);
+      resolveP();
+    });
+  });
+}
+function logVerbose(msg) {
+  process.stderr.write(`agentproto run-swarm: ${msg}
+`);
+}
 
 // src/util/pty-factory.ts
 async function loadNodePtyFactory() {
@@ -2236,7 +3772,7 @@ function createVerbs(spec) {
     const relativePath = spec.pathOf(handle);
     const path = join(opts.dir, relativePath);
     const frontmatter = toFrontmatter(params);
-    const rendered = matter.stringify(
+    const rendered = matter3.stringify(
       opts.body ?? defaultBody(spec, frontmatter),
       frontmatter
     );
@@ -2289,7 +3825,7 @@ function createVerbs(spec) {
     const mutated = await mutator(params, { handle, body });
     const newHandle = spec.define(mutated);
     const newFrontmatter = toFrontmatter(mutated);
-    const rendered = matter.stringify(
+    const rendered = matter3.stringify(
       opts.body ?? body,
       newFrontmatter
     );
@@ -2299,7 +3835,7 @@ function createVerbs(spec) {
     }
     return { path, handle: newHandle, rendered };
   }
-  async function resolve7(block, ctx = {}) {
+  async function resolve9(block, ctx = {}) {
     if ("inline" in block) {
       return spec.define(block.inline);
     }
@@ -2325,7 +3861,7 @@ function createVerbs(spec) {
   async function deleteFn(path) {
     await rm(path, { force: true });
   }
-  return { create, load, list, update, resolve: resolve7, delete: deleteFn };
+  return { create, load, list, update, resolve: resolve9, 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;
@@ -2343,28 +3879,51 @@ createDoctype({
   validate(def) {
     const result = extensionFrontmatterSchema.safeParse(def);
     if (!result.success) {
-      throw new Error(`defineExtension (AIP-40): ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`);
+      throw new Error(
+        `defineExtension (AIP-40): ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+      );
     }
   },
   build(def) {
     return { ...def };
   }
 });
+function parseExtensionManifest(source) {
+  const parsed = matter3(source);
+  if (Object.keys(parsed.data).length === 0) {
+    throw new Error("parseExtensionManifest: missing or empty frontmatter");
+  }
+  const result = extensionFrontmatterSchema.safeParse(parsed.data);
+  if (!result.success) {
+    throw new Error(
+      `parseExtensionManifest: invalid frontmatter \u2014 ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+  }
+  return { frontmatter: result.data, body: parsed.content };
+}
+
+// ../extension/dist/index.mjs
 function specFromExtension(extension, opts = {}) {
   const { parent } = opts;
   const isRoot = extension.extends === "none";
   if (!isRoot && !parent) {
-    throw new Error(`specFromExtension (AIP-40): extension '${extension.slug}' extends '${extension.extends}' but no parent spec was provided in opts.parent`);
+    throw new Error(
+      `specFromExtension (AIP-40): extension '${extension.slug}' extends '${extension.extends}' but no parent spec was provided in opts.parent`
+    );
   }
   if (isRoot && !extension.path_convention) {
-    throw new Error(`specFromExtension (AIP-40): extension '${extension.slug}' is a root doctype (extends: none) and MUST declare path_convention`);
+    throw new Error(
+      `specFromExtension (AIP-40): extension '${extension.slug}' is a root doctype (extends: none) and MUST declare path_convention`
+    );
   }
   if (parent && extension.tighten) {
     verifyTightening(extension);
   }
   const slugName = extension.slug.split(":")[1] ?? extension.slug;
   const pathTemplate = extension.path_convention ?? null;
-  const extensionKeys = new Set(Object.keys(extension.add_fields?.properties ?? {}));
+  const extensionKeys = new Set(
+    Object.keys(extension.add_fields?.properties ?? {})
+  );
   const define = (params) => {
     const withDefaults = { ...params };
     if (extension.defaults) {
@@ -2380,10 +3939,8 @@ function specFromExtension(extension, opts = {}) {
     const parentOnly = {};
     const extensionOnly = {};
     for (const [key, value] of Object.entries(withDefaults)) {
-      if (extensionKeys.has(key))
-        extensionOnly[key] = value;
-      else
-        parentOnly[key] = value;
+      if (extensionKeys.has(key)) extensionOnly[key] = value;
+      else parentOnly[key] = value;
     }
     const parentHandle = parent.define(parentOnly);
     return Object.freeze({
@@ -2394,7 +3951,11 @@ function specFromExtension(extension, opts = {}) {
   const parse = isRoot ? rootParse(extension) : parent.parse;
   const pathOf = (handle) => {
     if (pathTemplate) {
-      return resolvePathTemplate(pathTemplate, handle, slugName);
+      return resolvePathTemplate(
+        pathTemplate,
+        handle,
+        slugName
+      );
     }
     return parent.pathOf(handle);
   };
@@ -2411,36 +3972,33 @@ function verifyTightening(extension, parent) {
   const t = extension.tighten ?? {};
   for (const [field, override] of Object.entries(t)) {
     if (typeof override.minLength === "number" && typeof override.maxLength === "number" && override.minLength > override.maxLength) {
-      throw new Error(`specFromExtension (AIP-40): extension '${extension.slug}' tighten.${field}: minLength (${override.minLength}) > maxLength (${override.maxLength})`);
+      throw new Error(
+        `specFromExtension (AIP-40): extension '${extension.slug}' tighten.${field}: minLength (${override.minLength}) > maxLength (${override.maxLength})`
+      );
     }
     if (typeof override.minimum === "number" && typeof override.maximum === "number" && override.minimum > override.maximum) {
-      throw new Error(`specFromExtension (AIP-40): extension '${extension.slug}' tighten.${field}: minimum (${override.minimum}) > maximum (${override.maximum})`);
+      throw new Error(
+        `specFromExtension (AIP-40): extension '${extension.slug}' tighten.${field}: minimum (${override.minimum}) > maximum (${override.maximum})`
+      );
     }
     if (override.enum !== void 0 && !Array.isArray(override.enum)) {
-      throw new Error(`specFromExtension (AIP-40): extension '${extension.slug}' tighten.${field}: enum must be an array`);
+      throw new Error(
+        `specFromExtension (AIP-40): extension '${extension.slug}' tighten.${field}: enum must be an array`
+      );
     }
   }
 }
 function rootParse(extension) {
   return (source) => {
-    throw new Error(`specFromExtension (AIP-40): extension '${extension.slug}' is a root doctype \u2014 supply your own parser or extend a public AIP for parser inheritance`);
+    throw new Error(
+      `specFromExtension (AIP-40): extension '${extension.slug}' is a root doctype \u2014 supply your own parser or extend a public AIP for parser inheritance`
+    );
   };
 }
 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());
 }
-function parseExtensionManifest(source) {
-  const parsed = matter(source);
-  if (Object.keys(parsed.data).length === 0) {
-    throw new Error("parseExtensionManifest: missing or empty frontmatter");
-  }
-  const result = extensionFrontmatterSchema.safeParse(parsed.data);
-  if (!result.success) {
-    throw new Error(`parseExtensionManifest: 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
 async function createMcpServer(opts) {
@@ -4203,7 +5761,7 @@ function startHeartbeat(opts) {
     } catch {
       return null;
     }
-    const parsed = matter(source);
+    const parsed = matter3(source);
     const fm = parsed.data;
     const agent = typeof fm.agent === "string" ? fm.agent : null;
     if (!agent) return null;
@@ -4917,15 +6475,15 @@ async function startHttpServer(opts) {
     });
   });
   const bind = opts.bind ?? "127.0.0.1";
-  await new Promise((resolve8, reject) => {
+  await new Promise((resolve82, reject) => {
     server.once("error", reject);
-    server.listen(opts.port, bind, () => resolve8());
+    server.listen(opts.port, bind, () => resolve82());
   });
   return {
     url: `http://${bind}:${opts.port}`,
     async stop() {
       wss.close();
-      await new Promise((resolve8) => server.close(() => resolve8()));
+      await new Promise((resolve82) => server.close(() => resolve82()));
     }
   };
 }
@@ -6062,12 +7620,12 @@ function createSessionsRegistry(opts) {
       } catch {
       }
     }
-    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    const nowIso2 = (/* @__PURE__ */ new Date()).toISOString();
     for (const rt of sessions.values()) {
       rt.emitter.removeAllListeners();
       if (rt.desc.status === "running" || rt.desc.status === "starting") {
         rt.desc.status = "killed";
-        rt.desc.endedAt = nowIso;
+        rt.desc.endedAt = nowIso2;
         if (rt.agentSession) {
           void rt.agentSession.close().catch(() => void 0);
         }
@@ -6083,7 +7641,7 @@ function createSessionsRegistry(opts) {
     if (persist) {
       try {
         const snapshot = {
-          savedAt: nowIso,
+          savedAt: nowIso2,
           sessions: Array.from(sessions.values()).map((s) => s.desc)
         };
         mkdirSync(dirname(persistPath), { recursive: true });
@@ -6378,7 +7936,7 @@ var URL_REGEX = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
 var STARTUP_TIMEOUT_MS = 3e4;
 function quickTunnelProvider() {
   let child = null;
-  let configPath = null;
+  let configPath3 = null;
   return {
     id: "quick",
     async start(opts) {
@@ -6387,7 +7945,7 @@ function quickTunnelProvider() {
       const id = randomBytes(4).toString("hex");
       const dir = join(opts.workspace, ".agentproto");
       await mkdir(dir, { recursive: true });
-      configPath = join(dir, `cloudflared-${id}.yml`);
+      configPath3 = join(dir, `cloudflared-${id}.yml`);
       const configBody = [
         `# generated by agentproto-runtime \u2014 sentinel only`,
         `# overrides ~/.cloudflared/config.yml so its ingress rules`,
@@ -6397,14 +7955,14 @@ function quickTunnelProvider() {
         `loglevel: debug`,
         ``
       ].join("\n");
-      await writeFile(configPath, configBody, "utf8");
+      await writeFile(configPath3, configBody, "utf8");
       const proc = spawn(
         "cloudflared",
-        ["tunnel", "--config", configPath, "--url", targetUrl],
+        ["tunnel", "--config", configPath3, "--url", targetUrl],
         { stdio: ["ignore", "pipe", "pipe"], shell: false }
       );
       child = proc;
-      const url = await new Promise((resolve8, reject) => {
+      const url = await new Promise((resolve82, reject) => {
         let settled = false;
         const timer = setTimeout(() => {
           if (settled) return;
@@ -6429,7 +7987,7 @@ function quickTunnelProvider() {
           if (match) {
             settled = true;
             clearTimeout(timer);
-            resolve8(match[0]);
+            resolve82(match[0]);
           }
         };
         proc.stderr?.on("data", onData);
@@ -6460,9 +8018,9 @@ function quickTunnelProvider() {
     },
     async stop() {
       const proc = child;
-      const cfg = configPath;
+      const cfg = configPath3;
       child = null;
-      configPath = null;
+      configPath3 = null;
       if (cfg) {
         try {
           await rm(cfg, { force: true });
@@ -6478,15 +8036,15 @@ function quickTunnelProvider() {
         }
       }, 3e3);
       timer.unref();
-      await new Promise((resolve8) => {
+      await new Promise((resolve82) => {
         if (proc.exitCode !== null) {
           clearTimeout(timer);
-          resolve8();
+          resolve82();
           return;
         }
         proc.once("exit", () => {
           clearTimeout(timer);
-          resolve8();
+          resolve82();
         });
       });
     }
@@ -6565,7 +8123,7 @@ var RemoteController = class {
     let bearerTokenHash = "";
     if (exposesGateway) {
       bearerToken = randomBytes(32).toString("base64url");
-      bearerTokenHash = sha256(bearerToken);
+      bearerTokenHash = sha2562(bearerToken);
     }
     const state = {
       provider: providerId,
@@ -6630,7 +8188,7 @@ function pickProvider(id) {
   const _exhaustive = id;
   throw new Error(`unknown remote provider: ${String(_exhaustive)}`);
 }
-function sha256(input2) {
+function sha2562(input2) {
   return createHash("sha256").update(input2).digest("hex");
 }
 function errToMessage(err) {
@@ -6723,7 +8281,7 @@ var WorkspacePathError = class extends Error {
 };
 function createWorkspaceFs(opts) {
   const root = resolve(opts.workspace);
-  function resolvePath4(path) {
+  function resolvePath42(path) {
     if (typeof path !== "string" || path.length === 0) {
       throw new WorkspacePathError("path must be a non-empty string");
     }
@@ -6743,18 +8301,18 @@ function createWorkspaceFs(opts) {
   }
   return {
     async readFile(path) {
-      const abs = resolvePath4(path);
+      const abs = resolvePath42(path);
       const buf = await readFile(abs);
       return buf.toString("utf8");
     },
     async writeFile(path, content) {
-      const abs = resolvePath4(path);
+      const abs = resolvePath42(path);
       await mkdir(dirname(abs), { recursive: true });
       await writeFile(abs, content);
     },
     async exists(path) {
       try {
-        const abs = resolvePath4(path);
+        const abs = resolvePath42(path);
         return existsSync(abs);
       } catch {
         return false;
@@ -6959,8 +8517,8 @@ async function runServe(args) {
     values.workspace ?? cfgDaemon.workspace ?? process.cwd()
   );
   try {
-    const stat2 = await promises.stat(workspace);
-    if (!stat2.isDirectory()) {
+    const stat5 = await promises.stat(workspace);
+    if (!stat5.isDirectory()) {
       process.stderr.write(
         `agentproto serve: --workspace "${workspace}" is not a directory.
 `
@@ -7119,8 +8677,8 @@ ${color.dim}\u2500\u2500 shutting down (${signal}) \u2500\u2500${color.reset}
         AGENTPROTO_DAEMON_TOKEN: gateway.token
       }
     });
-    await new Promise((resolve7) => {
-      child.once("exit", () => resolve7());
+    await new Promise((resolve9) => {
+      child.once("exit", () => resolve9());
       aborter.signal.addEventListener("abort", () => {
         try {
           child.kill("SIGTERM");
@@ -7140,8 +8698,8 @@ ${color.dim}\u2500\u2500 shutting down (${signal}) \u2500\u2500${color.reset}
       `${color.dim}Press Ctrl-C to stop.${color.reset}
 `
     );
-    await new Promise((resolve7) => {
-      aborter.signal.addEventListener("abort", () => resolve7());
+    await new Promise((resolve9) => {
+      aborter.signal.addEventListener("abort", () => resolve9());
     });
     return 0;
   }
@@ -7160,7 +8718,7 @@ ${color.dim}\u2500\u2500 shutting down (${signal}) \u2500\u2500${color.reset}
         reconnectState.immediate = false;
         continue;
       }
-      await sleep2(2e3, aborter.signal);
+      await sleep3(2e3, aborter.signal);
     } catch (err) {
       if (aborter.signal.aborted) break;
       const msg = err instanceof Error ? err.message : String(err);
@@ -7169,7 +8727,7 @@ ${color.dim}\u2500\u2500 shutting down (${signal}) \u2500\u2500${color.reset}
   reconnecting in ${backoffMs}ms\u2026
 `
       );
-      await sleep2(backoffMs, aborter.signal);
+      await sleep3(backoffMs, aborter.signal);
       backoffMs = Math.min(backoffMs * 2, backoffMax);
     }
   }
@@ -7182,10 +8740,10 @@ async function runOneTunnel(opts, gateway, spawnPty, signal, reconnectState) {
   };
   if (opts.token) headers.authorization = `Bearer ${opts.token}`;
   const ws = new WebSocket2(opts.connect, { headers });
-  await new Promise((resolve7, reject) => {
+  await new Promise((resolve9, reject) => {
     const onOpen = () => {
       ws.off("error", onError);
-      resolve7();
+      resolve9();
     };
     const onError = (err) => {
       ws.off("open", onOpen);
@@ -7239,14 +8797,14 @@ async function runOneTunnel(opts, gateway, spawnPty, signal, reconnectState) {
         } catch {
         }
       }
-      return await new Promise((resolve7, reject) => {
+      return await new Promise((resolve9, reject) => {
         const sock = new WebSocket2(url, protocols ? [...protocols] : void 0, {
           headers: upstreamHeaders
         });
         const onceOpen = () => {
           sock.off("error", onceError);
           sock.off("unexpected-response", onceUnexpected);
-          resolve7({
+          resolve9({
             protocol: sock.protocol ?? "",
             send: (data, sendOpts) => {
               sock.send(data, { binary: sendOpts.binary });
@@ -7320,31 +8878,31 @@ async function runOneTunnel(opts, gateway, spawnPty, signal, reconnectState) {
       }
     }
   });
-  await new Promise((resolve7) => {
+  await new Promise((resolve9) => {
     const offClose = sink.onClose(() => {
       clearInterval(keepaliveInterval);
       offClose();
-      resolve7();
+      resolve9();
     });
     if (signal.aborted) {
       clearInterval(keepaliveInterval);
-      server.close().finally(() => resolve7());
+      server.close().finally(() => resolve9());
     }
     signal.addEventListener("abort", () => {
       clearInterval(keepaliveInterval);
-      server.close().finally(() => resolve7());
+      server.close().finally(() => resolve9());
     });
   });
   process.stderr.write(`agentproto serve: tunnel closed.
 `);
 }
-function sleep2(ms, signal) {
-  return new Promise((resolve7) => {
-    if (signal.aborted) return resolve7();
-    const timer = setTimeout(resolve7, ms);
+function sleep3(ms, signal) {
+  return new Promise((resolve9) => {
+    if (signal.aborted) return resolve9();
+    const timer = setTimeout(resolve9, ms);
     signal.addEventListener("abort", () => {
       clearTimeout(timer);
-      resolve7();
+      resolve9();
     });
   });
 }
@@ -7391,7 +8949,7 @@ var color = _isTty ? {
   cyan: "",
   red: ""
 };
-var USAGE3 = `agentproto workspace \u2014 manage local workspaces
+var USAGE4 = `agentproto workspace \u2014 manage local workspaces
 
 Usage:
   agentproto workspace add <path> [--slug <slug>] [--label <text>]
@@ -7404,7 +8962,7 @@ Config file: ${DEFAULT_CONFIG_PATH()}
 `;
 async function runWorkspace(args) {
   if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
-    process.stdout.write(USAGE3);
+    process.stdout.write(USAGE4);
     return 0;
   }
   const sub = args[0];
@@ -7414,7 +8972,7 @@ async function runWorkspace(args) {
       return runAdd(rest);
     case "list":
     case "ls":
-      return runList(rest);
+      return runList2(rest);
     case "remove":
     case "rm":
       return runRemove(rest);
@@ -7424,7 +8982,7 @@ async function runWorkspace(args) {
       process.stderr.write(
         `agentproto workspace: unknown subcommand '${sub}'
 
-${USAGE3}`
+${USAGE4}`
       );
       return 2;
   }
@@ -7469,7 +9027,7 @@ async function runAdd(args) {
   );
   return 0;
 }
-async function runList(args) {
+async function runList2(args) {
   const { values } = parseArgs({
     args: [...args],
     allowPositionals: false,
@@ -7619,7 +9177,7 @@ function probeMtimeLatestJsonl2(storeRel) {
 }
 
 // src/commands/sessions.ts
-var USAGE4 = `agentproto sessions \u2014 browse and control daemon sessions
+var USAGE5 = `agentproto sessions \u2014 browse and control daemon sessions
 
 Usage:
   agentproto sessions [--watch] [--json]
@@ -7643,7 +9201,7 @@ While attached:
 `;
 async function runSessions(args) {
   if (args.includes("--help") || args.includes("-h")) {
-    process.stdout.write(USAGE4);
+    process.stdout.write(USAGE5);
     return 0;
   }
   const sub = args[0];
@@ -7978,9 +9536,9 @@ function printNoDaemonError(report, verb) {
 }
 async function readRuntimeJsonWithStatus(workspacePath) {
   const path = resolve(workspacePath, ".agentproto", "runtime.json");
-  let stat2;
+  let stat5;
   try {
-    stat2 = await promises.stat(path);
+    stat5 = await promises.stat(path);
   } catch {
     return { endpoint: null };
   }
@@ -8003,7 +9561,7 @@ async function readRuntimeJsonWithStatus(workspacePath) {
       stale: {
         path,
         pid: parsed.pid ?? null,
-        mtime: stat2.mtime ?? null
+        mtime: stat5.mtime ?? null
       }
     };
   }
@@ -8804,7 +10362,7 @@ function stripAnsi(s) {
   return s.replace(/\x1b\[[0-9;]*m/g, "");
 }
 function httpDelete(url, token) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve9, reject) => {
     const u = new URL(url);
     const lib = u.protocol === "https:" ? https : http;
     const headers = {};
@@ -8820,7 +10378,7 @@ function httpDelete(url, token) {
           return;
         }
         try {
-          resolve7(raw ? JSON.parse(raw) : {});
+          resolve9(raw ? JSON.parse(raw) : {});
         } catch (err) {
           reject(err instanceof Error ? err : new Error(String(err)));
         }
@@ -9387,21 +10945,21 @@ async function runPtyAttach(endpoint, desc, _colour) {
   });
 }
 async function probeDaemonHealth(baseUrl) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     try {
       const u = new URL(`${baseUrl}/health`);
       const lib = u.protocol === "https:" ? https : http;
       const req = lib.get(u, { timeout: 500 }, (res) => {
-        resolve7((res.statusCode ?? 0) >= 200 && (res.statusCode ?? 0) < 300);
+        resolve9((res.statusCode ?? 0) >= 200 && (res.statusCode ?? 0) < 300);
         res.resume();
       });
-      req.on("error", () => resolve7(false));
+      req.on("error", () => resolve9(false));
       req.on("timeout", () => {
         req.destroy();
-        resolve7(false);
+        resolve9(false);
       });
     } catch {
-      resolve7(false);
+      resolve9(false);
     }
   });
 }
@@ -9441,7 +10999,7 @@ async function explain401(endpoint, verb) {
   return lines.join("\n");
 }
 function httpPostJson(url, body, token) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve9, reject) => {
     const u = new URL(url);
     const payload = Buffer.from(JSON.stringify(body), "utf8");
     const lib = u.protocol === "https:" ? https : http;
@@ -9464,7 +11022,7 @@ function httpPostJson(url, body, token) {
             return;
           }
           try {
-            resolve7(JSON.parse(raw));
+            resolve9(JSON.parse(raw));
           } catch (err) {
             reject(err instanceof Error ? err : new Error(String(err)));
           }
@@ -9480,7 +11038,7 @@ async function httpGetJson(url) {
   return await httpGetJsonImpl(url);
 }
 function httpGetJsonImpl(url) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve9, reject) => {
     const u = new URL(url);
     const lib = u.protocol === "https:" ? https : http;
     lib.get(u, (res) => {
@@ -9493,7 +11051,7 @@ function httpGetJsonImpl(url) {
           return;
         }
         try {
-          resolve7(JSON.parse(body));
+          resolve9(JSON.parse(body));
         } catch (err) {
           reject(err instanceof Error ? err : new Error(String(err)));
         }
@@ -9503,15 +11061,18 @@ function httpGetJsonImpl(url) {
 }
 
 // src/cli.ts
-var USAGE6 = `agentproto \u2014 AIP-45 agent CLI host
+var USAGE7 = `agentproto \u2014 AIP-45 agent CLI host
 
 Usage:
   agentproto auth      <login|status|logout> [--host <url>] [--label <name>]
   agentproto config    <show|path|get|set|unset|edit> [args]
   agentproto daemon    <install|uninstall|start|stop|status|logs> [args]
   agentproto install   <slug> [--force] [--dry-run] [--skip-setup]
+                       <slug> \u2208 { <adapter-slug> | runtime-profile/<name> }
+  agentproto plugins   <list|show|install|uninstall|enable|disable> [args]
   agentproto setup     <slug> [--force] [--dry-run] [--only <stepId>...]
   agentproto run       <slug> [--cwd <dir>] [--prompt <text>] [--resume <session-id>]
+  agentproto run-swarm --manifest <path> [--once] [--interval <ms|Ns>] [--verbose]
   agentproto serve     [--workspace <dir>] [--port <n>] [--bind <ip>]
                        [--connect <url> [--token <jwt>] [--label <name>]]
                        [--allow-origin <url> \u2026] [--interactive | -i]
@@ -9530,8 +11091,10 @@ Usage:
 Examples:
   agentproto auth login --host wss://guilde.work     # device flow \u2192 ~/.agentproto/credentials.json
   agentproto install claude-code
+  agentproto install runtime-profile/standard  # drops .claude/ swarm scaffolding into the cwd
   agentproto setup openclaw                # re-run setup (idempotent via skip_if + ledger)
   agentproto run claude-code --cwd . --prompt "summarise this repo"
+  agentproto run-swarm --manifest .runtime/local.yaml --verbose
   agentproto workspace add ~/code/my-project --slug my-project
   agentproto workspace list
   agentproto serve --connect wss://guilde.work/api/v1/agentproto/tunnel
@@ -9548,8 +11111,10 @@ var VERBS = /* @__PURE__ */ new Set([
   "config",
   "daemon",
   "install",
+  "plugins",
   "setup",
   "run",
+  "run-swarm",
   "serve",
   "workspace",
   "sessions"
@@ -9562,13 +11127,13 @@ async function main(argv) {
       return 0;
     }
     if (argv.includes("--help") || argv.includes("-h") || argv.length === 0) {
-      process.stdout.write(USAGE6);
+      process.stdout.write(USAGE7);
       return 0;
     }
     process.stderr.write(
       `agentproto: unrecognised argument(s): ${argv.join(" ")}
 
-${USAGE6}`
+${USAGE7}`
     );
     return 2;
   }
@@ -9585,10 +11150,14 @@ ${USAGE6}`
     }
     case "install":
       return runInstall(rest);
+    case "plugins":
+      return runPlugins(rest);
     case "setup":
       return runSetupCommand(rest);
     case "run":
       return runRun(rest);
+    case "run-swarm":
+      return runRunSwarm(rest);
     case "serve":
       return runServe(rest);
     case "workspace":
@@ -9598,7 +11167,7 @@ ${USAGE6}`
     default:
       process.stderr.write(`agentproto: unknown verb '${verb}'
 
-${USAGE6}`);
+${USAGE7}`);
       return 2;
   }
 }