@amsterdamdatalabs/enact-extensions 0.1.5 → 0.1.8

package/scripts/enact-extensions.mjs

@@ -799,11 +799,95 @@ if (command === "serve") {
   process.exitCode = 0; // signal intent; overridden to 1 on error inside IIFE
 }
 
+// ---------------------------------------------------------------------------
+// `hook` command — execute a hook handler by name, reading JSON from stdin.
+//
+// Currently supported sub-commands:
+//   enact-extensions hook user-prompt-submit
+//     Reads a UserPromptSubmit hook payload from stdin, extracts the prompt,
+//     builds the skill catalog from the bundled extensions dir, routes the
+//     prompt, and writes the hook response to stdout.
+//
+// Output contract (Claude Code hooks):
+//   Match:    { continue: true, hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: <string> } }
+//   No match: { continue: true }
+//   Error:    { continue: true }  (never throws/crashes — degrade gracefully)
+// ---------------------------------------------------------------------------
+if (command === "hook") {
+  const subCommand = path; // positional[1]
+
+  if (subCommand !== "user-prompt-submit") {
+    process.stderr.write(
+      `[enact-extensions hook] Unknown sub-command: ${subCommand ?? "(none)"}. ` +
+      `Supported: user-prompt-submit\n`,
+    );
+    process.stdout.write(JSON.stringify({ continue: true }) + "\n");
+    process.exit(0);
+  }
+
+  // Async IIFE: stdin reading and dynamic import require async context.
+  (async () => {
+    // Read stdin to get the hook payload JSON.
+    let payload;
+    try {
+      const chunks = [];
+      for await (const chunk of process.stdin) chunks.push(chunk);
+      const raw = Buffer.concat(chunks).toString("utf8").trim();
+      payload = raw ? JSON.parse(raw) : {};
+    } catch {
+      // Malformed or empty stdin — safe passthrough.
+      process.stdout.write(JSON.stringify({ continue: true }) + "\n");
+      process.exit(0);
+    }
+
+    try {
+      // Extract the user prompt from the hook payload.
+      // `prompt` is the canonical UserPromptSubmit field across surfaces:
+      // Claude Code (code.claude.com/docs/en/hooks) and Codex
+      // (developers.openai.com/codex/hooks) both send { prompt: string, ... };
+      // Cursor follows the same Claude-compatible schema. Single field, no fallback.
+      const prompt = payload && typeof payload.prompt === "string" ? payload.prompt : null;
+
+      if (!prompt) {
+        process.stdout.write(JSON.stringify({ continue: true }) + "\n");
+        process.exit(0);
+      }
+
+      // Resolve the extensions dir relative to the installed package root so
+      // the hook works whether invoked from the repo or the globally installed package.
+      const { buildSkillCatalog, routePrompt } = await import("./lib/ups-router.mjs");
+      const extensionsDir = join(PACKAGE_ROOT, "extensions");
+      const catalog = buildSkillCatalog(extensionsDir);
+
+      const { additionalContext } = routePrompt(prompt, catalog);
+
+      if (additionalContext) {
+        process.stdout.write(
+          JSON.stringify({
+            continue: true,
+            hookSpecificOutput: {
+              hookEventName: "UserPromptSubmit",
+              additionalContext,
+            },
+          }) + "\n",
+        );
+      } else {
+        process.stdout.write(JSON.stringify({ continue: true }) + "\n");
+      }
+    } catch {
+      // Any unexpected error — safe passthrough, never crash.
+      process.stdout.write(JSON.stringify({ continue: true }) + "\n");
+    }
+
+    process.exit(0);
+  })();
+}
+
 // ---------------------------------------------------------------------------
 // Commands that require resolving a plugin root path.
-// (Only run when command !== "serve" — serve handled above and must not fall through.)
+// (Only run when command is not already handled above.)
 // ---------------------------------------------------------------------------
-if (command !== "serve") {
+if (command !== "serve" && command !== "hook") {
 
 // Resolve the plugin root:
 //   - If no path arg given → default to cwd (existing behaviour).
@@ -838,7 +922,7 @@ try {
 
 try {
   if (command === "validate") {
-    const ok = runValidate(pluginRoot);
+    const ok = runValidate(pluginRoot, undefined, { pluginValidate: true });
     process.exit(ok ? 0 : 1);
   }
 

package/scripts/lib/run-validate.mjs

@@ -1,3 +1,6 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import {
   validatePluginBundleFromCanonical,
   checkPluginBundleComponentPathsFromCanonical,
@@ -10,8 +13,16 @@ import {
  * read or created.
  *
  * For backward-compatibility, `platforms` defaults to all four surfaces.
+ *
+ * If the plugin's `.agents/plugin.json` declares a `validate` field (a CLI
+ * command string) AND `options.pluginValidate` is true, that command is also
+ * executed in the plugin root. A non-zero exit code is treated as a validation
+ * failure.  `pluginValidate` defaults to false so that library callers (tests,
+ * programmatic use) are not affected by environment-specific CLI availability.
+ * The CLI sets it to true.
  */
-export function runValidate(pluginRoot, platforms) {
+export function runValidate(pluginRoot, platforms, options = {}) {
+  const { pluginValidate = false } = options;
   const report = validatePluginBundleFromCanonical(pluginRoot, platforms);
   const warnings = checkPluginBundleComponentPathsFromCanonical(pluginRoot);
   const hookErrors = checkHookEvents(pluginRoot);
@@ -35,5 +46,28 @@ export function runValidate(pluginRoot, platforms) {
     console.log(`[warn] ${warn}`);
   }
 
-  return report.ok && warnings.length === 0 && hookErrors.length === 0;
+  // Run the plugin's declared validate command when present and requested.
+  let pluginValidateOk = true;
+  const manifestPath = join(pluginRoot, ".agents", "plugin.json");
+  if (pluginValidate && existsSync(manifestPath)) {
+    let manifest;
+    try {
+      manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    } catch {
+      // malformed manifest — schema checks above will have already flagged it
+    }
+    const validateCmd = manifest?.validate;
+    if (typeof validateCmd === "string" && validateCmd.trim().length > 0) {
+      console.log(`[validate] running plugin validate: ${validateCmd}`);
+      try {
+        execSync(validateCmd, { cwd: pluginRoot, stdio: "inherit" });
+        console.log(`[ok] plugin validate: ${validateCmd}`);
+      } catch (err) {
+        console.log(`[FAIL] plugin validate: ${validateCmd} (exit ${err.status ?? 1})`);
+        pluginValidateOk = false;
+      }
+    }
+  }
+
+  return report.ok && warnings.length === 0 && hookErrors.length === 0 && pluginValidateOk;
 }

package/scripts/lib/ups-router.mjs

@@ -0,0 +1,432 @@
+/**
+ * ups-router.mjs — pure, testable module for the UserPromptSubmit keyword-router.
+ *
+ * Discovers plugin bundles and their skills, extracts trigger keywords from
+ * SKILL.md frontmatter, and routes a user prompt to matching skills.
+ *
+ * Two exports:
+ *   buildSkillCatalog(extensionsDir)  → CatalogEntry[]
+ *   routePrompt(prompt, catalog)      → RouteResult
+ *
+ * Both are deterministic and side-effect free (no network, no writes, no clock).
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+// ---------------------------------------------------------------------------
+// Types (JSDoc)
+// ---------------------------------------------------------------------------
+
+/**
+ * @typedef {{ skill: string, plugin: string, keywords: string[], invoke: string }} CatalogEntry
+ * @typedef {{ skill: string, plugin: string, invoke: string, reason: string }} RouteMatch
+ * @typedef {{ matches: RouteMatch[], additionalContext: string|null }} RouteResult
+ */
+
+// ---------------------------------------------------------------------------
+// Stop-word list — short or trivial tokens that should never fire a match.
+// The list is intentionally broad: we want precision over recall in the router
+// so that only genuinely skill-relevant keywords generate matches.
+// ---------------------------------------------------------------------------
+
+const STOP_WORDS = new Set([
+  // articles, conjunctions, prepositions
+  "a", "an", "the", "and", "or", "but", "in", "on", "at", "to", "for",
+  "of", "with", "by", "from", "up", "as", "via", "per",
+  // pronouns / determiners
+  "it", "its", "this", "that", "these", "those", "i", "we", "you", "he",
+  "she", "they", "my", "our", "your", "their", "its", "all", "any", "both",
+  // copula / auxiliaries
+  "is", "are", "was", "were", "be", "been", "being", "have", "has", "had",
+  "do", "does", "did", "will", "would", "could", "should", "may", "might",
+  "can", "shall", "must",
+  // high-frequency verbs that are not skill identifiers
+  "get", "set", "put", "let", "run", "use", "add", "see", "say", "ask",
+  "go", "give", "make", "take", "want", "need", "know", "keep", "find",
+  "call", "read", "work", "look", "show", "used", "each", "also", "into",
+  "when", "then", "than", "just", "more", "most", "only", "such", "even",
+  "now", "new", "not", "no", "so", "if", "how", "what", "which", "where",
+  "who", "why", "over", "after", "before", "about", "like",
+  // generic nouns too broad to be useful keywords
+  "task", "work", "file", "data", "code", "tool", "type", "name", "list",
+  "item", "part", "case", "time", "step", "way", "mode", "form", "end",
+  "start", "path", "user", "output", "input", "result", "context", "note",
+  "example", "reason", "detail", "value", "field", "key", "state", "stage",
+]);
+
+/**
+ * Return true when token should be excluded as a keyword.
+ * Tokens shorter than 3 characters, or pure stop-words, are excluded.
+ *
+ * @param {string} token
+ * @returns {boolean}
+ */
+function isStopWord(token) {
+  if (token.length < 3) return true;
+  return STOP_WORDS.has(token.toLowerCase());
+}
+
+// ---------------------------------------------------------------------------
+// Frontmatter parsing
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract the YAML frontmatter block from a Markdown file's text.
+ * Returns null when no frontmatter block is found.
+ *
+ * @param {string} text
+ * @returns {string|null}
+ */
+function extractFrontmatterBlock(text) {
+  if (!text.startsWith("---")) return null;
+  const m = /^---\n([\s\S]*?)\n---/.exec(text);
+  return m ? m[1] : null;
+}
+
+/**
+ * Parse a specific scalar field from a raw YAML frontmatter block.
+ * Handles both single-line `field: "value"` and block-scalar `field: >\n  val`.
+ *
+ * @param {string} block  Raw frontmatter text (between the --- delimiters).
+ * @param {string} field  Field name to extract.
+ * @returns {string|null}
+ */
+function parseFrontmatterField(block, field) {
+  // Match single-line scalar: field: value  (quoted or bare).
+  // After extracting the value, skip it when it is a block-scalar indicator
+  // (">", ">-", "|", "|-", etc.) so those fall through to the block-scalar branch.
+  const singleLine = new RegExp(`(?:^|\\n)${field}:\\s*(?:["']([^"'\\n]*)["']|(.+))`, "m");
+  const sl = singleLine.exec(block);
+  if (sl) {
+    const raw = (sl[1] ?? sl[2] ?? "").trim();
+    // Reject YAML block-scalar indicators so we fall through to the block branch.
+    if (raw && !/^[>|]-?$/.test(raw)) {
+      return raw || null;
+    }
+  }
+
+  // Match block scalar (folded or literal): field: >-\n  line1\n  line2
+  const blockScalar = new RegExp(`(?:^|\\n)${field}:\\s*[>|]-?\\n((?:  [^\\n]*\\n?)+)`, "m");
+  const bs = blockScalar.exec(block);
+  if (bs) {
+    return bs[1]
+      .split("\n")
+      .map((l) => l.replace(/^  /, "").trim())
+      .filter(Boolean)
+      .join(" ")
+      .trim() || null;
+  }
+
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Keyword extraction from a SKILL.md description
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract explicit trigger keywords from a skill description.
+ * Looks for quoted phrases after "Triggers on" (e.g. Triggers on "foo", "bar").
+ *
+ * @param {string} description
+ * @returns {string[]}
+ */
+function extractExplicitTriggers(description) {
+  const triggerSection = /[Tt]riggers?\s+on\s+(.*)/;
+  const m = triggerSection.exec(description);
+  if (!m) return [];
+  const section = m[1];
+  // Extract all double-quoted tokens from the trigger section.
+  const quoted = [];
+  const re = /"([^"]+)"/g;
+  let hit;
+  while ((hit = re.exec(section)) !== null) {
+    const phrase = hit[1].trim().toLowerCase();
+    if (phrase && !isStopWord(phrase)) quoted.push(phrase);
+  }
+  return quoted;
+}
+
+/**
+ * Derive salient keywords from a skill's description text.
+ *
+ * Conservative: only extracts tokens that are plausibly skill identifiers:
+ *   - Hyphenated compound tokens (e.g. "contract-runner", "test-driven")
+ *   - $skill-name mentions (e.g. "$loop", "$tdd")
+ *   - Quoted short phrases other than the "Triggers on" section
+ *   - Unquoted tokens that are longer (>=6 chars) and not stop-words
+ *
+ * @param {string} description
+ * @returns {string[]}
+ */
+function descriptionKeywords(description) {
+  const tokens = new Set();
+
+  // $skill mentions: "$foo", "$foo-bar"
+  const dollarRe = /\$([a-z][a-z0-9-]+)/gi;
+  let m;
+  while ((m = dollarRe.exec(description)) !== null) {
+    tokens.add(m[1].toLowerCase());
+  }
+
+  // Hyphenated compound tokens: at least two segments, each 2+ chars
+  const hyphenRe = /\b([a-z][a-z0-9]*(?:-[a-z][a-z0-9]*)+)\b/gi;
+  while ((m = hyphenRe.exec(description)) !== null) {
+    const tok = m[1].toLowerCase();
+    if (!isStopWord(tok)) tokens.add(tok);
+  }
+
+  // Longer bare words (>=6 chars) that don't look like common English prose.
+  const longWordRe = /\b([a-z]{6,})\b/gi;
+  while ((m = longWordRe.exec(description)) !== null) {
+    const tok = m[1].toLowerCase();
+    if (!isStopWord(tok)) tokens.add(tok);
+  }
+
+  return [...tokens];
+}
+
+/**
+ * Derive the full keyword set for a single skill.
+ * Priority: explicit "Triggers on" > skill name > salient description terms.
+ * Deduplicates and excludes stop-words.
+ *
+ * @param {string} skillName
+ * @param {string|null} description
+ * @returns {string[]}
+ */
+function deriveKeywords(skillName, description) {
+  const seen = new Set();
+  const push = (kw) => {
+    const k = kw.toLowerCase().trim();
+    if (k && !seen.has(k) && !isStopWord(k)) { seen.add(k); }
+  };
+
+  // Always include the skill name itself (unless it is a stop-word).
+  if (skillName) push(skillName);
+
+  if (description) {
+    // Explicit triggers have highest priority.
+    for (const t of extractExplicitTriggers(description)) push(t);
+    // Salient terms from the description.
+    for (const t of descriptionKeywords(description)) push(t);
+  }
+
+  return [...seen];
+}
+
+// ---------------------------------------------------------------------------
+// Directory helpers
+// ---------------------------------------------------------------------------
+
+function isDir(p) {
+  try { return statSync(p).isDirectory(); } catch { return false; }
+}
+
+// ---------------------------------------------------------------------------
+// buildSkillCatalog
+// ---------------------------------------------------------------------------
+
+/**
+ * Discover all plugin bundles under extensionsDir, read each bundle's
+ * skills/<name>/SKILL.md, and build a catalog of { skill, plugin, keywords, invoke }.
+ *
+ * - Skips bundles without a .agents/plugin.json.
+ * - Skips skill dirs without a SKILL.md.
+ * - Skips malformed manifests / SKILL.md files without throwing.
+ * - Invocation form: "$<skill>" (the canonical invocation for all surfaces).
+ *
+ * @param {string} extensionsDir  Absolute path to the extensions/ directory.
+ * @returns {CatalogEntry[]}
+ */
+export function buildSkillCatalog(extensionsDir) {
+  const dir = resolve(extensionsDir);
+  if (!existsSync(dir)) return [];
+
+  let bundleNames;
+  try {
+    bundleNames = readdirSync(dir);
+  } catch {
+    return [];
+  }
+
+  const catalog = [];
+
+  for (const bundleName of bundleNames) {
+    const bundleDir = join(dir, bundleName);
+    if (!isDir(bundleDir)) continue;
+
+    const manifestPath = join(bundleDir, ".agents", "plugin.json");
+    if (!existsSync(manifestPath)) continue;
+
+    let manifest;
+    try {
+      manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    } catch {
+      // malformed manifest — skip silently
+      continue;
+    }
+
+    const pluginName = (typeof manifest.name === "string" ? manifest.name : null) ?? bundleName;
+
+    const skillsDir = join(bundleDir, "skills");
+    if (!isDir(skillsDir)) continue;
+
+    let skillNames;
+    try {
+      skillNames = readdirSync(skillsDir);
+    } catch {
+      continue;
+    }
+
+    for (const skillName of skillNames) {
+      const skillDir = join(skillsDir, skillName);
+      if (!isDir(skillDir)) continue;
+
+      const skillMdPath = join(skillDir, "SKILL.md");
+      if (!existsSync(skillMdPath)) continue;
+
+      let skillText;
+      try {
+        skillText = readFileSync(skillMdPath, "utf8");
+      } catch {
+        continue;
+      }
+
+      const fmBlock = extractFrontmatterBlock(skillText);
+
+      // `name` from frontmatter (fall back to directory name).
+      const fmName = fmBlock ? parseFrontmatterField(fmBlock, "name") : null;
+      const resolvedName = fmName ?? skillName;
+
+      // `description` from frontmatter — both "description" and "desc" keys.
+      let description = null;
+      if (fmBlock) {
+        description = parseFrontmatterField(fmBlock, "description") ?? parseFrontmatterField(fmBlock, "desc");
+      }
+
+      const keywords = deriveKeywords(resolvedName, description ?? "");
+      const invoke = `$${resolvedName}`;
+
+      catalog.push({ skill: resolvedName, plugin: pluginName, keywords, invoke });
+    }
+  }
+
+  return catalog;
+}
+
+// ---------------------------------------------------------------------------
+// routePrompt
+// ---------------------------------------------------------------------------
+
+/**
+ * Route a user prompt against the skill catalog.
+ *
+ * Matching strategy:
+ *   1. Explicit mention — `/skill-name` or `$skill-name` in the prompt (strong).
+ *   2. Keyword match — any non-stop-word keyword appears as a word-boundary token.
+ *
+ * Returns all matched skills (de-duplicated by skill name).
+ * No match → additionalContext: null (passthrough).
+ *
+ * @param {string|null|undefined} prompt
+ * @param {CatalogEntry[]} catalog
+ * @returns {RouteResult}
+ */
+export function routePrompt(prompt, catalog) {
+  if (!prompt || typeof prompt !== "string") {
+    return { matches: [], additionalContext: null };
+  }
+
+  const promptLower = prompt.toLowerCase();
+
+  // Normalise catalog: skip bogus entries.
+  const validCatalog = (Array.isArray(catalog) ? catalog : []).filter(
+    (e) => e && typeof e.skill === "string" && Array.isArray(e.keywords),
+  );
+
+  const matchMap = new Map(); // skill → RouteMatch
+
+  for (const entry of validCatalog) {
+    if (matchMap.has(entry.skill)) continue; // already matched
+
+    const { skill, plugin, keywords, invoke } = entry;
+
+    // 1. Explicit /skill or $skill mention.
+    const explicitPatterns = [`/${skill.toLowerCase()}`, `$${skill.toLowerCase()}`];
+    for (const pat of explicitPatterns) {
+      if (promptLower.includes(pat)) {
+        matchMap.set(skill, {
+          skill,
+          plugin,
+          invoke: invoke ?? `$${skill}`,
+          reason: `explicit mention of "${pat}"`,
+        });
+        break;
+      }
+    }
+    if (matchMap.has(skill)) continue;
+
+    // 2. Keyword word-boundary match.
+    for (const kw of keywords) {
+      if (!kw || isStopWord(kw)) continue;
+      // Word-boundary check: kw must appear as a whole token (not substring of another word).
+      // Use a simple regex with \b-equivalent: check that surrounding chars are non-word.
+      const kwLower = kw.toLowerCase();
+      // Build a word-boundary regex. Escape regex metacharacters in kw.
+      const escaped = kwLower.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+      const re = new RegExp(`(?<![a-z0-9_-])${escaped}(?![a-z0-9_-])`, "i");
+      if (re.test(promptLower)) {
+        matchMap.set(skill, {
+          skill,
+          plugin,
+          invoke: invoke ?? `$${skill}`,
+          reason: `keyword match on "${kw}"`,
+        });
+        break;
+      }
+    }
+  }
+
+  const matches = [...matchMap.values()];
+
+  if (matches.length === 0) {
+    return { matches: [], additionalContext: null };
+  }
+
+  const additionalContext = buildAdditionalContext(matches);
+  return { matches, additionalContext };
+}
+
+// ---------------------------------------------------------------------------
+// additionalContext builder
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a human-readable additionalContext string that points the agent at
+ * the matching skills and how to invoke them.
+ *
+ * @param {RouteMatch[]} matches
+ * @returns {string}
+ */
+function buildAdditionalContext(matches) {
+  const lines = [
+    "<!-- enact-extensions: UserPromptSubmit keyword-router -->",
+    `The following skill${matches.length === 1 ? "" : "s"} appear${matches.length === 1 ? "s" : ""} relevant to the user's prompt:`,
+    "",
+  ];
+
+  for (const m of matches) {
+    lines.push(`- **${m.skill}** (plugin: ${m.plugin})`);
+    lines.push(`  Invoke with: \`${m.invoke}\``);
+    lines.push(`  Matched because: ${m.reason}`);
+    lines.push("");
+  }
+
+  lines.push(
+    "If the user's intent aligns with one of these skills, invoke it using the form shown above.",
+    "If unsure, proceed with the default behaviour and ignore this hint.",
+  );
+
+  return lines.join("\n");
+}

package/spec/enact.json

@@ -105,6 +105,10 @@
       "description": "Relative path to default settings applied when the plugin is enabled.",
       "default": "./settings.json"
     },
+    "validate": {
+      "type": "string",
+      "description": "Optional CLI command run by 'enact-extensions validate' after schema checks. The command is executed in the plugin root; a non-zero exit fails validation. Allows plugins to declare a self-check (e.g. 'enact-loop doctor')."
+    },
     "bin": {
       "type": "string",
       "description": "Relative path to executables added to the Bash PATH while the plugin is active.",

package/spec/enact.md

@@ -9,7 +9,8 @@ Extend what Enact can do, for example:
 
 - Install the enact-context plugin to give agents deep code intelligence and semantic search.
 - Install the enact-wiki plugin to persist knowledge across sessions and projects.
-- Install the enact-operator plugin to unlock factory workflows, team orchestration, and operator oversight.
+- Install the enact-loop plugin to run durable contract-verified work with independent judgment grading.
+- Install the enact-operator plugin for the full operator surface (team orchestration, HUD, doctor, and oversight tools).
 
 A plugin can contain:
 
@@ -85,10 +86,12 @@ If you want to keep a plugin installed but turn it off, set its entry in
 `~/.enact/config.toml` to `enabled = false`, then restart the agent:
 
 ```toml
-[plugins."enact-operator@enact-curated"]
+[plugins."enact-loop@enact-curated"]
 enabled = false
 ```
 
+> **Note:** enact-operator is also available in the registry for teams that need the full operator surface (HUD, doctor, team orchestration, oversight). enact-loop is the recommended default for contract-verified loop work.
+
 ## Build your own plugin
 
 Plugins live in a directory containing an `.agents/` folder with a `plugin.json`

package/extensions/cmux/.agents/plugin.json

@@ -1,37 +0,0 @@
-{
-  "name": "cmux",
-  "version": "0.1.0",
-  "description": "cmux terminal and VM orchestration skills: split panes, workspace control, and VM monitoring for agent-driven sessions.",
-  "author": {
-    "name": "Amsterdam Data Labs"
-  },
-  "license": "UNLICENSED",
-  "keywords": [
-    "cmux",
-    "terminal",
-    "vm",
-    "workspace",
-    "orchestration"
-  ],
-  "targets": [
-    "claude",
-    "codex",
-    "cursor"
-  ],
-  "skills": "./skills/",
-  "interface": {
-    "displayName": "cmux",
-    "shortDescription": "Terminal/VM orchestration: panes, workspaces, and VM monitoring.",
-    "developerName": "Amsterdam Data Labs",
-    "category": "Developer Tools",
-    "capabilities": [
-      "terminal control",
-      "workspace management",
-      "vm monitoring"
-    ]
-  },
-  "factory": {
-    "firstParty": true,
-    "operatorScope": "global"
-  }
-}