godmode 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,18 +1,25 @@
 #!/usr/bin/env node
 import {
   execute
-} from "./chunk-I4WS4MMI.js";
+} from "./chunk-GJCJO7YT.js";
 import {
+  GODMODE_EXTENSIONS_DIR,
+  GODMODE_HOME,
   listApis,
   loadManifest,
+  loadMultiManifest,
   removeApi,
   updateApi,
   validateGraphQLFlags
-} from "./chunk-FBMQ3AC4.js";
+} from "./chunk-2J2VDCQ4.js";
 import {
   executeMcpTool,
   validateMcpFlags
-} from "./chunk-EHS56XXY.js";
+} from "./chunk-EXWYJU2I.js";
+
+// src/index.ts
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve5 } from "path";
 
 // src/env.ts
 import { readFileSync } from "fs";
@@ -35,7 +42,7 @@ function loadEnv() {
   }
 }
 
-// src/match.ts
+// ../../interfaces/api/src/match.ts
 function matchRoute(manifest, userSegments, method) {
   if (userSegments.length > 0) {
     const ver = manifest.versions.find((v) => v.name === userSegments[0]);
@@ -88,47 +95,73 @@ function suggestRoutes(manifest, userSegments) {
   });
 }
 
+// ../../interfaces/mcp/src/command.ts
+import { resolve as resolve2 } from "path";
+import { readFile } from "fs/promises";
+import { spawn } from "child_process";
+async function runMcp(rt, args) {
+  const name = args[0];
+  if (!name || name === "--help" || name === "-h") {
+    console.log(`Serve a registered API as an MCP server over stdio.
+
+Usage:
+  godmode mcp <name> [options]
+
+Options:
+  --filter <text>             Fuzzy-filter routes by resource name
+  --method <method>           Filter by HTTP method (get, post, etc.)
+
+For package-based extensions, spawns the extension's MCP server.
+For spec-based extensions, serves routes as MCP tools.`);
+    process.exit(name ? 0 : 1);
+  }
+  let filter;
+  let method;
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === "--filter" && args[i + 1]) filter = args[++i];
+    else if (args[i] === "--method" && args[i + 1]) method = args[++i];
+  }
+  const pkgName = name.startsWith("@") ? name : `@godmode-cli/${name}`;
+  const pkgDir = resolve2(rt.godmodeHome, "node_modules", pkgName);
+  const mcpConfigPath = resolve2(pkgDir, ".mcp.json");
+  try {
+    const mcpConfig = JSON.parse(await readFile(mcpConfigPath, "utf-8"));
+    const serverKey = Object.keys(mcpConfig.mcpServers)[0];
+    const server = mcpConfig.mcpServers[serverKey];
+    if (server.type === "stdio" && server.command) {
+      const child = spawn(server.command, server.args || [], {
+        stdio: "inherit",
+        cwd: pkgDir,
+        env: { ...process.env, ...server.env }
+      });
+      child.on("exit", (code) => process.exit(code ?? 0));
+      return;
+    }
+  } catch {
+  }
+  const manifest = await rt.loadManifest(name);
+  const { serveMcp } = await import("./server-4YVOAJJG.js");
+  await serveMcp(manifest, { filter, method });
+}
+
 // src/args.ts
+var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
 function parseArgs(args) {
   const segments = [];
   const headers = {};
   const query = {};
   const body = {};
   let method = "get";
-  let token;
+  let explicitMethod = false;
   let filter;
   let methodFilter;
   let all = false;
-  let verbose = false;
-  let dryRun = false;
+  const verbose = process.env.GODMODE_VERBOSE === "1";
+  const dryRun = process.env.GODMODE_DRY_RUN === "1";
   let help = false;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     switch (arg) {
-      // HTTP methods
-      case "-g":
-      case "--get":
-        method = "get";
-        break;
-      case "-po":
-      case "--post":
-        method = "post";
-        break;
-      case "-pu":
-      case "--put":
-        method = "put";
-        break;
-      case "-pa":
-      case "--patch":
-        method = "patch";
-        break;
-      case "-d":
-      case "--delete":
-        method = "delete";
-        break;
-      case "--head":
-        method = "head";
-        break;
       // Options
       case "-H":
       case "--header": {
@@ -137,25 +170,18 @@ function parseArgs(args) {
         if (idx > 0) headers[val.slice(0, idx).trim()] = val.slice(idx + 1).trim();
         break;
       }
-      case "--token":
-        token = args[++i];
-        break;
+      case "-F":
       case "--filter":
         filter = args[++i];
         break;
+      case "-X":
       case "--method":
         methodFilter = args[++i];
         break;
+      case "-A":
       case "--all":
         all = true;
         break;
-      case "-v":
-      case "--verbose":
-        verbose = true;
-        break;
-      case "--dry-run":
-        dryRun = true;
-        break;
       case "-h":
       case "--help":
         help = true;
@@ -166,6 +192,11 @@ function parseArgs(args) {
 `);
           process.exit(1);
         }
+        if (!segments.length && !explicitMethod && HTTP_METHODS.has(arg.toUpperCase())) {
+          method = arg.toLowerCase();
+          explicitMethod = true;
+          break;
+        }
         const eqeq = arg.indexOf("==");
         const eq = arg.indexOf("=");
         if (eqeq > 0) {
@@ -177,8 +208,7 @@ function parseArgs(args) {
         }
     }
   }
-  if (Object.keys(body).length && method === "get") method = "post";
-  return { segments, method, headers, query, body, token, filter, methodFilter, all, verbose, dryRun, help };
+  return { segments, method, explicitMethod, headers, query, body, filter, methodFilter, all, verbose, dryRun, help };
 }
 async function readStdin() {
   if (process.stdin.isTTY) return void 0;
@@ -190,6 +220,171 @@ async function readStdin() {
 
 // src/help.ts
 import fuzzysort from "fuzzysort";
+
+// ../cli-tools/src/index.ts
+var USE_COLOR = process.stdout.isTTY;
+var DIM = USE_COLOR ? "\x1B[2m" : "";
+var ITALIC = USE_COLOR ? "\x1B[3m" : "";
+var RESET = USE_COLOR ? "\x1B[0m" : "";
+var RED = USE_COLOR ? "\x1B[31m" : "";
+function visibleLength(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+function wrapText(text, width) {
+  if (text.length <= width) return [text];
+  const out = [];
+  let line = "";
+  for (const word of text.split(/\s+/)) {
+    if (!line) {
+      line = word;
+      continue;
+    }
+    if (line.length + 1 + word.length <= width) {
+      line += " " + word;
+    } else {
+      out.push(line);
+      line = word;
+    }
+  }
+  if (line) out.push(line);
+  return out;
+}
+function renderSections(sections, maxLineWidth = 80) {
+  const INDENT = "  ";
+  const GAP = "  ";
+  const flattened = sections.map((s) => {
+    if (!s.rows.length) return { title: s.title, rows: [] };
+    const cols = Math.max(...s.rows.map((r) => r.length));
+    const widths = Array(cols).fill(0);
+    for (const row of s.rows) {
+      for (let i = 0; i < cols; i++) {
+        widths[i] = Math.max(widths[i], visibleLength(row[i] ?? ""));
+      }
+    }
+    const rows = s.rows.map((row) => {
+      const left = row.slice(0, cols - 1).map((cell, i) => (cell ?? "") + " ".repeat(widths[i] - visibleLength(cell ?? ""))).join(GAP).replace(/\s+$/, "");
+      const desc = row[cols - 1] ?? "";
+      return [left, desc];
+    });
+    return { title: s.title, rows };
+  });
+  const allRows = flattened.flatMap((s) => s.rows);
+  if (!allRows.length) return;
+  const rowsWithDesc = allRows.filter((r) => r[1].length > 0);
+  const widthCandidates = (rowsWithDesc.length ? rowsWithDesc : allRows).map((r) => visibleLength(r[0]));
+  const globalLeft = Math.max(...widthCandidates);
+  const descBudget = Math.max(20, maxLineWidth - INDENT.length - globalLeft - GAP.length);
+  for (const s of flattened) {
+    if (!s.rows.length) continue;
+    if (s.title) {
+      console.log("");
+      console.log(s.title);
+    }
+    for (const [left, desc] of s.rows) {
+      const pad = " ".repeat(Math.max(0, globalLeft - visibleLength(left)));
+      const plain = desc.replace(/\x1b\[[0-9;]*m/g, "");
+      if (!plain) {
+        console.log(`${INDENT}${left}${pad}`.trimEnd());
+        continue;
+      }
+      if (plain.length <= descBudget) {
+        console.log(`${INDENT}${left}${pad}${GAP}${desc}`);
+        continue;
+      }
+      const italic = /^\x1b\[3m/.test(desc);
+      const wrap = (s2) => italic ? `${ITALIC}${s2}${RESET}` : s2;
+      const lines = wrapText(plain, Math.max(10, descBudget));
+      console.log(`${INDENT}${left}${pad}${GAP}${wrap(lines[0])}`);
+      for (let i = 1; i < lines.length; i++) {
+        console.log(`${INDENT}${" ".repeat(Math.max(0, globalLeft))}${GAP}${wrap(lines[i])}`);
+      }
+    }
+  }
+}
+function authMissingLabel(type) {
+  switch (type) {
+    case "api-key":
+      return "missing api-key";
+    case "basic":
+      return "missing basic auth credentials";
+    case "bearer":
+    default:
+      return "missing bearer token";
+  }
+}
+var HelpPage = class {
+  title() {
+    return null;
+  }
+  tagline() {
+    return null;
+  }
+  authNote() {
+    return null;
+  }
+  usage() {
+    return [];
+  }
+  sections() {
+    return [];
+  }
+  footer() {
+    return null;
+  }
+  toJSON() {
+    return {
+      title: this.title(),
+      tagline: this.tagline(),
+      authNote: this.authNote(),
+      usage: this.usage(),
+      sections: this.sections(),
+      footer: this.footer()
+    };
+  }
+  render() {
+    const d = this.toJSON();
+    let wrote = false;
+    if (d.title) {
+      console.log(d.title);
+      wrote = true;
+    }
+    if (d.tagline) {
+      if (wrote) console.log("");
+      console.log(d.tagline);
+      wrote = true;
+    }
+    if (d.authNote && !d.authNote.present) {
+      const arrow = USE_COLOR ? `${RED}-->${RESET}` : "-->";
+      const label = authMissingLabel(d.authNote.authType);
+      const body = USE_COLOR ? `${RED}${label}${RESET}` : label;
+      if (wrote) console.log("");
+      console.log(`${arrow} ${d.authNote.env}: ${body}`);
+      wrote = true;
+    }
+    if (d.usage.length) {
+      if (wrote) console.log("");
+      for (let i = 0; i < d.usage.length; i++) {
+        const prefix = i === 0 ? "Usage:" : "   or:";
+        console.log(`${prefix} ${d.usage[i]}`);
+      }
+      wrote = true;
+    }
+    renderSections(d.sections);
+    if (d.footer) {
+      if (d.footer.extras?.length) {
+        console.log("");
+        for (const line of d.footer.extras) console.log(line);
+      }
+      if (d.footer.reportBugs || d.footer.homepage) {
+        console.log("");
+        if (d.footer.reportBugs) console.log(`Report bugs to <${d.footer.reportBugs}>.`);
+        if (d.footer.homepage) console.log(`Godmode home page: <${d.footer.homepage}>.`);
+      }
+    }
+  }
+};
+
+// src/help.ts
 function buildTrie(routes) {
   const root = { name: "", isParam: false, methods: [], children: [] };
   for (const route of routes) {
@@ -243,42 +438,31 @@ function getChildren(node) {
   result.sort((a, b) => a.name.localeCompare(b.name));
   return result;
 }
-var ACTION_ORDER = ["list", "create", "get", "update", "delete"];
-var METHOD_LABEL = {
+var METHOD_LABEL = USE_COLOR ? {
   get: "\x1B[1;38;5;34mGET\x1B[0m",
   post: "\x1B[1;38;5;25mPOST\x1B[0m",
   put: "\x1B[1;38;5;172mPUT\x1B[0m",
   patch: "\x1B[1;38;5;30mPATCH\x1B[0m",
   delete: "\x1B[1;38;5;160mDELETE\x1B[0m"
+} : { get: "GET", post: "POST", put: "PUT", patch: "PATCH", delete: "DELETE" };
+var INTERFACE_LABEL = {
+  api: "API",
+  graphql: "GraphQL",
+  mcp: "MCP",
+  skill: "Skill"
 };
-var DIM = "\x1B[2m";
-var ITALIC = "\x1B[3m";
-var RESET = "\x1B[0m";
-function methodToAction(method, isResource) {
-  switch (method) {
-    case "get":
-      return isResource ? "get" : "list";
-    case "post":
-      return isResource ? "update" : "create";
-    case "put":
-    case "patch":
-      return "update";
-    case "delete":
-      return "delete";
-    default:
-      return method;
-  }
-}
-function getNodeActions(node) {
-  const actions = /* @__PURE__ */ new Set();
-  const paramChild = node.children.find((c) => c.isParam);
-  const isLeaf = !paramChild;
-  for (const ep of node.methods) actions.add(methodToAction(ep.method, isLeaf));
-  if (paramChild) {
-    for (const ep of paramChild.methods) actions.add(methodToAction(ep.method, true));
-  }
-  return [...actions].sort((a, b) => ACTION_ORDER.indexOf(a) - ACTION_ORDER.indexOf(b));
-}
+var titleCase = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+var ROOT_OPTION_ROWS = [
+  ["-v, --version", "output version information and exit"]
+];
+var INTERFACE_OPTION_ROWS = [
+  ["-H, --header <key:value>", "add a request header"],
+  ["-A, --all", "list all resources"],
+  ["-F, --filter <text>", "fuzzy-filter resources by name"],
+  ["-X, --method <verb>", "filter resources by HTTP method"],
+  ["-h, --help", "show help for this subcommand"],
+  ["-v, --version", "show extension spec versions"]
+];
 function getParamName(node) {
   return node.children.find((c) => c.isParam)?.name || null;
 }
@@ -290,251 +474,1208 @@ function methodLabels(node) {
   const order = ["get", "post", "put", "patch", "delete"];
   return order.filter((m) => methods.has(m)).map((m) => METHOD_LABEL[m]).join(" ");
 }
-function showHelp() {
-  console.log(`\u0262\u1D0F\u1D05\u1D0D\u1D0F\u1D05\u1D07
-\x1B[2mbetter than mcp\x1B[0m
-
-Usage:
-  godmode <api> <resource> [id] [flags]
-  godmode <api> /path [flags]
-
-Setup:
-  create                      Create own custom API entrypoint
-  add <name|file>             Add API as CLI command from <name>.yaml config
-  update <name>               Re-fetch OpenAPI spec and rebuild routes
-  remove <name>               Unregister an API
-  list                        Show all registered APIs
-  mcp <name>                  Serve registered API as MCP server (stdio)
-  ...                         Run \x1B[2mgodmode add --help\x1B[0m for config format
-
-Navigation:
-  <api> --help                Show resources, auth, and usage
-  <api> <resource> --help     Show operations and sub-resources
-
-Methods:
-  -g,  --get                  GET (default)
-  -po, --post                 POST
-  -pu, --put                  PUT
-  -pa, --patch                PATCH
-  -d,  --delete               DELETE
-
-Data (httpie-style):
-  key=value                   Body field (JSON, implies POST)
-  key==value                  Query param (URL)
-
-Options:
-  -H  <key:value>             Add header
-      --token <tok>            Auth token (overrides config)
-      --dry-run                Preview request without sending
-  -v, --verbose                Show full request/response
-
-Use "godmode <api> --help" for API-specific usage.`);
-}
-function showApiHelp(manifest, apiName, path, filter, methodFilter, all) {
-  const root = buildTrie(manifest.routes);
-  const nav = navigateTrie(root, path);
-  if (!nav) {
-    console.log("No matching resource.");
-    return;
+var RootHelp = class extends HelpPage {
+  tagline() {
+    return "A control surface of agentic I/O.";
   }
-  const { node, fullPath } = nav;
-  const actions = getNodeActions(node);
-  const param = getParamName(node);
-  const children = getChildren(node).filter((c) => !c.isParam);
-  const childNames = [...new Set(children.map((c) => c.name))];
-  const resourceName = fullPath.join(" ");
-  if (!path.length) {
-    const name = manifest.config.name || apiName;
-    const ver = manifest.specVersion ? ` \x1B[2mv${manifest.specVersion}\x1B[0m` : "";
-    const desc = manifest.description ? `
-\x1B[2m${manifest.description}\x1B[0m` : "";
-    console.log(`${name}${ver}${desc}
-`);
-    console.log(`Usage:
-  godmode ${apiName} <resource> [id] [flags]
-`);
-    const auth = manifest.config.auth;
-    if (auth?.env) {
-      const ok = !!process.env[auth.env];
-      const status = ok ? "\x1B[32m(token provided)\x1B[0m" : "\x1B[31m(missing token)\x1B[0m";
-      console.log(`${auth.env} ${status}
-`);
+  usage() {
+    return [
+      "godmode <extension> [args]...",
+      "godmode <extension> <interface> [args]..."
+    ];
+  }
+  sections() {
+    return [
+      { title: "Built-in extensions:", rows: [
+        ["ext", "Install and manage godmode extensions"],
+        ["agent", "Coding-agent workflows"]
+      ] },
+      { title: "Options:", rows: ROOT_OPTION_ROWS }
+    ];
+  }
+  footer() {
+    return {
+      extras: [
+        'Run "godmode ext list" to see installed extensions.',
+        'Run "godmode <extension> --help" for extension-specific usage.'
+      ],
+      reportBugs: "https://github.com/tomsiwik/godmode/issues",
+      homepage: "https://godmode.so"
+    };
+  }
+};
+var ExtensionOverview = class extends HelpPage {
+  constructor(multi) {
+    super();
+    this.multi = multi;
+  }
+  title() {
+    return titleCase(this.multi.name || this.multi.slug);
+  }
+  usage() {
+    const declared = Object.keys(this.multi.interfaces);
+    const args = (iface) => iface === "mcp" ? " <tool> [args]" : iface === "graphql" ? " <query> [flags]" : " <method> <resource> [id] [flags]";
+    return declared.map((iface) => `godmode ${this.multi.slug} ${iface}${args(iface)}`);
+  }
+  sections() {
+    const declared = Object.keys(this.multi.interfaces);
+    return [
+      { title: "Interfaces:", rows: declared.map((iface) => {
+        const d = this.multi.interfaces[iface];
+        const url = d && "url" in d && d.url ? d.url : "(local)";
+        return [iface, url];
+      }) },
+      { title: "Options:", rows: [["-v, --version", "show extension spec versions"]] }
+    ];
+  }
+};
+var ExtensionVersionPage = class extends HelpPage {
+  constructor(multi) {
+    super();
+    this.multi = multi;
+  }
+  title() {
+    return titleCase(this.multi.name || this.multi.slug);
+  }
+  sections() {
+    const declared = Object.keys(this.multi.interfaces);
+    return [
+      { title: "", rows: declared.map((iface) => {
+        const d = this.multi.interfaces[iface];
+        return [iface, d?.specVersion || "(unversioned)"];
+      }) }
+    ];
+  }
+};
+var InterfaceHelp = class extends HelpPage {
+  constructor(manifest, apiName, rawPath = [], opts = {}) {
+    super();
+    this.manifest = manifest;
+    this.apiName = apiName;
+    this.opts = opts;
+    const HTTP_VERBS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
+    const cleaned = [...rawPath];
+    while (cleaned.length && HTTP_VERBS.has(cleaned[cleaned.length - 1].toUpperCase())) {
+      cleaned.pop();
     }
-  } else {
-    const paramHint = getParamName(node);
+    this.path = cleaned;
+  }
+  path;
+  get ifaceType() {
+    return this.manifest.config.type;
+  }
+  getNav() {
+    const root = buildTrie(this.manifest.routes);
+    return navigateTrie(root, this.path);
+  }
+  title() {
+    if (this.path.length) return null;
+    return `${titleCase(this.manifest.config.name || this.apiName)} ${INTERFACE_LABEL[this.ifaceType] || this.ifaceType}`;
+  }
+  authNote() {
+    const auth = this.manifest.config.auth;
+    if (!auth?.env) return null;
+    return {
+      env: auth.env,
+      authType: auth.type || "bearer",
+      present: !!process.env[auth.env]
+    };
+  }
+  usage() {
+    if (!this.path.length) {
+      const multi = this.opts.multi;
+      const declared = multi ? Object.keys(multi.interfaces) : [this.ifaceType];
+      const ordered = [this.ifaceType, ...declared.filter((k) => k !== this.ifaceType)];
+      const args = (iface) => iface === "mcp" ? " <tool> [args]" : iface === "graphql" ? " <query> [flags]" : " <method> <resource> [id] [flags]";
+      return ordered.map((iface) => `godmode ${this.apiName} ${iface}${args(iface)}`);
+    }
+    const nav = this.getNav();
+    if (!nav) return [];
+    const paramHint = getParamName(nav.node);
     const idRef = paramHint ? ` [${paramHint}]` : "";
-    console.log(`Usage:
-  godmode ${apiName} ${resourceName}${idRef} [flags]
-`);
-    const auth = manifest.config.auth;
-    if (auth?.env) {
-      const ok = !!process.env[auth.env];
-      const status = ok ? "\x1B[32m(token provided)\x1B[0m" : "\x1B[31m(missing token)\x1B[0m";
-      console.log(`${auth.env} ${status}`);
-    }
-    for (const p of nav.params) {
-      const status = p.provided ? `\x1B[32m(${p.value})\x1B[0m` : "\x1B[31m(missing parameter)\x1B[0m";
-      console.log(`<${p.name}> ${status}`);
-    }
-    console.log("");
-    const mcpTools = manifest.config._mcpTools;
-    const mcpTool = mcpTools?.find((t) => t.name === path[path.length - 1]);
-    if (mcpTool?.inputSchema?.properties) {
-      const props = mcpTool.inputSchema.properties;
-      const required = new Set(mcpTool.inputSchema.required || []);
-      const toolName = mcpTool.name;
-      if (mcpTool.description) {
-        const first = mcpTool.description.split("\n")[0];
-        console.log(`${ITALIC}${first}${RESET}
-`);
-      }
-      console.log("Parameters:");
-      for (const [name, schema] of Object.entries(props)) {
-        const req = required.has(name) ? `\x1B[1;38;5;160m[REQUIRED]${RESET} ` : "";
-        const desc = schema.description ? `${DIM}${ITALIC}${schema.description}${RESET}` : "";
-        console.log(`  ${name.padEnd(28)}${req}${desc}`);
+    const methodSlot = this.ifaceType === "api" ? "<method> " : "";
+    return [`godmode ${this.apiName} ${this.ifaceType} ${methodSlot}${nav.fullPath.join(" ")}${idRef} [flags]`];
+  }
+  sections() {
+    const nav = this.getNav();
+    if (!nav) return [];
+    const sections = [];
+    if (!this.path.length) {
+      if (this.ifaceType === "api") {
+        const methodsPresent = new Set(this.manifest.routes.map((r) => r.method.toLowerCase()));
+        const METHOD_DESC = {
+          get: "retrieve a resource",
+          post: "create a resource or send a command",
+          put: "replace a resource",
+          patch: "modify a resource",
+          delete: "remove a resource",
+          head: "retrieve headers only"
+        };
+        const order = ["get", "post", "put", "patch", "delete", "head"];
+        const methodsHere = order.filter((m) => methodsPresent.has(m));
+        if (methodsHere.length) {
+          sections.push({
+            title: "Methods:",
+            rows: methodsHere.map((m) => [METHOD_LABEL[m] || m.toUpperCase(), METHOD_DESC[m]])
+          });
+        }
       }
-      console.log("");
-      console.log(`Example:
-  godmode ${apiName} ${toolName} ${[...required].map((r) => `${r}=...`).join(" ")}`);
-      console.log("");
     } else {
-      const order = ["get", "post", "put", "patch", "delete"];
-      const pc = node.children.find((c) => c.isParam);
-      const rows = [];
-      for (const ep of node.methods) {
-        rows.push({ method: ep.method, summary: ep.summary, needsId: false });
-      }
-      if (pc) {
-        for (const ep of pc.methods) {
-          rows.push({ method: ep.method, summary: ep.summary, needsId: true });
+      const mcpTools = this.manifest.config._mcpTools;
+      const mcpTool = mcpTools?.find((t) => t.name === this.path[this.path.length - 1]);
+      if (mcpTool?.inputSchema?.properties) {
+        const props = mcpTool.inputSchema.properties;
+        const required = new Set(mcpTool.inputSchema.required || []);
+        const rows = [];
+        for (const [name, schema] of Object.entries(props)) {
+          const req = required.has(name) ? `${RED}[REQUIRED]${RESET}` : "";
+          const desc = schema.description ? `${ITALIC}${schema.description}${RESET}` : "";
+          rows.push([name, req, desc]);
         }
-      }
-      if (rows.length) {
-        const lastSeg = path[path.length - 1] || resourceName;
-        const base = lastSeg;
-        const lines = [];
-        for (const m of order) {
-          for (const r of rows.filter((r2) => r2.method === m)) {
-            const id = r.needsId ? ` <${pc.name}>` : "";
-            let suffix = "";
-            if (m === "post" || m === "put" || m === "patch") suffix = " key=val";
-            if (m === "delete") suffix = " -d";
-            const needsFlag = !r.needsId && m !== "get" && m !== "post" || r.needsId && m === "post";
-            const flag = needsFlag ? ` -${m === "post" ? "po" : m === "put" ? "pu" : m === "patch" ? "pa" : ""}` : "";
-            const cmd = `${base}${id}${suffix}${flag}`.trim();
-            lines.push({ cmd, label: METHOD_LABEL[m] || m, desc: r.summary || "" });
+        sections.push({ title: "Parameters:", rows });
+      } else {
+        const order = ["get", "post", "put", "patch", "delete"];
+        const pc = nav.node.children.find((c) => c.isParam);
+        const items = [];
+        for (const ep of nav.node.methods) items.push({ method: ep.method, summary: ep.summary, needsId: false });
+        if (pc) for (const ep of pc.methods) items.push({ method: ep.method, summary: ep.summary, needsId: true });
+        if (items.length) {
+          const rows = [];
+          for (const m of order) {
+            for (const r of items.filter((r2) => r2.method === m)) {
+              const label = METHOD_LABEL[m] || m.toUpperCase();
+              const idArg = r.needsId ? `<${pc.name}>` : "";
+              const desc = r.summary ? `${ITALIC}${r.summary}${RESET}` : "";
+              rows.push([label, idArg, desc]);
+            }
           }
+          sections.push({ title: "Methods:", rows });
         }
-        const maxCmd = Math.max(...lines.map((l) => l.cmd.length));
-        for (const l of lines) {
-          const desc = l.desc ? `  ${ITALIC}${l.desc}${RESET}` : "";
-          console.log(`  ${l.cmd.padEnd(maxCmd + 2)}${l.label}${desc}`);
-        }
-        console.log("");
       }
     }
+    const children = getChildren(nav.node).filter((c) => !c.isParam);
+    const childNames = [...new Set(children.map((c) => c.name))];
+    const resourceSection = buildResourceSection(
+      children,
+      childNames,
+      this.manifest,
+      this.opts.filter,
+      this.opts.methodFilter,
+      this.opts.all
+    );
+    if (resourceSection) sections.push(resourceSection.section);
+    sections.push({ title: "Options:", rows: INTERFACE_OPTION_ROWS });
+    return sections;
   }
-  if (childNames.length) {
-    const ALL_METHODS = ["get", "post", "put", "patch", "delete"];
-    const mf = methodFilter ? fuzzysort.go(methodFilter, ALL_METHODS)[0]?.target : void 0;
-    if (methodFilter && !mf) {
-      console.log(`
-No method matching "${methodFilter}".`);
-      return;
+  /** Drilled-in view also shows param status lines (ANSI-only). */
+  render() {
+    super.render();
+  }
+};
+function showHelp() {
+  new RootHelp().render();
+}
+function showExtensionOverview(multi) {
+  new ExtensionOverview(multi).render();
+}
+function showExtensionVersion(multi) {
+  new ExtensionVersionPage(multi).render();
+}
+function showApiHelp(manifest, apiName, path, filter, methodFilter, all, multi) {
+  new InterfaceHelp(manifest, apiName, path, { multi, filter, methodFilter, all }).render();
+}
+async function showVersion() {
+  const { readFile: readFile2 } = await import("fs/promises");
+  const { resolve: resolve6, dirname } = await import("path");
+  const { fileURLToPath } = await import("url");
+  const root = resolve6(dirname(fileURLToPath(import.meta.url)), "..");
+  const pkg = JSON.parse(await readFile2(resolve6(root, "package.json"), "utf-8"));
+  const license = await readFile2(resolve6(root, "LICENSE"), "utf-8");
+  const copyright = license.match(/^Copyright.*$/m)?.[0] ?? "";
+  console.log(`godmode ${pkg.version}
+
+${pkg.license} License
+${copyright}`);
+}
+function buildResourceSection(children, childNames, manifest, filter, methodFilter, all) {
+  if (!childNames.length) return null;
+  const ALL_METHODS = ["get", "post", "put", "patch", "delete"];
+  const mf = methodFilter ? fuzzysort.go(methodFilter, ALL_METHODS)[0]?.target : void 0;
+  if (methodFilter && !mf) return null;
+  const candidates = mf ? childNames.filter((n) => {
+    const child = children.find((c) => c.name === n);
+    if (!child) return false;
+    const methods = /* @__PURE__ */ new Set();
+    for (const ep of child.methods) methods.add(ep.method);
+    const pc = child.children.find((c) => c.isParam);
+    if (pc) for (const ep of pc.methods) methods.add(ep.method);
+    return methods.has(mf);
+  }) : childNames;
+  const filtered = filter ? fuzzysort.go(filter, candidates).map((r) => r.target) : candidates;
+  const title = filter || mf ? `Resources${filter ? ` matching "${filter}"` : ""}${mf ? ` with ${mf.toUpperCase()}` : ""}:` : "Resources:";
+  if (!filtered.length) return { section: { title, rows: [["  No matches.", ""]] } };
+  const limit = filter || mf || all ? filtered.length : 5;
+  const shown = filtered.slice(0, limit);
+  const more = filtered.length - shown.length;
+  const rows = [];
+  for (const n of shown) {
+    const child = children.find((c) => c.name === n);
+    const labels = child ? methodLabels(child) : "";
+    const subCount = child ? getChildren(child).filter((c) => !c.isParam).length : 0;
+    const sub = subCount ? `(${subCount} sub)` : "";
+    const rawDesc = manifest.resourceDescriptions[n] || "";
+    const desc = rawDesc ? `${ITALIC}${rawDesc}${RESET}` : "";
+    const parts = [labels, sub, desc].filter(Boolean);
+    rows.push([n, parts.join("  ")]);
+  }
+  if (more) {
+    const verb = mf ? ` ${mf.toUpperCase()}` : "";
+    const hintText = `${more} more${verb} resources. Use options to display more`;
+    const dots = USE_COLOR ? `${DIM}...${RESET}` : "...";
+    const body = USE_COLOR ? `${DIM}${hintText}${RESET}` : hintText;
+    rows.push([dots, body]);
+  }
+  return { section: { title, rows } };
+}
+
+// ../../commands/agent/dist/index.js
+import { spawnSync } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+import { closeSync, existsSync as existsSync2, openSync, readFileSync as readFileSync2, readSync, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve22 } from "path";
+import { randomUUID } from "crypto";
+import { mkdirSync, readFileSync as readFileSync4, writeFileSync, existsSync, readdirSync } from "fs";
+import { homedir } from "os";
+import { resolve as resolve4 } from "path";
+var DEFAULT_HARNESS_ORDER = ["claude", "codex", "gemini", "pi"];
+var HARNESSES = {
+  claude: {
+    id: "claude",
+    displayName: "Claude Code",
+    command: "claude",
+    modelFlags: ["--model"],
+    effortFlags: ["--effort"],
+    helpArgs: ["--help"],
+    promptHints: ["[prompt]", "your prompt"],
+    buildTurnArgs: ({ prompt, model, effort, passthroughArgs, resumeToken }) => [
+      "-p",
+      "--verbose",
+      "--output-format",
+      "stream-json",
+      ...resumeToken ? ["--resume", resumeToken] : [],
+      ...model ? ["--model", model] : [],
+      ...effort ? ["--effort", effort] : [],
+      prompt,
+      ...passthroughArgs
+    ]
+  },
+  codex: {
+    id: "codex",
+    displayName: "Codex CLI",
+    command: "codex",
+    modelFlags: ["-m", "--model"],
+    effortFlags: [],
+    helpArgs: ["--help"],
+    promptHints: ["[prompt]", "optional user prompt"],
+    buildTurnArgs: ({ prompt, model, passthroughArgs }) => [
+      "exec",
+      "--json",
+      ...model ? ["-m", model] : [],
+      prompt,
+      ...passthroughArgs
+    ]
+  },
+  gemini: {
+    id: "gemini",
+    displayName: "Gemini CLI",
+    command: "gemini",
+    modelFlags: ["-m", "--model"],
+    effortFlags: [],
+    helpArgs: ["--help"],
+    promptHints: ["query", "initial prompt"],
+    buildTurnArgs: ({ prompt, model, passthroughArgs, resumeToken }) => [
+      ...resumeToken ? ["--resume", resumeToken] : [],
+      ...model ? ["-m", model] : [],
+      "-p",
+      prompt,
+      "-o",
+      "stream-json",
+      ...passthroughArgs
+    ]
+  },
+  pi: {
+    id: "pi",
+    displayName: "Pi",
+    command: "pi",
+    modelFlags: ["--model"],
+    effortFlags: ["--thinking"],
+    helpArgs: ["--help"],
+    promptHints: ["[messages...]", "initial prompt"],
+    buildTurnArgs: ({ prompt, model, effort, passthroughArgs, resumeToken, sessionDir }) => [
+      "--print",
+      "--mode",
+      "json",
+      ...sessionDir ? ["--session-dir", sessionDir] : [],
+      ...resumeToken ? ["--continue"] : [],
+      ...model ? ["--model", model] : [],
+      ...effort ? ["--thinking", effort] : [],
+      prompt,
+      ...passthroughArgs
+    ]
+  }
+};
+function detectHarness(executor, requested) {
+  const ids = requested ? [requested] : DEFAULT_HARNESS_ORDER;
+  for (const id of ids) {
+    const harness = HARNESSES[id];
+    const result = executor(harness.command, harness.helpArgs);
+    if (!result.error && result.status === 0) return harness;
+  }
+  throw new Error(requested ? `Harness "${requested}" not found.` : "No supported coding harness found.");
+}
+function event(ts, id, turn, partial) {
+  return { ts, id, turn, ...partial };
+}
+function normalizeTurn(harness, id, turn, stdout, stderr, ts) {
+  const lines = stdout.split(/\r?\n/);
+  if (harness === "claude") return parseClaude(lines, id, turn, stderr, ts);
+  if (harness === "gemini") return parseGemini(lines, id, turn, stderr, ts);
+  if (harness === "pi") return parsePi(lines, id, turn, stderr, ts);
+  return {
+    sessionId: null,
+    assistantText: stdout.trim(),
+    events: [
+      event(ts, id, turn, { type: "turn.started" }),
+      event(ts, id, turn, { type: "assistant.completed", text: stdout.trim() }),
+      event(ts, id, turn, { type: "turn.completed", status: "completed" })
+    ]
+  };
+}
+function parseClaude(lines, id, turn, stderr, ts) {
+  const events = [];
+  let sessionId = null;
+  let assistantText = "";
+  let usage;
+  let timing;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
     }
-    let candidates = mf ? childNames.filter((n) => {
-      const child = children.find((c) => c.name === n);
-      if (!child) return false;
-      const methods = /* @__PURE__ */ new Set();
-      for (const ep of child.methods) methods.add(ep.method);
-      const pc = child.children.find((c) => c.isParam);
-      if (pc) for (const ep of pc.methods) methods.add(ep.method);
-      return methods.has(mf);
-    }) : childNames;
-    const filtered = filter ? fuzzysort.go(filter, candidates).map((r) => r.target) : candidates;
-    const prefix = `godmode ${apiName}${resourceName ? " " + resourceName : ""}`;
-    const label = filter || mf ? `Resources${filter ? ` matching "${filter}"` : ""}${mf ? ` with ${mf.toUpperCase()}${methodFilter !== mf ? ` (matched "${methodFilter}")` : ""}` : ""}:` : "Resources:";
-    console.log(`
-${label}`);
-    if (!filtered.length) {
-      console.log("  No matches.");
-    } else {
-      const limit = filter || mf || all ? filtered.length : 5;
-      const shown = filtered.slice(0, limit);
-      const more = filtered.length - shown.length;
-      for (const n of shown) {
-        const child = children.find((c) => c.name === n);
-        const labels = child ? methodLabels(child) : "";
-        const subCount = child ? getChildren(child).filter((c) => !c.isParam).length : 0;
-        const sub = subCount ? `  ${DIM}(${subCount} sub)${RESET}` : "";
-        const rawDesc = manifest.resourceDescriptions[n] || "";
-        const truncated = rawDesc.length > 60 ? rawDesc.slice(0, 57) + "..." : rawDesc;
-        const descStr = truncated ? `  ${ITALIC}${truncated}${RESET}` : "";
-        console.log(`  ${n.padEnd(28)}${labels}${sub}${descStr}`);
+    if (parsed.type === "system" && parsed.subtype === "init") {
+      sessionId = parsed.session_id ?? sessionId;
+      events.push(event(ts, id, turn, { type: "turn.started" }));
+      events.push(event(ts, id, turn, { type: "state.changed", state: "starting" }));
+    }
+    if (parsed.type === "assistant") {
+      const text = (parsed.message?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("");
+      if (text) assistantText = text;
+      if (text) events.push(event(ts, id, turn, { type: "assistant.completed", text }));
+    }
+    if (parsed.type === "result") {
+      sessionId = parsed.session_id ?? sessionId;
+      usage = {
+        inputTokens: parsed.usage?.input_tokens,
+        outputTokens: parsed.usage?.output_tokens,
+        cachedTokens: parsed.usage?.cache_read_input_tokens
+      };
+      timing = { durationMs: parsed.duration_ms };
+      events.push(event(ts, id, turn, { type: "turn.completed", status: parsed.is_error ? "failed" : "completed" }));
+    }
+  }
+  for (const line of stderr.split(/\r?\n/).filter(Boolean)) events.push(event(ts, id, turn, { type: "warning", message: line }));
+  return { sessionId, assistantText, events, usage, timing };
+}
+function parseGemini(lines, id, turn, stderr, ts) {
+  const events = [];
+  let sessionId = null;
+  let assistantText = "";
+  let usage;
+  let timing;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (parsed.type === "init") {
+      sessionId = parsed.session_id ?? sessionId;
+      events.push(event(ts, id, turn, { type: "turn.started" }));
+      events.push(event(ts, id, turn, { type: "state.changed", state: "starting" }));
+    }
+    if (parsed.type === "message" && parsed.role === "assistant" && parsed.delta === true && typeof parsed.content === "string") {
+      assistantText += parsed.content;
+      events.push(event(ts, id, turn, { type: "assistant.delta", text: parsed.content }));
+    }
+    if (parsed.type === "result") {
+      usage = {
+        inputTokens: parsed.stats?.input_tokens,
+        outputTokens: parsed.stats?.output_tokens,
+        cachedTokens: parsed.stats?.cached,
+        totalTokens: parsed.stats?.total_tokens
+      };
+      timing = { durationMs: parsed.stats?.duration_ms };
+      events.push(event(ts, id, turn, { type: "assistant.completed", text: assistantText }));
+      events.push(event(ts, id, turn, { type: "turn.completed", status: parsed.status === "success" ? "completed" : "failed" }));
+    }
+  }
+  for (const line of stderr.split(/\r?\n/).filter(Boolean)) events.push(event(ts, id, turn, { type: "warning", message: line }));
+  return { sessionId, assistantText, events, usage, timing };
+}
+function parsePi(lines, id, turn, stderr, ts) {
+  const events = [];
+  let sessionId = null;
+  let assistantText = "";
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (parsed.type === "session") {
+      sessionId = parsed.id ?? sessionId;
+      events.push(event(ts, id, turn, { type: "turn.started" }));
+      events.push(event(ts, id, turn, { type: "state.changed", state: "starting" }));
+    }
+    if (parsed.type === "turn_start") events.push(event(ts, id, turn, { type: "state.changed", state: "running" }));
+    if (parsed.type === "message_update" && parsed.assistantMessageEvent?.type === "thinking_start") {
+      events.push(event(ts, id, turn, { type: "state.changed", state: "thinking" }));
+    }
+    if (parsed.type === "message_update" && parsed.assistantMessageEvent?.type === "text_delta") {
+      const delta = parsed.assistantMessageEvent.delta ?? "";
+      assistantText += delta;
+      if (delta) events.push(event(ts, id, turn, { type: "assistant.delta", text: delta }));
+    }
+    if (parsed.type === "turn_end") {
+      const text = (parsed.message?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("");
+      if (text) assistantText = text;
+      events.push(event(ts, id, turn, { type: "assistant.completed", text: assistantText }));
+      events.push(event(ts, id, turn, { type: "turn.completed", status: "completed" }));
+    }
+  }
+  for (const line of stderr.split(/\r?\n/).filter(Boolean)) events.push(event(ts, id, turn, { type: "warning", message: line }));
+  return { sessionId, assistantText, events };
+}
+var GODMODE_HOME2 = process.platform === "linux" && process.env.XDG_CONFIG_HOME ? resolve4(process.env.XDG_CONFIG_HOME, "godmode") : resolve4(homedir(), ".godmode");
+var CODING_AGENTS_HOME = resolve4(GODMODE_HOME2, "coding-agents");
+var RUNS_DIR = resolve4(CODING_AGENTS_HOME, "runs");
+var ACTIVE_RUNS_PATH = resolve4(CODING_AGENTS_HOME, "active-runs.json");
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function ensureDirs() {
+  mkdirSync(RUNS_DIR, { recursive: true });
+}
+function shellEscape(value) {
+  return `'${value.replace(/'/g, `"'"'`)}'`;
+}
+function writeJson(path, value) {
+  mkdirSync(resolve4(path, ".."), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync4(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function readSettingsFile(path) {
+  return readJson(path) ?? {};
+}
+function loadSettings(cwd = process.cwd()) {
+  const globalSettings = readSettingsFile(resolve4(GODMODE_HOME2, "settings.json"));
+  const projectSettings = readSettingsFile(resolve4(cwd, ".godmode", "settings.json"));
+  return {
+    ...globalSettings,
+    ...projectSettings,
+    plugins: {
+      ...globalSettings.plugins ?? {},
+      ...projectSettings.plugins ?? {},
+      "coding-agents": {
+        ...globalSettings.plugins?.["coding-agents"] ?? {},
+        ...projectSettings.plugins?.["coding-agents"] ?? {}
       }
-      if (more) {
-        console.log(`  \x1B[2m...${more} more \u2192 use --all, --filter or --method\x1B[0m`);
+    }
+  };
+}
+function loadActiveRuns() {
+  return readJson(ACTIVE_RUNS_PATH) ?? {};
+}
+function saveActiveRun(cwd, id) {
+  const current = loadActiveRuns();
+  current[cwd] = id;
+  writeJson(ACTIVE_RUNS_PATH, current);
+}
+function activeRunIdForCwd(cwd) {
+  return loadActiveRuns()[cwd] ?? null;
+}
+function runDir(id) {
+  return resolve4(RUNS_DIR, id);
+}
+function runPath(id) {
+  return resolve4(runDir(id), "run.json");
+}
+function turnDir(id, turn) {
+  return resolve4(runDir(id), "turns", String(turn).padStart(4, "0"));
+}
+function loadRun(id) {
+  const run = readJson(runPath(id));
+  if (!run) throw new Error(`Run not found: ${id}`);
+  return run;
+}
+function saveRun(run) {
+  run.updatedAt = timestamp();
+  writeJson(runPath(run.id), run);
+}
+function listRuns() {
+  ensureDirs();
+  return readdirSync(RUNS_DIR, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => readJson(runPath(entry.name))).filter((value) => !!value).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+function createRun(cwd, harness, model, effort) {
+  ensureDirs();
+  const id = `run-${Date.now()}-${randomUUID().slice(0, 8)}`;
+  const run = {
+    id,
+    cwd,
+    harness: harness.id,
+    harnessName: harness.displayName,
+    sessions: {
+      zmx: `godmode-agent-${harness.id}-${id.replace(/^run-/, "")}`
+    },
+    model: model ?? null,
+    effort: effort ?? null,
+    status: "idle",
+    createdAt: timestamp(),
+    updatedAt: timestamp(),
+    lastTurn: 0
+  };
+  mkdirSync(runDir(id), { recursive: true });
+  mkdirSync(resolve4(runDir(id), "turns"), { recursive: true });
+  saveRun(run);
+  saveActiveRun(cwd, id);
+  return run;
+}
+function buildShellCommand(harness, run, turn, prompt, passthroughArgs) {
+  const dir = turnDir(run.id, turn);
+  mkdirSync(dir, { recursive: true });
+  const stdoutPath = resolve4(dir, "stdout.log");
+  const stderrPath = resolve4(dir, "stderr.log");
+  const exitCodePath = resolve4(dir, "exit-code.txt");
+  const sessionDir = resolve4(runDir(run.id), "pi-session");
+  mkdirSync(sessionDir, { recursive: true });
+  const args = harness.buildTurnArgs({
+    prompt,
+    model: run.model ?? void 0,
+    effort: run.effort ?? void 0,
+    passthroughArgs,
+    resumeToken: run.sessions[run.harness] ?? void 0,
+    sessionDir
+  });
+  const command = `${[harness.command, ...args].map(shellEscape).join(" ")} > ${shellEscape(stdoutPath)} 2> ${shellEscape(stderrPath)}`;
+  const shell = `${command}; code=$?; printf '%s' "$code" > ${shellEscape(exitCodePath)}; exit "$code"`;
+  return { shell, stdoutPath, stderrPath, exitCodePath };
+}
+function waitForFile(path, timeoutMs = 3e5) {
+  const started = Date.now();
+  while (!existsSync(path)) {
+    if (Date.now() - started > timeoutMs) throw new Error(`Timed out waiting for ${path}`);
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
+  }
+}
+function latestTurn(run) {
+  if (run.lastTurn < 1) throw new Error(`Run ${run.id} has no turns yet.`);
+  const turn = readJson(resolve4(turnDir(run.id, run.lastTurn), "normalized.json"));
+  if (!turn) throw new Error(`Turn ${run.lastTurn} not found for ${run.id}`);
+  return turn;
+}
+function resolveRunId(cwd, explicit) {
+  if (explicit) return explicit;
+  const active = activeRunIdForCwd(cwd);
+  if (!active) throw new Error(`No active coding-agent run for ${cwd}`);
+  return active;
+}
+function renderTurn(turn, outputMode) {
+  if (outputMode === "assistant-text") return turn.assistant.text;
+  if (outputMode === "raw") {
+    const stdout = existsSync2(turn.paths.stdout) ? readFileSync2(turn.paths.stdout, "utf-8") : "";
+    const stderr = existsSync2(turn.paths.stderr) ? readFileSync2(turn.paths.stderr, "utf-8") : "";
+    return JSON.stringify({ stdout, stderr }, null, 2);
+  }
+  if (outputMode === "events") {
+    return existsSync2(turn.paths.events) ? readFileSync2(turn.paths.events, "utf-8").trimEnd() : "";
+  }
+  return JSON.stringify(turn, null, 2);
+}
+function renderStatus(run) {
+  return JSON.stringify(run, null, 2);
+}
+function writeEvents(path, events) {
+  writeFileSyncSafe(path, `${events.map((event2) => JSON.stringify(event2)).join("\n")}
+`);
+}
+function writeFileSyncSafe(path, content) {
+  writeFileSync2(path, content);
+}
+function attachHelp() {
+  return [
+    "Usage: godmode agent attach run <id>",
+    "   or: godmode agent attach session <zmx-session-id>"
+  ].join("\n");
+}
+var AgentHelp = class extends HelpPage {
+  usage() {
+    return [
+      "godmode agent start [--harness <name>] [--model <id>] <prompt>",
+      "godmode agent send  [--harness <name>] [--model <id>] <prompt>",
+      "godmode agent attach run <id>",
+      "godmode agent attach session <session-id>",
+      "godmode agent output [id] [--json|--assistant-text|--events|--raw]",
+      "godmode agent status [id]",
+      "godmode agent list"
+    ];
+  }
+  sections() {
+    return [
+      { title: "Options:", rows: [
+        ["    --harness <name>", "coding agent harness (claude, codex, gemini, etc.)"],
+        ["    --model <id>", "model identifier passed to the harness"],
+        ["    --effort <level>", "effort level passed to the harness"],
+        ["    --json", "output machine-readable events"],
+        ["    --follow", "stream output until the run completes"]
+      ] },
+      { title: "Shortcuts:", rows: [
+        ["godmode agent <prompt>", "send prompt to active run, or start a new run"]
+      ] }
+    ];
+  }
+};
+function agentHelp() {
+  const lines = [];
+  const origLog = console.log;
+  console.log = (...args) => {
+    lines.push(args.join(" "));
+  };
+  try {
+    new AgentHelp().render();
+  } finally {
+    console.log = origLog;
+  }
+  return lines.join("\n");
+}
+function followOutput(run, turn, outputMode, writer) {
+  const dir = turnDir(run.id, turn);
+  const stdoutPath = resolve22(dir, "stdout.log");
+  const stderrPath = resolve22(dir, "stderr.log");
+  const statePath = runPath(run.id);
+  let assistant = "";
+  const emit = (event2) => {
+    if (outputMode === "events") writer.write(`${JSON.stringify(event2)}
+`);
+    if (outputMode === "assistant-text") {
+      if (event2.type === "assistant.delta" && event2.text) writer.write(event2.text);
+      if (event2.type === "assistant.completed" && !assistant && event2.text) writer.write(event2.text);
+    }
+  };
+  streamFile(stdoutPath, (line) => {
+    const normalized = normalizeTurn(run.harness, run.id, turn, `${line}
+`, "", timestamp());
+    for (const event2 of normalized.events) {
+      if (event2.type === "assistant.delta" && event2.text) assistant += event2.text;
+      emit(event2);
+    }
+  }, () => (readJson2(statePath)?.status ?? "completed") === "running");
+  if (outputMode === "assistant-text") writer.write("\n");
+  if (outputMode === "events" && existsSync2(stderrPath)) {
+    for (const line of readFileSync2(stderrPath, "utf-8").split(/\r?\n/).filter(Boolean)) {
+      writer.write(`${JSON.stringify({ ts: timestamp(), id: run.id, turn, type: "warning", message: line })}
+`);
+    }
+  }
+}
+function streamFile(path, onLine, until) {
+  let offset = 0;
+  let pending = "";
+  while (true) {
+    if (existsSync2(path)) {
+      const size = statSync(path).size;
+      if (size > offset) {
+        const fd = openSync(path, "r");
+        const buffer = Buffer.alloc(size - offset);
+        try {
+          const bytes = buffer.length ? readSync(fd, buffer, 0, buffer.length, offset) : 0;
+          offset += bytes;
+          pending += buffer.toString("utf-8", 0, bytes);
+          const lines = pending.split(/\r?\n/);
+          pending = lines.pop() ?? "";
+          for (const line of lines) if (line) onLine(line);
+        } finally {
+          closeSync(fd);
+        }
       }
     }
-    console.log(`
-Use "${prefix} <resource> --help" for more.`);
+    if (!until()) {
+      if (pending) onLine(pending);
+      return;
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
+  }
+}
+function readJson2(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function defaultExecutor(command, args, stdio = "pipe") {
+  const spawnStdio = stdio === "inherit" ? "inherit" : "pipe";
+  const result = spawnSync(command, args, { encoding: "utf-8", stdio: spawnStdio });
+  return {
+    status: result.status,
+    stdout: stdio === "pipe" && typeof result.stdout === "string" ? result.stdout : "",
+    stderr: stdio === "pipe" && typeof result.stderr === "string" ? result.stderr : "",
+    error: result.error ?? void 0
+  };
+}
+function parseOutputMode(args) {
+  let outputMode = "json";
+  let follow = false;
+  const remaining = [];
+  for (const arg of args) {
+    if (arg === "--json") outputMode = "json";
+    else if (arg === "--assistant-text") outputMode = "assistant-text";
+    else if (arg === "--events") outputMode = "events";
+    else if (arg === "--raw") outputMode = "raw";
+    else if (arg === "--follow") follow = true;
+    else remaining.push(arg);
+  }
+  return { outputMode, follow, remaining };
+}
+function parseStartSendArgs(action, argv) {
+  const { outputMode, remaining } = parseOutputMode(argv);
+  let harness;
+  let model;
+  let effort;
+  let passthroughArgs = [];
+  const promptParts = [];
+  for (let i = 0; i < remaining.length; i++) {
+    const arg = remaining[i];
+    if (arg === "--") {
+      passthroughArgs = remaining.slice(i + 1);
+      break;
+    }
+    if (arg === "--harness") {
+      const value = remaining[++i];
+      if (!value || !(value in HARNESSES)) throw new Error("Missing or invalid value for --harness");
+      harness = value;
+      continue;
+    }
+    if (arg === "--model") {
+      model = remaining[++i];
+      if (!model) throw new Error("Missing value for --model");
+      continue;
+    }
+    if (arg === "--effort") {
+      effort = remaining[++i];
+      if (!effort) throw new Error("Missing value for --effort");
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") throw new Error(agentHelp());
+    if (arg.startsWith("-")) throw new Error(`Unknown flag: ${arg}. Use -- to pass flags through to the native harness.`);
+    promptParts.push(arg);
+  }
+  return { action, prompt: promptParts.join(" ").trim(), harness, model, effort, passthroughArgs, outputMode };
+}
+function parseOutputArgs(argv) {
+  const { outputMode, follow, remaining } = parseOutputMode(argv);
+  return { outputMode, follow, id: remaining.find((arg) => !arg.startsWith("-")) };
+}
+function classifyStatus(exitCode, stdout, stderr) {
+  const text = `${stdout}
+${stderr}`.toLowerCase();
+  if (exitCode === 0) return "completed";
+  if (text.includes("auth") || text.includes("api key") || text.includes("permission") || text.includes("may not exist")) return "blocked";
+  return "failed";
+}
+function resolveRunAndHarness(parsed, executor, cwd, options) {
+  const settings = options.settings ?? loadSettings(cwd);
+  const plugin = settings.plugins?.["coding-agents"];
+  const requestedHarnessId = parsed.harness ?? plugin?.harness;
+  let model = parsed.model ?? plugin?.model;
+  let effort = parsed.effort ?? plugin?.effort;
+  let run;
+  let harness;
+  if (parsed.action === "start") {
+    harness = detectHarness(executor, requestedHarnessId);
+    if (effort && harness.effortFlags.length === 0) throw new Error(`Harness "${harness.id}" does not support --effort.`);
+    run = createRun(cwd, harness, model, effort);
+  } else {
+    const active = activeRunIdForCwd(cwd);
+    if (active) {
+      run = loadRun(active);
+      if (parsed.harness && parsed.harness !== run.harness) throw new Error(`Active run uses harness ${run.harness}; start a new run for ${parsed.harness}.`);
+      harness = detectHarness(executor, run.harness);
+      model = parsed.model ?? run.model ?? plugin?.model ?? void 0;
+      effort = parsed.effort ?? run.effort ?? plugin?.effort ?? void 0;
+      if (effort && harness.effortFlags.length === 0) throw new Error(`Harness "${harness.id}" does not support --effort.`);
+      run.model = model ?? run.model;
+      run.effort = effort ?? run.effort;
+    } else {
+      harness = detectHarness(executor, requestedHarnessId);
+      if (effort && harness.effortFlags.length === 0) throw new Error(`Harness "${harness.id}" does not support --effort.`);
+      run = createRun(cwd, harness, model, effort);
+    }
+  }
+  run.status = "running";
+  run.model = model ?? run.model;
+  run.effort = effort ?? run.effort;
+  run.lastTurn += 1;
+  saveRun(run);
+  saveActiveRun(cwd, run.id);
+  return { run, harness };
+}
+function executeTurn(parsed, options) {
+  const executor = options.executor ?? defaultExecutor;
+  const writer = options.writer ?? process.stdout;
+  const errorWriter = options.errorWriter ?? process.stderr;
+  const cwd = options.cwd ?? process.cwd();
+  const zmxCheck = executor("zmx", ["--help"]);
+  if (zmxCheck.error || zmxCheck.status !== 0) {
+    errorWriter.write("zmx not found. Install zmx to use coding agents.\n");
+    return 2;
+  }
+  const { run, harness } = resolveRunAndHarness(parsed, executor, cwd, options);
+  const { shell, stdoutPath, stderrPath, exitCodePath } = buildShellCommand(harness, run, run.lastTurn, parsed.prompt, parsed.passthroughArgs);
+  const launch = executor("zmx", ["run", run.sessions.zmx, "sh", "-lc", shell], "ignore");
+  if (launch.error || launch.status !== 0) {
+    run.status = "failed";
+    saveRun(run);
+    errorWriter.write(`Failed to queue turn in zmx session ${run.sessions.zmx}.
+`);
+    return 3;
+  }
+  waitForFile(exitCodePath);
+  const exitCode = Number(readFileSync3(exitCodePath, "utf-8").trim() || "1");
+  const stdout = existsSync3(stdoutPath) ? readFileSync3(stdoutPath, "utf-8") : "";
+  const stderr = existsSync3(stderrPath) ? readFileSync3(stderrPath, "utf-8") : "";
+  const normalized = normalizeTurn(run.harness, run.id, run.lastTurn, stdout, stderr, (/* @__PURE__ */ new Date()).toISOString());
+  const turnStatus = classifyStatus(exitCode, stdout, stderr);
+  const turn = {
+    id: run.id,
+    turn: run.lastTurn,
+    status: turnStatus,
+    prompt: parsed.prompt,
+    harness: run.harness,
+    sessions: {
+      zmx: run.sessions.zmx,
+      ...normalized.sessionId || run.sessions[run.harness] ? { [run.harness]: normalized.sessionId ?? run.sessions[run.harness] } : {}
+    },
+    assistant: { text: normalized.assistantText },
+    usage: normalized.usage,
+    timing: normalized.timing,
+    paths: {
+      stdout: stdoutPath,
+      stderr: stderrPath,
+      events: resolve3(turnDir(run.id, run.lastTurn), "events.jsonl")
+    },
+    completedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeEvents(turn.paths.events, normalized.events);
+  writeJson(resolve3(turnDir(run.id, run.lastTurn), "normalized.json"), turn);
+  if (turn.sessions[run.harness]) run.sessions[run.harness] = turn.sessions[run.harness];
+  run.status = turnStatus;
+  saveRun(run);
+  writer.write(`${renderTurn(turn, parsed.outputMode)}
+`);
+  return turnStatus === "completed" ? 0 : 1;
+}
+function attachToTarget(argv, options) {
+  const executor = options.executor ?? defaultExecutor;
+  const errorWriter = options.errorWriter ?? process.stderr;
+  if (argv.length < 2) {
+    errorWriter.write(`${attachHelp()}
+`);
+    return 1;
+  }
+  const session = argv[0] === "run" ? loadRun(argv[1]).sessions.zmx : argv[0] === "session" ? argv[1] : null;
+  if (!session) {
+    errorWriter.write(`${attachHelp()}
+`);
+    return 1;
+  }
+  return executor("zmx", ["attach", session], "inherit").status ?? 1;
+}
+function outputCommand(argv, options) {
+  const writer = options.writer ?? process.stdout;
+  const cwd = options.cwd ?? process.cwd();
+  const parsed = parseOutputArgs(argv);
+  const run = loadRun(resolveRunId(cwd, parsed.id));
+  if (parsed.follow && run.status === "running") {
+    followOutput(run, run.lastTurn, parsed.outputMode, writer);
+    return 0;
+  }
+  writer.write(`${renderTurn(latestTurn(run), parsed.outputMode)}
+`);
+  return 0;
+}
+function statusCommand(argv, options) {
+  const writer = options.writer ?? process.stdout;
+  const cwd = options.cwd ?? process.cwd();
+  writer.write(`${renderStatus(loadRun(resolveRunId(cwd, argv.find((arg) => !arg.startsWith("-")))))}
+`);
+  return 0;
+}
+function listCommand(options) {
+  const writer = options.writer ?? process.stdout;
+  writer.write(`${JSON.stringify(listRuns(), null, 2)}
+`);
+  return 0;
+}
+async function runAgentCommand(argv, options = {}) {
+  ensureDirs();
+  const writer = options.writer ?? process.stdout;
+  const errorWriter = options.errorWriter ?? process.stderr;
+  if (!argv.length) {
+    writer.write(`${agentHelp()}
+`);
+    return 0;
+  }
+  try {
+    const [cmd, ...rest] = argv;
+    if (cmd === "--help" || cmd === "-h" || cmd === "help") {
+      writer.write(`${agentHelp()}
+`);
+      return 0;
+    }
+    if (cmd === "start") return executeTurn(parseStartSendArgs("start", rest), options);
+    if (cmd === "send") return executeTurn(parseStartSendArgs("send", rest), options);
+    if (cmd === "attach") return attachToTarget(rest, options);
+    if (cmd === "output") return outputCommand(rest, options);
+    if (cmd === "status") return statusCommand(rest, options);
+    if (cmd === "list") return listCommand(options);
+    return executeTurn(parseStartSendArgs("send", argv), options);
+  } catch (error) {
+    errorWriter.write(`${error.message || error}
+`);
+    return 1;
   }
 }
 
 // src/index.ts
 loadEnv();
+var VALID_INTERFACES = /* @__PURE__ */ new Set(["api", "graphql", "mcp", "skill"]);
+var RESERVED_SLUGS = /* @__PURE__ */ new Set(["ext", "agent"]);
 async function main() {
   const args = process.argv.slice(2);
   if (!args.length || args.length === 1 && (args[0] === "-h" || args[0] === "--help")) {
     showHelp();
     return;
   }
-  const cmd = args[0];
-  if (cmd === "create") {
-    const { configWizard } = await import("./prompt-DCFFOQ7K.js");
-    await configWizard();
+  if (args.length === 1 && (args[0] === "--version" || args[0] === "-v")) {
+    await showVersion();
     return;
   }
-  if (cmd === "add") {
-    const { runAdd } = await import("./add-ZRNIX6DM.js");
-    await runAdd(args.slice(1));
+  const extensionSlug = args[0];
+  const rest = args.slice(1);
+  if (extensionSlug === "ext") {
+    await runExt(rest);
     return;
   }
-  if (cmd === "update") {
-    if (!args[1]) {
-      console.error("Usage: godmode update <name>");
+  if (extensionSlug === "agent") {
+    await runAgent(rest);
+    return;
+  }
+  const multi = installedExtension(extensionSlug);
+  if (!multi) {
+    process.stderr.write(`'${extensionSlug}' is not an installed extension.
+`);
+    process.stderr.write(`Try 'godmode ext list' to see installed extensions.
+`);
+    process.stderr.write(`Try 'godmode --help' for more information.
+`);
+    process.exit(1);
+  }
+  const declared = declaredInterfaces(multi);
+  const first = rest[0];
+  if (!first || first === "--help" || first === "-h") {
+    showExtensionOverview(multi);
+    return;
+  }
+  if (first === "--version" || first === "-v") {
+    showExtensionVersion(multi);
+    return;
+  }
+  if (!VALID_INTERFACES.has(first)) {
+    process.stderr.write(`Missing interface.
+`);
+    process.stderr.write(`'${extensionSlug}' declares: ${declared.join(", ")}.
+`);
+    process.stderr.write(`Try 'godmode ${extensionSlug} ${declared[0]} ${first}' or 'godmode ${extensionSlug} --help'.
+`);
+    process.exit(1);
+  }
+  if (!declared.includes(first)) {
+    process.stderr.write(`'${extensionSlug}' does not declare a '${first}' interface.
+`);
+    process.stderr.write(`Declared: ${declared.join(", ")}.
+`);
+    process.stderr.write(`Try 'godmode ${extensionSlug} --help' for more information.
+`);
+    process.exit(1);
+  }
+  await runInterface(first, extensionSlug, rest.slice(1));
+}
+function installedExtension(name) {
+  const extPath = resolve5(GODMODE_EXTENSIONS_DIR, `${name}.json`);
+  if (!existsSync4(extPath)) return null;
+  try {
+    return JSON.parse(readFileSync5(extPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function declaredInterfaces(m) {
+  return Object.keys(m.interfaces);
+}
+function showExtHelp() {
+  console.log(`Install, inspect, and manage godmode extensions.
+
+Usage: godmode ext <command> [args]
+
+Commands:
+  install <name|folder>    Install an extension
+  uninstall <name>         Uninstall an extension
+  update <name>            Re-fetch spec, rebuild routes
+  list                     Show installed extensions
+  create                   Interactive manifest wizard`);
+}
+async function runExt(rest) {
+  const cmd = rest[0];
+  if (!cmd || cmd === "--help" || cmd === "-h") {
+    showExtHelp();
+    return;
+  }
+  if (cmd === "install") {
+    const target = rest[1];
+    if (!target) {
+      console.error("Usage: godmode ext install <name|folder>");
+      process.exit(1);
+    }
+    if (RESERVED_SLUGS.has(target)) {
+      process.stderr.write(`'${target}' is a reserved extension slug and cannot be installed.
+`);
+      process.stderr.write(`Reserved: ${[...RESERVED_SLUGS].join(", ")}.
+`);
       process.exit(1);
     }
-    await updateApi(args[1]);
+    const { runAdd } = await import("./add-AJERMPEA.js");
+    await runAdd(rest.slice(1));
     return;
   }
-  if (cmd === "remove") {
-    if (!args[1]) {
-      console.error("Usage: godmode remove <name>");
+  if (cmd === "uninstall") {
+    if (!rest[1]) {
+      console.error("Usage: godmode ext uninstall <name>");
       process.exit(1);
     }
-    await removeApi(args[1]);
+    await removeApi(rest[1]);
+    return;
+  }
+  if (cmd === "update") {
+    if (!rest[1]) {
+      console.error("Usage: godmode ext update <name>");
+      process.exit(1);
+    }
+    await updateApi(rest[1]);
     return;
   }
   if (cmd === "list") {
     await listApis();
     return;
   }
-  if (cmd === "mcp") {
-    const { runMcp } = await import("./mcp-NZIEMQOM.js");
-    await runMcp(args.slice(1));
+  if (cmd === "create") {
+    const { configWizard } = await import("./prompt-SWOWWAOH.js");
+    await configWizard();
     return;
   }
-  const apiName = cmd;
-  const parsed = parseArgs(args.slice(1));
-  const manifest = await loadManifest(apiName);
-  if (parsed.help || !parsed.segments.length) {
-    showApiHelp(manifest, apiName, parsed.segments, parsed.filter, parsed.methodFilter, parsed.all);
+  if (installedExtension(cmd)) {
+    const multi = installedExtension(cmd);
+    const ifaces = declaredInterfaces(multi);
+    process.stderr.write(`'${cmd}' is an installed extension, not an ext command.
+
+`);
+    process.stderr.write(`Did you mean:
+`);
+    process.stderr.write(`  godmode ${cmd} --help
+`);
+    for (const i of ifaces) {
+      process.stderr.write(`  godmode ${cmd} ${i} --help
+`);
+    }
+    process.stderr.write(`
+Try 'godmode ext --help' for more information.
+`);
+    process.exit(1);
+  }
+  process.stderr.write(`Unknown ext command '${cmd}'.
+`);
+  process.stderr.write(`Try 'godmode ext --help' for more information.
+`);
+  process.exit(1);
+}
+async function runAgent(rest) {
+  const code = await runAgentCommand(rest);
+  if (code !== 0) process.exit(code);
+}
+async function runInterface(iface, extensionName, rest) {
+  if (iface === "skill") {
+    process.stderr.write(`Skill interface not yet implemented.
+`);
+    process.exit(1);
+  }
+  if (rest.includes("--version") || rest.includes("-v")) {
+    const multi2 = await loadMultiManifest(extensionName);
+    showExtensionVersion(multi2);
+    return;
+  }
+  const parsed = parseArgs(rest);
+  const ifaceKey = iface;
+  const multi = await loadMultiManifest(extensionName);
+  const manifest = await loadManifest(extensionName, ifaceKey);
+  const implicitMethodFilter = parsed.methodFilter || (parsed.explicitMethod ? parsed.method : void 0);
+  if (parsed.help) {
+    showApiHelp(manifest, extensionName, parsed.segments, parsed.filter, implicitMethodFilter, parsed.all, multi);
+    return;
+  }
+  if (iface === "mcp" && !parsed.segments.length) {
+    await runMcp(
+      { godmodeHome: GODMODE_HOME, loadManifest: (n) => loadManifest(n, "mcp") },
+      [extensionName, ...rest]
+    );
     return;
   }
-  if (manifest.config.type === "graphql") {
-    const err = validateGraphQLFlags(parsed.method, parsed.query, parsed.body, apiName);
+  if (!parsed.segments.length) {
+    showApiHelp(manifest, extensionName, parsed.segments, parsed.filter, implicitMethodFilter, parsed.all, multi);
+    return;
+  }
+  if (iface === "api" && !parsed.explicitMethod) {
+    process.stderr.write(`Missing HTTP method. Try: godmode ${extensionName} api GET ${parsed.segments.join(" ")}
+`);
+    process.stderr.write(`Valid methods: GET, POST, PUT, PATCH, DELETE, HEAD.
+`);
+    process.exit(1);
+  }
+  if (iface === "graphql") {
+    const err = validateGraphQLFlags(parsed.method, parsed.query, parsed.body, extensionName);
     if (err) {
       process.stderr.write(err + "\n");
       process.exit(1);
@@ -564,7 +1705,6 @@ async function main() {
       headers: parsed.headers,
       query,
       body,
-      token: parsed.token,
       verbose: parsed.verbose,
       dryRun: parsed.dryRun
     });
@@ -572,14 +1712,23 @@ async function main() {
   }
   const match = matchRoute(manifest, parsed.segments, parsed.method);
   if (!match) {
+    const HTTP_VERBS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
+    const trailingVerb = parsed.segments.map((s) => s.toUpperCase()).find((s) => HTTP_VERBS.has(s));
+    if (trailingVerb) {
+      const rest2 = parsed.segments.filter((s) => s.toUpperCase() !== trailingVerb);
+      process.stderr.write(`No route matching: ${parsed.segments.join(" ")}
+`);
+      process.stderr.write(`Method goes first: try 'godmode ${extensionName} ${iface} ${trailingVerb} ${rest2.join(" ")}'
+`);
+      process.exit(1);
+    }
     process.stderr.write(`No ${parsed.method.toUpperCase()} route matching: ${parsed.segments.join(" ")}
 `);
     for (const m of ["get", "post", "put", "patch", "delete"]) {
       if (m === parsed.method) continue;
       const alt = matchRoute(manifest, parsed.segments, m);
       if (alt) {
-        const flag = m === "delete" ? "-d" : `--${m}`;
-        process.stderr.write(`  try: godmode ${apiName} ${parsed.segments.join(" ")} ${flag}
+        process.stderr.write(`  try: godmode ${extensionName} api ${m.toUpperCase()} ${parsed.segments.join(" ")}
 `);
       }
     }