agents-united 0.5.0

package/dist/cli.js

@@ -0,0 +1,4789 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { cac } from "cac";
+import pc from "picocolors";
+import { intro, outro, spinner, note, select, multiselect, confirm, text } from "@clack/prompts";
+import fs12 from "fs-extra";
+import path14 from "path";
+
+// src/core/registry.ts
+import path from "path";
+import fs from "fs-extra";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var RegistryResolver = class {
+  registryDir;
+  bundlesManifest = null;
+  constructor(customRegistryDir) {
+    if (customRegistryDir) {
+      this.registryDir = path.resolve(customRegistryDir);
+    } else {
+      const candidatePaths = [
+        path.resolve(__dirname, "../registry"),
+        path.resolve(__dirname, "../../registry"),
+        path.resolve(process.cwd(), "registry")
+      ];
+      const found = candidatePaths.find((p) => fs.existsSync(path.join(p, "bundles.json")));
+      this.registryDir = found || candidatePaths[0];
+    }
+  }
+  getRegistryDir() {
+    return this.registryDir;
+  }
+  async loadBundles() {
+    if (this.bundlesManifest) {
+      return this.bundlesManifest;
+    }
+    const manifestPath = path.join(this.registryDir, "bundles.json");
+    if (!await fs.pathExists(manifestPath)) {
+      throw new Error(`Registry bundles.json not found at ${manifestPath}`);
+    }
+    this.bundlesManifest = await fs.readJson(manifestPath);
+    return this.bundlesManifest;
+  }
+  async getBundle(bundleName) {
+    const manifest = await this.loadBundles();
+    if (manifest.bundles[bundleName]) {
+      return manifest.bundles[bundleName];
+    }
+    const found = Object.values(manifest.bundles).find(
+      (b) => b.aliases?.includes(bundleName)
+    );
+    return found || null;
+  }
+  async listBundles() {
+    const manifest = await this.loadBundles();
+    return Object.values(manifest.bundles);
+  }
+  async getBundlesByDomain(domain) {
+    const manifest = await this.loadBundles();
+    const d = domain.toLowerCase();
+    return Object.values(manifest.bundles).filter((b) => b.domain?.toLowerCase() === d);
+  }
+  async resolve(identifier) {
+    if (identifier.startsWith("domain:")) {
+      const domainName = identifier.replace(/^domain:/, "").toLowerCase();
+      const domainBundles = await this.getBundlesByDomain(domainName);
+      if (domainBundles.length > 0) {
+        const agents = /* @__PURE__ */ new Set();
+        const skills = /* @__PURE__ */ new Set();
+        const workflows = /* @__PURE__ */ new Set();
+        for (const b of domainBundles) {
+          const resolved = await this.resolve(b.name);
+          resolved.agents.forEach((a) => agents.add(a));
+          resolved.skills.forEach((s) => skills.add(s));
+          resolved.workflows.forEach((w) => workflows.add(w));
+        }
+        return {
+          targetBundle: `domain:${domainName}`,
+          agents: Array.from(agents),
+          skills: Array.from(skills),
+          workflows: Array.from(workflows),
+          rules: ["GEMINI.md"]
+        };
+      }
+    }
+    const bundle = await this.getBundle(identifier);
+    if (bundle) {
+      const agents = /* @__PURE__ */ new Set();
+      const skills = new Set(bundle.skills || []);
+      const workflows = new Set(bundle.workflows || []);
+      const rules = ["GEMINI.md"];
+      if (bundle.parentBundle) {
+        const parent = await this.getBundle(bundle.parentBundle);
+        if (parent) {
+          if (parent.orchestrator) agents.add(parent.orchestrator);
+          if (parent.agents) parent.agents.forEach((a) => agents.add(a));
+          if (parent.skills) parent.skills.forEach((s) => skills.add(s));
+          if (parent.workflows) parent.workflows.forEach((w) => workflows.add(w));
+        }
+      }
+      if (bundle.orchestrator) agents.add(bundle.orchestrator);
+      if (bundle.agents) bundle.agents.forEach((a) => agents.add(a));
+      return {
+        targetBundle: bundle.name,
+        agents: Array.from(agents),
+        skills: Array.from(skills),
+        workflows: Array.from(workflows),
+        rules
+      };
+    }
+    const agentPath = path.join(this.registryDir, "agents", identifier.endsWith(".md") ? identifier : `${identifier}.md`);
+    if (await fs.pathExists(agentPath)) {
+      return {
+        agents: [path.basename(agentPath)],
+        skills: [],
+        workflows: [],
+        rules: []
+      };
+    }
+    const skillPath = path.join(this.registryDir, "skills", identifier);
+    if (await fs.pathExists(skillPath)) {
+      return {
+        agents: [],
+        skills: [identifier],
+        workflows: [],
+        rules: []
+      };
+    }
+    const workflowFileName = identifier.startsWith("workflow-") ? `${identifier}.md` : `workflow-${identifier}.md`;
+    const workflowPath = path.join(this.registryDir, "workflows", workflowFileName);
+    if (await fs.pathExists(workflowPath)) {
+      return {
+        agents: [],
+        skills: [],
+        workflows: [path.basename(workflowPath)],
+        rules: []
+      };
+    }
+    throw new Error(`Item or bundle "${identifier}" not found in registry.`);
+  }
+  async find(query = "", options) {
+    const manifest = await this.loadBundles();
+    const q = query.trim().toLowerCase();
+    let matchedBundles = [];
+    if (!options?.type || options.type === "bundle") {
+      matchedBundles = Object.values(manifest.bundles).filter((b) => {
+        if (options?.domain && b.domain?.toLowerCase() !== options.domain.toLowerCase()) {
+          return false;
+        }
+        if (!q) return true;
+        return b.name.toLowerCase().includes(q) || b.description.toLowerCase().includes(q) || b.category?.toLowerCase().includes(q) || b.domain?.toLowerCase().includes(q) || b.aliases?.some((a) => a.toLowerCase().includes(q));
+      });
+    }
+    const agentsDir = path.join(this.registryDir, "agents");
+    let matchedAgents = [];
+    if (!options?.type || options.type === "agent") {
+      if (await fs.pathExists(agentsDir)) {
+        const files = await fs.readdir(agentsDir);
+        matchedAgents = files.filter((f) => {
+          if (!q) return true;
+          return f.toLowerCase().includes(q);
+        });
+      }
+    }
+    const skillsDir = path.join(this.registryDir, "skills");
+    let matchedSkills = [];
+    if (!options?.type || options.type === "skill") {
+      if (await fs.pathExists(skillsDir)) {
+        const dirs = await fs.readdir(skillsDir);
+        matchedSkills = dirs.filter((d) => {
+          if (!q) return true;
+          return d.toLowerCase().includes(q);
+        });
+      }
+    }
+    const workflowsDir = path.join(this.registryDir, "workflows");
+    let matchedWorkflows = [];
+    if (!options?.type || options.type === "workflow") {
+      if (await fs.pathExists(workflowsDir)) {
+        const files = await fs.readdir(workflowsDir);
+        matchedWorkflows = files.filter((f) => f.endsWith(".md")).filter((f) => {
+          if (!q) return true;
+          return f.toLowerCase().includes(q);
+        });
+      }
+    }
+    return {
+      bundles: matchedBundles,
+      agents: matchedAgents,
+      skills: matchedSkills,
+      workflows: matchedWorkflows
+    };
+  }
+};
+
+// src/core/installer.ts
+import path5 from "path";
+import crypto from "crypto";
+import fs3 from "fs-extra";
+
+// src/core/adapter.ts
+import path3 from "path";
+import os from "os";
+
+// src/core/hosts.ts
+import path2 from "path";
+var HOST_REGISTRY = {
+  agents: {
+    id: "agents",
+    label: "Google Antigravity & Master Library (\u{1F4C1} .agents/)",
+    projectDir: ".agents",
+    globalDirSegments: [".agents"],
+    agentsSubdir: "agents",
+    detectionMarkers: [".agents"],
+    profile: "antigravity",
+    projectionCapable: false
+  },
+  gemini: {
+    id: "gemini",
+    label: "Antigravity legacy (\u{1F4C1} .gemini/)",
+    projectDir: ".gemini",
+    globalDirSegments: [".gemini", "config"],
+    agentsSubdir: "agents",
+    detectionMarkers: [".gemini"],
+    profile: "antigravity",
+    projectionCapable: false
+  },
+  claude: {
+    id: "claude",
+    label: "Anthropic Claude Code (\u{1F4C1} .claude/)",
+    projectDir: ".claude",
+    globalDirSegments: [".claude"],
+    agentsSubdir: "agents",
+    detectionMarkers: [".claude"],
+    profile: "claude-code",
+    projectionCapable: true
+  },
+  cursor: {
+    id: "cursor",
+    label: "Cursor IDE (\u{1F4C1} .cursor/)",
+    projectDir: ".cursor",
+    globalDirSegments: [".cursor"],
+    agentsSubdir: "agents",
+    detectionMarkers: [".cursor"],
+    profile: "cursor",
+    projectionCapable: true
+  },
+  cline: {
+    id: "cline",
+    label: "Cline (\u{1F4C1} .cline/)",
+    projectDir: ".cline",
+    globalDirSegments: [".cline"],
+    agentsSubdir: "agents",
+    detectionMarkers: [".cline", ".clinerules"],
+    profile: "cline",
+    projectionCapable: true
+  },
+  opencode: {
+    id: "opencode",
+    label: "OpenCode (\u{1F4C1} .opencode/)",
+    projectDir: ".opencode",
+    globalDirSegments: [".config", "opencode"],
+    agentsSubdir: "agent",
+    detectionMarkers: [".opencode", "opencode.json"],
+    profile: "opencode",
+    projectionCapable: true
+  },
+  codex: {
+    id: "codex",
+    label: "OpenAI Codex, Copilot, Aider & Zed (\u{1F4C4} ./AGENTS.md)",
+    projectDir: ".",
+    globalDirSegments: [".codex"],
+    agentsSubdir: void 0,
+    detectionMarkers: ["AGENTS.md", ".codex"],
+    profile: "agentsmd",
+    projectionCapable: true
+  }
+};
+var KNOWN_HOST_IDS = Object.keys(HOST_REGISTRY);
+function isKnownHost(id) {
+  return Object.prototype.hasOwnProperty.call(HOST_REGISTRY, id);
+}
+function resolveHostProjectDir(host, cwd) {
+  return path2.resolve(cwd, HOST_REGISTRY[host].projectDir);
+}
+function resolveHostGlobalDir(host, home) {
+  return path2.join(home, ...HOST_REGISTRY[host].globalDirSegments);
+}
+function planInstallTargets(selected) {
+  const normalized = Array.from(
+    new Set(selected.map((s) => typeof s === "string" ? s.trim().toLowerCase() : "").filter(Boolean))
+  );
+  const known = normalized.filter(isKnownHost);
+  const fanout = known.filter((h) => HOST_REGISTRY[h].projectionCapable);
+  const hosts = known.filter((h) => !HOST_REGISTRY[h].projectionCapable);
+  let addedCanonicalStore = false;
+  if (fanout.length > 0 && !hosts.includes("agents")) {
+    hosts.unshift("agents");
+    addedCanonicalStore = true;
+  }
+  if (hosts.length === 0 && fanout.length === 0) {
+    hosts.push("agents");
+  }
+  return { hosts, fanout, addedCanonicalStore };
+}
+
+// src/core/adapter.ts
+var AgentHostAdapter = class {
+  static resolveHostDir(scope = "project", host = "agents", overrideDir) {
+    if (overrideDir) {
+      return path3.resolve(overrideDir);
+    }
+    if (!isKnownHost(host)) {
+      host = "agents";
+    }
+    const home = os.homedir();
+    const cwd = process.cwd();
+    if (scope === "global") {
+      return resolveHostGlobalDir(host, home);
+    }
+    return resolveHostProjectDir(host, cwd);
+  }
+  static getSubPaths(targetDir) {
+    return {
+      agentsDir: path3.join(targetDir, "agents"),
+      skillsDir: path3.join(targetDir, "skills"),
+      workflowsDir: path3.join(targetDir, "workflows"),
+      rulesDir: path3.join(targetDir, "rules"),
+      lockfile: path3.join(targetDir, "agents-united.json")
+    };
+  }
+};
+
+// src/core/projector.ts
+import YAML from "yaml";
+
+// src/core/cline-projector.ts
+import yaml from "yaml";
+import path4 from "path";
+import fs2 from "fs-extra";
+var ClineProjector = class {
+  /**
+   * Render a Cline role definition from canonical agent markdown content.
+   */
+  static renderRole(canonicalContent, canonicalRelPath) {
+    const normCanonical = canonicalRelPath.replace(/\\/g, "/");
+    const marker = `<!-- managed-by: agents-united | profile: cline | canonical: ${normCanonical} | do not edit -->`;
+    const preamble = `## Cline runtime note
+
+Use the equivalent capabilities available in this Cline session. Canonical tool names describe
+intent and may differ from Cline's runtime tool names. For delegation, prefer Agent Teams when
+available, then session subagents; otherwise complete the role in the main session.`;
+    const match = canonicalContent.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+    if (!match) {
+      return `${marker}
+
+${preamble}
+
+${canonicalContent.trim()}`;
+    }
+    const rawYaml = match[1];
+    const rawBody = match[2];
+    let parsed = {};
+    try {
+      parsed = yaml.parse(rawYaml) || {};
+    } catch {
+      parsed = {};
+    }
+    const cleanFrontmatter = {};
+    if (parsed.name) cleanFrontmatter.name = parsed.name;
+    if (parsed.description) cleanFrontmatter.description = parsed.description;
+    if (parsed.providerId) cleanFrontmatter.providerId = parsed.providerId;
+    if (parsed.modelId) cleanFrontmatter.modelId = parsed.modelId;
+    if (parsed.cwd) cleanFrontmatter.cwd = parsed.cwd;
+    if (parsed.maxIterations) cleanFrontmatter.maxIterations = parsed.maxIterations;
+    const frontmatterStr = yaml.stringify(cleanFrontmatter).trim();
+    const bodyStr = rawBody.trim();
+    return `---
+${frontmatterStr}
+---
+${marker}
+
+${preamble}
+
+${bodyStr}
+`;
+  }
+  /**
+   * Render a Cline SKILL.md preserving frontmatter and placing managed marker after delimiter.
+   */
+  static renderSkillMd(canonicalContent, canonicalRelPath) {
+    const normCanonical = canonicalRelPath.replace(/\\/g, "/");
+    const marker = `<!-- managed-by: agents-united | profile: cline | canonical: ${normCanonical} | do not edit -->`;
+    const match = canonicalContent.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+    if (!match) {
+      return `${marker}
+
+${canonicalContent.trim()}`;
+    }
+    const rawYaml = match[1];
+    const rawBody = match[2];
+    let parsed = {};
+    try {
+      parsed = yaml.parse(rawYaml) || {};
+    } catch {
+      parsed = {};
+    }
+    const frontmatterStr = yaml.stringify(parsed).trim();
+    const bodyStr = rawBody.trim();
+    return `---
+${frontmatterStr}
+---
+${marker}
+
+${bodyStr}
+`;
+  }
+  /**
+   * Render Team Manifest YAML matching ClineTeamManifest schema.
+   * @param excludeAddons optional addon names to omit from `recommendedAddons`
+   *   (used to stop advertising bundles already present in the workspace).
+   */
+  static renderTeamManifest(bundle, scope, excludeAddons = []) {
+    const coordinatorFile = bundle.orchestrator || `${bundle.name}.md`;
+    const coordinatorName = coordinatorFile.replace(/\.md$/, "");
+    const coordinatorCanonical = `agents/${coordinatorFile}`;
+    const roles = (bundle.agents || []).map((agentFile) => ({
+      name: agentFile.replace(/\.md$/, ""),
+      canonicalPath: `agents/${agentFile}`
+    }));
+    const sortedSkills = [...bundle.skills || []].sort();
+    const sortedWorkflows = [...bundle.workflows || []].sort();
+    const recommendedAddons = (bundle.recommendedAddons || []).filter((a) => !excludeAddons.includes(a));
+    const manifest = {
+      schemaVersion: 1,
+      bundle: bundle.name,
+      scope,
+      coordinator: {
+        name: coordinatorName,
+        canonicalPath: coordinatorCanonical
+      },
+      roles,
+      skills: sortedSkills,
+      workflows: sortedWorkflows,
+      recommendedAddons,
+      activation: {
+        preferred: "named-team",
+        fallbacks: ["adaptive-session", "single-orchestrator"]
+      }
+    };
+    return yaml.stringify(manifest);
+  }
+  /**
+   * Render the coordinator rule file (.agents/plugins/<bundle>/rules/agents-united-<bundle>.md).
+   * @param excludeAddons optional addon names to omit from the "Recommended Addon
+   *   Policy" list (used to stop advertising bundles already installed).
+   */
+  static renderCoordinatorRule(bundle, scope, excludeAddons = []) {
+    const marker = `<!-- managed-by: agents-united | profile: cline | bundle: ${bundle.name} | do not edit -->`;
+    const manifestRelPath = scope === "global" ? `~/.agents/plugins/${bundle.name}/agents-united/teams/${bundle.name}.yaml` : `.agents/plugins/${bundle.name}/agents-united/teams/${bundle.name}.yaml`;
+    const coordinatorFile = bundle.orchestrator || `${bundle.name}.md`;
+    const coordinatorName = coordinatorFile.replace(/\.md$/, "");
+    const coordinatorCanonical = `agents/${coordinatorFile}`;
+    const specialistLines = (bundle.agents || []).map((agentFile) => {
+      const name = agentFile.replace(/\.md$/, "");
+      return `- **${name}**: \`.agents/agents/${agentFile}\``;
+    });
+    const addons = (bundle.recommendedAddons || []).filter((a) => !excludeAddons.includes(a));
+    const addonSection = addons.length > 0 ? `
+### Recommended Addon Policy
+When user tasks require capabilities from: ${addons.join(", ")}, explain the capability and request user confirmation to install via \`agents add <addon> -t cline -y\` before running the installation.` : "";
+    return `# Agents United \u2014 ${bundle.name} Coordinator Rule
+${marker}
+
+> Installed bundle: **${bundle.name}** (${scope} scope)
+> Team Manifest: \`${manifestRelPath}\`
+> Coordinator role: \`${coordinatorName}\` (\`.agents/${coordinatorCanonical}\`)
+
+## Activation Protocol
+1. At session start, read the Team Manifest (\`${manifestRelPath}\`) and coordinator role prompt (\`.agents/${coordinatorCanonical}\`).
+2. Delegate specialist tasks using **Agent Teams** (\`team_spawn_teammate\`, \`team_delegate_task\`) when available, assigning non-overlapping scopes.
+3. For lightweight read-only research, use session subagents.
+4. Only specialist roles declared in the Team Manifest are active in this workspace.
+${specialistLines.length > 0 ? `
+### Installed Specialist Roles
+${specialistLines.join("\n")}` : ""}
+${addonSection}
+`;
+  }
+  /**
+   * Plan all compound artifacts for a bundle installation into Cline.
+   * @param excludeAddons optional addon names forwarded to the coordinator rule and
+   *   team manifest renderers so already-installed bundles are not advertised.
+   */
+  static async planCompoundProjection(bundle, scope, resolved, registryDir, excludeAddons = []) {
+    const artifacts = [];
+    const baseDir = `.agents/plugins/${bundle.name}`;
+    const pluginManifest = {
+      name: `agents-united-${bundle.name}`,
+      version: "1.0.0",
+      description: bundle.description || "",
+      cline: {
+        plugins: [
+          {
+            capabilities: ["skills", "tools", "workflows"],
+            skills: ["./skills"]
+          }
+        ]
+      }
+    };
+    artifacts.push({
+      kind: "plugin-manifest",
+      relPath: `${baseDir}/package.json`.replace(/\\/g, "/"),
+      content: JSON.stringify(pluginManifest, null, 2),
+      managedMarker: false
+    });
+    for (const agentFile of resolved.agents) {
+      const canonicalRel = `agents/${agentFile}`;
+      const srcPath = path4.join(registryDir, "agents", agentFile);
+      if (await fs2.pathExists(srcPath)) {
+        const content = await fs2.readFile(srcPath, "utf8");
+        const rendered = this.renderRole(content, canonicalRel);
+        artifacts.push({
+          kind: "role",
+          canonical: canonicalRel,
+          relPath: `${baseDir}/agents/${agentFile}`.replace(/\\/g, "/"),
+          content: rendered,
+          managedMarker: true
+        });
+      }
+    }
+    for (const skillName of resolved.skills) {
+      const skillSrcDir = path4.join(registryDir, "skills", skillName);
+      if (await fs2.pathExists(skillSrcDir)) {
+        const entries = await fs2.readdir(skillSrcDir, { recursive: true, withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isFile()) {
+            const entryRel = path4.relative(skillSrcDir, path4.join(entry.parentPath || skillSrcDir, entry.name)).replace(/\\/g, "/");
+            const canonicalRel = `skills/${skillName}/${entryRel}`;
+            const targetRel = `${baseDir}/skills/${skillName}/${entryRel}`.replace(/\\/g, "/");
+            const fullSrcPath = path4.join(skillSrcDir, entryRel);
+            if (entry.name === "SKILL.md") {
+              const content = await fs2.readFile(fullSrcPath, "utf8");
+              const rendered = this.renderSkillMd(content, canonicalRel);
+              artifacts.push({
+                kind: "skill",
+                canonical: canonicalRel,
+                relPath: targetRel,
+                content: rendered,
+                managedMarker: true
+              });
+            } else {
+              artifacts.push({
+                kind: "skill",
+                canonical: canonicalRel,
+                relPath: targetRel,
+                sourceFilePath: fullSrcPath,
+                managedMarker: false
+              });
+            }
+          }
+        }
+      }
+    }
+    const ruleContent = this.renderCoordinatorRule(bundle, scope, excludeAddons);
+    artifacts.push({
+      kind: "rule",
+      relPath: `${baseDir}/rules/agents-united-${bundle.name}.md`.replace(/\\/g, "/"),
+      content: ruleContent,
+      managedMarker: true
+    });
+    const manifestContent = this.renderTeamManifest(bundle, scope, excludeAddons);
+    artifacts.push({
+      kind: "team-manifest",
+      relPath: `${baseDir}/agents-united/teams/${bundle.name}.yaml`.replace(/\\/g, "/"),
+      content: manifestContent,
+      managedMarker: false
+    });
+    return artifacts;
+  }
+};
+
+// src/core/projector.ts
+var ProjectionError = class extends Error {
+  fileName;
+  cause;
+  constructor(message, fileName, cause) {
+    super(message, { cause });
+    this.name = "ProjectionError";
+    this.fileName = fileName;
+    this.cause = cause;
+  }
+};
+var TOOL_NAME_MAP = {
+  view_file: "Read",
+  replace_file_content: "Edit",
+  write_to_file: "Write",
+  run_command: "Bash",
+  grep_search: "Grep",
+  list_dir: "Glob",
+  read_file: "Read",
+  search_file_content: "Grep",
+  apply_diff: "Edit",
+  web_search: "WebSearch"
+};
+var ANTIGRAVITY_ONLY_KEYS = [
+  "version",
+  "type",
+  "permissionMode",
+  "commandExecutionPolicy",
+  "mainAgent",
+  "subagent",
+  "hooks",
+  "inheritCustomizations",
+  "rules",
+  "effort"
+];
+var FRONTMATTER_REGEX = /^---\r?\n([\s\S]+?)\r?\n---/;
+var HostProjector = class _HostProjector {
+  /**
+   * Splits a canonical file into its YAML frontmatter metadata and markdown body.
+   * The returned body starts right after the closing `---` delimiter so callers can
+   * insert a managed marker as the very first body line.
+   */
+  static parseFrontmatter(content, fileName = "<memory>") {
+    const match = content.match(FRONTMATTER_REGEX);
+    if (!match) {
+      throw new ProjectionError(
+        `No YAML frontmatter found in ${fileName}. Expected a leading "---" block.`,
+        fileName
+      );
+    }
+    let parsed;
+    try {
+      parsed = YAML.parse(match[1]);
+    } catch (cause) {
+      const err = cause instanceof Error ? cause : new Error(typeof cause === "string" ? cause : "");
+      throw new ProjectionError(
+        `Invalid YAML frontmatter in ${fileName}: ${err.message}`,
+        fileName,
+        err
+      );
+    }
+    const meta = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    const body = content.slice(match[0].length).replace(/^\r?\n/, "");
+    return { meta, body };
+  }
+  /**
+     * Projects a canonical `.agents/` file into the given {@link ProjectionProfile}'s
+     * native dialect, stamping it with the managed marker and preserving the body
+     * verbatim (line endings normalized to `\n`).
+     */
+  static projectAgent(md, profile, canonicalRelPath) {
+    const { meta, body } = _HostProjector.parseFrontmatter(md, canonicalRelPath);
+    const warnings = [];
+    const normalizedBody = body.replace(/\r\n/g, "\n");
+    const marker = `<!-- managed-by: agents-united | profile: ${profile} | canonical: ${canonicalRelPath} | do not edit -->`;
+    if (profile === "agentsmd") {
+      const name = typeof meta.name === "string" ? meta.name : "(unnamed)";
+      const description = typeof meta.description === "string" ? meta.description.replace(/[\r\n]+/g, " ").replace(/\|/g, "\\|") : "";
+      const link = canonicalRelPath.replace(/\\/g, "/");
+      const content2 = [
+        `## ${name}`,
+        "",
+        `| ${name} | ${description} |`,
+        "| --- | --- |",
+        "",
+        `[View source](${link})`,
+        "",
+        marker,
+        ""
+      ].join("\n");
+      return { content: content2, warnings };
+    }
+    if (profile === "cline") {
+      const content2 = ClineProjector.renderRole(md, canonicalRelPath);
+      return { content: content2, warnings };
+    }
+    const out = {};
+    out.name = meta.name;
+    if (typeof meta.description === "string") {
+      out.description = meta.description;
+    }
+    if (meta.model !== void 0 && meta.model !== "inherit") {
+      out.model = meta.model;
+    }
+    for (const key of ANTIGRAVITY_ONLY_KEYS) {
+      delete out[key];
+    }
+    if (Array.isArray(meta.tools)) {
+      const translated = [];
+      for (const raw of meta.tools) {
+        if (typeof raw !== "string") {
+          continue;
+        }
+        const mapped = TOOL_NAME_MAP[raw];
+        if (mapped !== void 0) {
+          translated.push(mapped);
+        } else {
+          warnings.push(
+            `Dropping unknown tool "${raw}" for profile ${profile}: no known name mapping (never kept, never invented).`
+          );
+        }
+      }
+      out.tools = translated;
+    }
+    let yamlStr;
+    try {
+      yamlStr = YAML.stringify(out).replace(/\r\n/g, "\n").trimEnd();
+    } catch (cause) {
+      const err = cause instanceof Error ? cause : new Error(String(cause));
+      throw new ProjectionError(
+        `Failed to serialize frontmatter for ${canonicalRelPath}: ${err.message}`,
+        canonicalRelPath,
+        err
+      );
+    }
+    const content = `---
+${yamlStr}
+---
+${marker}
+${normalizedBody}`;
+    return { content, warnings };
+  }
+  /**
+   * Returns true when `content` is one of our managed projections. Agent projections
+   * carry the marker as the first body line after the frontmatter; the AGENTS.md
+   * bridge has no frontmatter, so the whole document is checked. Used to distinguish
+   * "our own deterministic projection" (safe to regenerate) from foreign user files
+   * (never overwritten without --force).
+   */
+  static hasManagedMarker(content) {
+    const match = content.match(FRONTMATTER_REGEX);
+    if (match) {
+      const rest = content.slice(match[0].length).replace(/^\r?\n/, "");
+      const firstLine = rest.split(/\r?\n/)[0] || "";
+      return firstLine.includes("managed-by: agents-united");
+    }
+    return content.includes("managed-by: agents-united");
+  }
+  /**
+   * Builds the root AGENTS.md bridge index, grouping canonical assets by type and
+   * linking each to its canonical `.agents/` path. Deterministic for identical input.
+   */
+  static buildAgentsMdIndex(assets) {
+    const sections = ["agent", "skill", "workflow"];
+    const lines = [];
+    lines.push("# agents-united \u2014 Managed Agents Index");
+    lines.push("");
+    lines.push("<!-- managed-by: agents-united | profile: agentsmd | do not edit -->");
+    lines.push("");
+    lines.push(
+      "This index links the canonical `.agents/` store for runtimes without a subagent loader. Files under `.claude/`, `.cursor/`, `.cline/`, and `.opencode/` are machine-managed projections (see marker lines)."
+    );
+    lines.push("");
+    for (const type of sections) {
+      const heading = type === "agent" ? "## Agents" : type === "skill" ? "## Skills" : "## Workflows";
+      lines.push(heading);
+      lines.push("");
+      const items = assets.filter((a) => a.type === type).map((a) => ({ ...a, relPath: a.relPath.replace(/\\/g, "/") }));
+      if (items.length === 0) {
+        lines.push("_none_");
+        lines.push("");
+        continue;
+      }
+      for (const item of items) {
+        lines.push(`- [${item.name}](${item.relPath})`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/core/installer.ts
+var InstallEngine = class _InstallEngine {
+  registry;
+  constructor(registry2) {
+    this.registry = registry2 || new RegistryResolver();
+  }
+  async calculateHash(filePath) {
+    const buffer = await fs3.readFile(filePath);
+    return "sha256:" + crypto.createHash("sha256").update(buffer).digest("hex");
+  }
+  async readLockfile(lockfilePath) {
+    if (await fs3.pathExists(lockfilePath)) {
+      try {
+        return await fs3.readJson(lockfilePath);
+      } catch {
+      }
+    }
+    return {
+      $schema: "https://agents-united.dev/schema/lockfile.v1.json",
+      version: 1,
+      installed: {
+        bundles: [],
+        agents: [],
+        skills: [],
+        workflows: []
+      },
+      files: {}
+    };
+  }
+  parseHosts(options) {
+    if (options.hosts && options.hosts.length > 0) {
+      return options.hosts;
+    }
+    if (options.target) {
+      const raw = Array.isArray(options.target) ? options.target.join(",") : options.target;
+      const parsed = raw.split(",").map((s) => s.trim().toLowerCase());
+      const valid = [];
+      for (const h of parsed) {
+        if (isKnownHost(h)) {
+          valid.push(h);
+        }
+      }
+      if (valid.length > 0) return valid;
+    }
+    return ["agents"];
+  }
+  parseMethod(options) {
+    if (options.copy) return "copy";
+    if (options.symlink || options.method === "symlink") return "symlink";
+    return options.method || "symlink";
+  }
+  parseScope(options) {
+    if (options.global) return "global";
+    return options.scope || "project";
+  }
+  async deployFile(src, dest, method, force) {
+    await fs3.ensureDir(path5.dirname(dest));
+    if (await fs3.pathExists(dest) || await fs3.pathExists(dest).catch(() => false)) {
+      if (force) {
+        await fs3.remove(dest);
+      }
+    }
+    if (method === "symlink") {
+      try {
+        const stat = await fs3.stat(src);
+        const type = stat.isDirectory() ? process.platform === "win32" ? "junction" : "dir" : "file";
+        await fs3.ensureSymlink(src, dest, type);
+        return "symlink";
+      } catch {
+        await fs3.copy(src, dest, { overwrite: true });
+        return "copy";
+      }
+    }
+    await fs3.copy(src, dest, { overwrite: true });
+    return "copy";
+  }
+  /**
+     * Writes a projection copy (never a symlink). Projections are always translated
+     * copies of canonical assets, so their bytes differ from the source.
+     */
+  async deployProjection(dest, content) {
+    await fs3.ensureDir(path5.dirname(dest));
+    await fs3.writeFile(dest, content, "utf8");
+  }
+  /**
+   * Computes the canonical `.agents/` target dir and the workspace root that contains
+   * it. Projections are recorded relative to this root (e.g. '.claude/agents/x.md').
+   */
+  static projectionRoot(scope, targetDir) {
+    const agentsTarget = AgentHostAdapter.resolveHostDir(scope, "agents", targetDir);
+    return { agentsTarget, root: path5.resolve(path5.dirname(agentsTarget)) };
+  }
+  toPosix(p) {
+    return p.split(path5.sep).join("/");
+  }
+  canonicalRelAgent(agentFile) {
+    return `.agents/agents/${agentFile}`;
+  }
+  lockRel(subdir, file) {
+    return path5.join(subdir, file);
+  }
+  destForProjection(host, root, file) {
+    const def = HOST_REGISTRY[host];
+    const base = resolveHostProjectDir(host, root);
+    if (def.agentsSubdir) return path5.join(base, def.agentsSubdir, file);
+    return base;
+  }
+  recordProjectedTo(lockfile, relKey, projPath) {
+    const normProj = this.toPosix(projPath);
+    const posixKey = relKey.replace(/\\/g, "/");
+    const sysKey = relKey.replace(/\//g, path5.sep);
+    const targetKey = lockfile.files[posixKey] ? posixKey : lockfile.files[sysKey] ? sysKey : relKey;
+    if (!lockfile.files[targetKey]) {
+      lockfile.files[targetKey] = { hash: "", installedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+    const asset = lockfile.files[targetKey];
+    asset.projectedTo = asset.projectedTo || [];
+    if (!asset.projectedTo.includes(normProj)) {
+      asset.projectedTo.push(normProj);
+    }
+  }
+  removeProjectedTo(lockfile, canonicalRelPath, projectedRelPath) {
+    const normProj = this.toPosix(projectedRelPath);
+    const posixKey = canonicalRelPath.replace(/\\/g, "/");
+    const sysKey = canonicalRelPath.replace(/\//g, path5.sep);
+    const targetKey = lockfile.files[posixKey] ? posixKey : lockfile.files[sysKey] ? sysKey : canonicalRelPath;
+    const asset = lockfile.files[targetKey];
+    if (asset && asset.projectedTo) {
+      asset.projectedTo = asset.projectedTo.filter((p) => p !== normProj);
+      if (asset.projectedTo.length === 0) {
+        delete asset.projectedTo;
+      }
+    }
+  }
+  async removeEmptyProjectionDirs(workspaceRoot, projPath) {
+    let dir = path5.dirname(path5.join(workspaceRoot, projPath));
+    while (dir !== workspaceRoot && dir.startsWith(workspaceRoot)) {
+      try {
+        const entries = await fs3.readdir(dir);
+        if (entries.length > 0) break;
+        await fs3.rmdir(dir);
+      } catch {
+        break;
+      }
+      dir = path5.dirname(dir);
+    }
+  }
+  /**
+   * Dry-run: compute the projection plan (paths + warnings) without writing anything.
+   */
+  async buildProjections(fanoutHosts, resolved, registryDir, scope, targetDir) {
+    const infos = [];
+    if (fanoutHosts.length === 0) return infos;
+    const { root } = _InstallEngine.projectionRoot(scope, targetDir);
+    for (const host of fanoutHosts) {
+      if (host === "codex") {
+        infos.push({ host, path: "AGENTS.md", kind: "bridge", warnings: [] });
+        continue;
+      }
+      if (host === "cline") {
+        const bundleDef = resolved.targetBundle ? await this.registry.getBundle(resolved.targetBundle) : void 0;
+        if (bundleDef) {
+          const artifacts = await ClineProjector.planCompoundProjection(bundleDef, scope, resolved, registryDir);
+          for (const artifact of artifacts) {
+            infos.push({ host, path: artifact.relPath, kind: artifact.kind, warnings: [] });
+          }
+          continue;
+        }
+      }
+      const base = resolveHostProjectDir(host, root);
+      const subdir = HOST_REGISTRY[host].agentsSubdir ?? "agents";
+      for (const agentFile of resolved.agents) {
+        const content = await fs3.readFile(path5.join(registryDir, "agents", agentFile), "utf8");
+        const res = HostProjector.projectAgent(content, HOST_REGISTRY[host].profile, this.canonicalRelAgent(agentFile));
+        const dest = path5.join(base, subdir, agentFile);
+        infos.push({ host, path: this.toPosix(path5.relative(root, dest)), kind: "role", warnings: res.warnings });
+      }
+    }
+    return infos;
+  }
+  /**
+   * Real fan-out: project canonical `.agents/` agents into each non-bridge host, build
+   * the root AGENTS.md bridge for `codex`, and record every projection in the lockfile
+   * of the canonical `.agents/` store that `targetDir` points at.
+   */
+  async applyFanout(fanoutHosts, resolved, registryDir, scope, targetDir, lockfile, options, projections) {
+    if (fanoutHosts.length === 0) return;
+    const { root } = _InstallEngine.projectionRoot(scope, options.targetDir);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const host of fanoutHosts) {
+      if (host === "codex") {
+        const assets = [];
+        resolved.agents.forEach((f) => assets.push({ name: f.replace(/\.md$/, ""), type: "agent", relPath: `.agents/agents/${f}` }));
+        resolved.workflows.forEach((f) => assets.push({ name: f.replace(/\.md$/, ""), type: "workflow", relPath: `.agents/workflows/${f}` }));
+        resolved.skills.forEach((s) => assets.push({ name: s, type: "skill", relPath: `.agents/skills/${s}/SKILL.md` }));
+        const bridge = HostProjector.buildAgentsMdIndex(assets);
+        const bridgeDest = path5.join(root, "AGENTS.md");
+        if (await fs3.pathExists(bridgeDest) && !options.force) {
+          const existing = await fs3.readFile(bridgeDest, "utf8");
+          if (!HostProjector.hasManagedMarker(existing)) {
+            throw new Error(
+              "File AGENTS.md already exists at the workspace root and is not managed by agents-united. Use --force to overwrite."
+            );
+          }
+        }
+        await this.deployProjection(bridgeDest, bridge);
+        projections.push({ host, path: "AGENTS.md", kind: "bridge", warnings: [] });
+        resolved.agents.forEach((f) => this.recordProjectedTo(lockfile, this.lockRel("agents", f), "AGENTS.md"));
+        resolved.workflows.forEach((f) => this.recordProjectedTo(lockfile, this.lockRel("workflows", f), "AGENTS.md"));
+        resolved.skills.forEach((s) => this.recordProjectedTo(lockfile, this.lockRel("skills", path5.join(s, "SKILL.md")), "AGENTS.md"));
+        continue;
+      }
+      if (host === "cline") {
+        const bundleDef = resolved.targetBundle ? await this.registry.getBundle(resolved.targetBundle) : void 0;
+        if (bundleDef) {
+          const declared = /* @__PURE__ */ new Set();
+          if (bundleDef.orchestrator) declared.add(`agents/${bundleDef.orchestrator}`);
+          (bundleDef.agents || []).forEach((a) => declared.add(`agents/${a}`));
+          (bundleDef.skills || []).forEach((s) => declared.add(`skills/${s}/SKILL.md`));
+          (bundleDef.workflows || []).forEach((w) => declared.add(`workflows/${w}`));
+          const artifacts = await ClineProjector.planCompoundProjection(bundleDef, scope, resolved, registryDir);
+          const newPaths = new Set(artifacts.map((a) => a.relPath));
+          if (lockfile.projections) {
+            for (const [projRelPath, proj] of Object.entries(lockfile.projections)) {
+              if (proj.host === "cline" && !newPaths.has(projRelPath) && proj.owners.includes(bundleDef.name)) {
+                proj.owners = proj.owners.filter((o) => o !== bundleDef.name);
+                if (proj.owners.length === 0) {
+                  const absProjection = path5.join(root, projRelPath);
+                  if (await fs3.pathExists(absProjection)) {
+                    await fs3.remove(absProjection);
+                    await this.removeEmptyProjectionDirs(root, projRelPath);
+                  }
+                  delete lockfile.projections[projRelPath];
+                }
+                if (proj.canonical) {
+                  this.removeProjectedTo(lockfile, proj.canonical, projRelPath);
+                }
+              }
+            }
+          }
+          if (lockfile.files) {
+            for (const [canonKey, fileMeta] of Object.entries(lockfile.files)) {
+              if (fileMeta.projectedTo) {
+                const staleClinePaths = fileMeta.projectedTo.filter((p) => p.startsWith(".cline/"));
+                for (const stalePath of staleClinePaths) {
+                  const absPath = path5.join(root, stalePath);
+                  if (await fs3.pathExists(absPath)) {
+                    await fs3.remove(absPath);
+                    await this.removeEmptyProjectionDirs(root, stalePath);
+                  }
+                  this.removeProjectedTo(lockfile, canonKey, stalePath);
+                }
+              }
+            }
+          }
+          for (const artifact of artifacts) {
+            const dest = path5.join(root, artifact.relPath);
+            if (await fs3.pathExists(dest) && !options.force) {
+              const existing = await fs3.readFile(dest, "utf8").catch(() => null);
+              if (existing !== null) {
+                if (artifact.managedMarker && !HostProjector.hasManagedMarker(existing)) {
+                  throw new Error(
+                    `Projection target ${artifact.relPath} already exists and is not managed by agents-united. Use --force to overwrite.`
+                  );
+                } else if (!artifact.managedMarker) {
+                  const registeredProj = lockfile.projections?.[artifact.relPath];
+                  if (!registeredProj) {
+                    throw new Error(
+                      `Projection target ${artifact.relPath} already exists and is not managed by agents-united. Use --force to overwrite.`
+                    );
+                  }
+                }
+              }
+            }
+            if (artifact.content !== void 0) {
+              await this.deployProjection(dest, artifact.content);
+            } else if (artifact.sourceFilePath) {
+              await fs3.ensureDir(path5.dirname(dest));
+              await fs3.copy(artifact.sourceFilePath, dest, { overwrite: true });
+            }
+            const deployedHash = await this.calculateHash(dest);
+            lockfile.projections = lockfile.projections || {};
+            const existingProj = lockfile.projections[artifact.relPath];
+            const bundleName = bundleDef.name;
+            const declares = artifact.kind === "rule" || artifact.kind === "team-manifest" || artifact.kind === "plugin-manifest" || (artifact.canonical ? declared.has(artifact.canonical) : false);
+            const priorOwners = existingProj?.owners ?? [];
+            const owners = declares ? Array.from(/* @__PURE__ */ new Set([...priorOwners, bundleName])) : priorOwners;
+            lockfile.projections[artifact.relPath] = {
+              host: "cline",
+              kind: artifact.kind,
+              canonical: artifact.canonical,
+              owners,
+              hash: deployedHash,
+              installedAt: existingProj?.installedAt ?? now,
+              managedMarker: artifact.managedMarker
+            };
+            projections.push({ host, path: artifact.relPath, kind: artifact.kind, warnings: [] });
+            if (artifact.canonical) {
+              this.recordProjectedTo(lockfile, artifact.canonical, artifact.relPath);
+            }
+          }
+          if (bundleDef.parentBundle) {
+            const parentDef = await this.registry.getBundle(bundleDef.parentBundle);
+            if (parentDef) {
+              const parentProjection = await ClineProjector.planCompoundProjection(
+                parentDef,
+                scope,
+                resolved,
+                registryDir,
+                lockfile.installed.bundles
+              );
+              for (const artifact of parentProjection) {
+                if (artifact.kind !== "rule" && artifact.kind !== "team-manifest") continue;
+                if (artifact.content === void 0) continue;
+                const dest = path5.join(root, artifact.relPath);
+                if (!await fs3.pathExists(dest)) continue;
+                await this.deployProjection(dest, artifact.content);
+                const deployedHash = await this.calculateHash(dest);
+                lockfile.projections = lockfile.projections || {};
+                const existingProj = lockfile.projections[artifact.relPath];
+                lockfile.projections[artifact.relPath] = {
+                  host: "cline",
+                  kind: artifact.kind,
+                  canonical: artifact.canonical,
+                  // Preserve existing ownership; the parent remains the sole owner.
+                  owners: existingProj?.owners ?? [],
+                  hash: deployedHash,
+                  installedAt: existingProj?.installedAt ?? now,
+                  managedMarker: artifact.managedMarker
+                };
+              }
+            }
+          }
+          continue;
+        }
+      }
+      const base = resolveHostProjectDir(host, root);
+      const subdir = HOST_REGISTRY[host].agentsSubdir ?? "agents";
+      for (const agentFile of resolved.agents) {
+        const content = await fs3.readFile(path5.join(registryDir, "agents", agentFile), "utf8");
+        const canonicalRel = this.canonicalRelAgent(agentFile);
+        const res = HostProjector.projectAgent(content, HOST_REGISTRY[host].profile, canonicalRel);
+        const dest = path5.join(base, subdir, agentFile);
+        if (await fs3.pathExists(dest) && !options.force) {
+          const existing = await fs3.readFile(dest, "utf8");
+          if (!HostProjector.hasManagedMarker(existing)) {
+            throw new Error(
+              `Projection target ${this.toPosix(path5.relative(root, dest))} already exists and is not managed by agents-united. Use --force to overwrite.`
+            );
+          }
+        }
+        await this.deployProjection(dest, res.content);
+        const projPath = this.toPosix(path5.relative(root, dest));
+        projections.push({ host, path: projPath, kind: "role", warnings: res.warnings });
+        this.recordProjectedTo(lockfile, this.lockRel("agents", agentFile), projPath);
+      }
+    }
+  }
+  async install(identifier, options = {}) {
+    const scope = this.parseScope(options);
+    const method = this.parseMethod(options);
+    const hosts = this.parseHosts(options);
+    const resolved = await this.registry.resolve(identifier);
+    const registryDir = this.registry.getRegistryDir();
+    const targetDirs = hosts.map((h) => AgentHostAdapter.resolveHostDir(scope, h, options.targetDir));
+    const hasCanonicalAgents = hosts.includes("agents");
+    const fanoutHosts = (options.fanout || []).map((h) => typeof h === "string" ? h.trim().toLowerCase() : h).filter((h) => isKnownHost(h) && HOST_REGISTRY[h]?.projectionCapable);
+    if (options.dryRun) {
+      const projections2 = hasCanonicalAgents ? await this.buildProjections(fanoutHosts, resolved, registryDir, scope, options.targetDir) : [];
+      return { installed: resolved, targetDirs, dryRun: true, method, projections: projections2 };
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const projections = [];
+    const agentsTarget = AgentHostAdapter.resolveHostDir(scope, "agents", options.targetDir);
+    for (const targetDir of targetDirs) {
+      const subPaths = AgentHostAdapter.getSubPaths(targetDir);
+      await fs3.ensureDir(subPaths.agentsDir);
+      await fs3.ensureDir(subPaths.skillsDir);
+      await fs3.ensureDir(subPaths.workflowsDir);
+      await fs3.ensureDir(subPaths.rulesDir);
+      const lockfile = await this.readLockfile(subPaths.lockfile);
+      lockfile.scope = scope;
+      lockfile.method = method;
+      lockfile.hosts = hosts;
+      const effectiveFanout = (options.fanout !== void 0 ? fanoutHosts : lockfile.fanout ?? []).filter((h) => isKnownHost(h) && HOST_REGISTRY[h]?.projectionCapable);
+      if (options.fanout !== void 0) {
+        lockfile.fanout = effectiveFanout;
+      }
+      const declared = /* @__PURE__ */ new Set();
+      if (resolved.targetBundle) {
+        const bundleDef = await this.registry.getBundle(resolved.targetBundle);
+        if (bundleDef) {
+          if (bundleDef.orchestrator) declared.add(`agents/${bundleDef.orchestrator}`);
+          (bundleDef.agents || []).forEach((a) => declared.add(`agents/${a}`));
+          (bundleDef.skills || []).forEach((s) => declared.add(`skills/${s}/SKILL.md`));
+          (bundleDef.workflows || []).forEach((w) => declared.add(`workflows/${w}`));
+        }
+      }
+      for (const agentFile of resolved.agents) {
+        const src = path5.join(registryDir, "agents", agentFile);
+        const dest = path5.join(subPaths.agentsDir, agentFile);
+        if (await fs3.pathExists(dest) && !options.force && method !== "symlink") {
+          const existingHash = await this.calculateHash(dest).catch(() => null);
+          const relPath2 = path5.relative(targetDir, dest);
+          if (existingHash && lockfile.files[relPath2] && lockfile.files[relPath2].hash !== existingHash) {
+            throw new Error(`File ${relPath2} has user modifications. Use --force to overwrite.`);
+          }
+        }
+        const actualMethod = await this.deployFile(src, dest, method, options.force);
+        const hash = await this.calculateHash(src);
+        const relPath = this.toPosix(path5.relative(targetDir, dest));
+        const existing = lockfile.files[relPath];
+        const existingOwners = existing?.owners ?? (existing?.bundle ? [existing.bundle] : []);
+        const declaresAsset = declared.has(`agents/${agentFile}`);
+        const owners = resolved.targetBundle && declaresAsset ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
+        lockfile.files[relPath] = {
+          hash,
+          bundle: existing?.bundle ?? resolved.targetBundle,
+          owners,
+          method: actualMethod,
+          installedAt: existing?.installedAt ?? now,
+          ...existing?.projectedTo ? { projectedTo: existing.projectedTo } : {}
+        };
+        if (!lockfile.installed.agents.includes(agentFile)) {
+          lockfile.installed.agents.push(agentFile);
+        }
+      }
+      for (const skillName of resolved.skills) {
+        const src = path5.join(registryDir, "skills", skillName);
+        const dest = path5.join(subPaths.skillsDir, skillName);
+        const actualMethod = await this.deployFile(src, dest, method, options.force);
+        const skillFile = path5.join(src, "SKILL.md");
+        if (await fs3.pathExists(skillFile)) {
+          const hash = await this.calculateHash(skillFile);
+          const relPath = this.toPosix(path5.relative(targetDir, path5.join(subPaths.skillsDir, skillName, "SKILL.md")));
+          const existing = lockfile.files[relPath];
+          const existingOwners = existing?.owners ?? (existing?.bundle ? [existing.bundle] : []);
+          const declaresAsset = declared.has(`skills/${skillName}/SKILL.md`);
+          const owners = resolved.targetBundle && declaresAsset ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
+          lockfile.files[relPath] = {
+            hash,
+            bundle: existing?.bundle ?? resolved.targetBundle,
+            owners,
+            method: actualMethod,
+            installedAt: existing?.installedAt ?? now,
+            ...existing?.projectedTo ? { projectedTo: existing.projectedTo } : {}
+          };
+        }
+        if (!lockfile.installed.skills.includes(skillName)) {
+          lockfile.installed.skills.push(skillName);
+        }
+      }
+      for (const workflowFile of resolved.workflows) {
+        const src = path5.join(registryDir, "workflows", workflowFile);
+        const dest = path5.join(subPaths.workflowsDir, workflowFile);
+        const actualMethod = await this.deployFile(src, dest, method, options.force);
+        const hash = await this.calculateHash(src);
+        const relPath = this.toPosix(path5.relative(targetDir, dest));
+        const existing = lockfile.files[relPath];
+        const existingOwners = existing?.owners ?? (existing?.bundle ? [existing.bundle] : []);
+        const declaresAsset = declared.has(`workflows/${workflowFile}`);
+        const owners = resolved.targetBundle && declaresAsset ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
+        lockfile.files[relPath] = {
+          hash,
+          bundle: existing?.bundle ?? resolved.targetBundle,
+          owners,
+          method: actualMethod,
+          installedAt: existing?.installedAt ?? now,
+          ...existing?.projectedTo ? { projectedTo: existing.projectedTo } : {}
+        };
+        if (!lockfile.installed.workflows.includes(workflowFile)) {
+          lockfile.installed.workflows.push(workflowFile);
+        }
+      }
+      for (const ruleFile of resolved.rules) {
+        const src = path5.join(registryDir, "rules", ruleFile);
+        const dest = path5.join(subPaths.rulesDir, ruleFile);
+        if (await fs3.pathExists(src)) {
+          const actualMethod = await this.deployFile(src, dest, method, options.force);
+          const hash = await this.calculateHash(src);
+          const relPath = this.toPosix(path5.relative(targetDir, dest));
+          const existing = lockfile.files[relPath];
+          const existingOwners = existing?.owners ?? (existing?.bundle ? [existing.bundle] : []);
+          const declaresAsset = true;
+          const owners = resolved.targetBundle && declaresAsset ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
+          lockfile.files[relPath] = {
+            hash,
+            bundle: existing?.bundle ?? resolved.targetBundle,
+            owners,
+            method: actualMethod,
+            installedAt: existing?.installedAt ?? now,
+            ...existing?.projectedTo ? { projectedTo: existing.projectedTo } : {}
+          };
+        }
+      }
+      if (resolved.targetBundle) {
+        if (!lockfile.installed.bundles.includes(resolved.targetBundle)) {
+          lockfile.installed.bundles.push(resolved.targetBundle);
+        }
+        lockfile.bundleVersions = lockfile.bundleVersions || {};
+        const bundleDef = await this.registry.getBundle(resolved.targetBundle);
+        lockfile.bundleVersions[resolved.targetBundle] = bundleDef?.version || "1.0.0";
+        if (options.mode) {
+          lockfile.bundleModes = lockfile.bundleModes || {};
+          lockfile.bundleModes[resolved.targetBundle] = options.mode;
+        }
+      }
+      if (hasCanonicalAgents && effectiveFanout.length > 0 && path5.resolve(targetDir) === path5.resolve(agentsTarget)) {
+        await this.applyFanout(effectiveFanout, resolved, registryDir, scope, targetDir, lockfile, options, projections);
+      }
+      await fs3.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
+    }
+    return { installed: resolved, targetDirs, dryRun: false, method, projections };
+  }
+};
+
+// src/core/uninstaller.ts
+import path6 from "path";
+import crypto2 from "crypto";
+import fs4 from "fs-extra";
+var UninstallEngine = class {
+  registry;
+  constructor(registry2) {
+    this.registry = registry2 || new RegistryResolver();
+  }
+  async calculateHash(filePath) {
+    const buffer = await fs4.readFile(filePath);
+    return "sha256:" + crypto2.createHash("sha256").update(buffer).digest("hex");
+  }
+  /**
+   * Determines whether a projected file still carries our managed marker. Agent
+   * projections have YAML frontmatter with the marker as the first body line; the
+   * AGENTS.md bridge (agentsmd profile) is a plain markdown index with no
+   * frontmatter, so the marker is checked against the whole content.
+   */
+  async isManagedProjection(absPath, isAgentsMd) {
+    const content = await fs4.readFile(absPath, "utf8");
+    if (isAgentsMd) {
+      return content.includes("managed-by: agents-united");
+    }
+    return HostProjector.hasManagedMarker(content);
+  }
+  /**
+   * Removes empty projection dirs left behind after deleting a projected file
+   * (e.g. `.claude/agents/` and then `.claude/`). Only ever removes empty dirs.
+   */
+  async removeEmptyProjectionDirs(workspaceRoot, projPath) {
+    let dir = path6.dirname(path6.join(workspaceRoot, projPath));
+    while (dir !== workspaceRoot && dir.startsWith(workspaceRoot)) {
+      try {
+        const entries = await fs4.readdir(dir);
+        if (entries.length > 0) break;
+        await fs4.rmdir(dir);
+      } catch {
+        break;
+      }
+      dir = path6.dirname(dir);
+    }
+  }
+  /**
+   * Removes every recorded projection for a canonical asset, guarding against
+   * clobbering user-modified files. Mirrors the hash-conflict error pattern.
+   */
+  async removeProjections(workspaceRoot, projectedTo, force) {
+    for (const projPath of projectedTo) {
+      const absProjection = path6.join(workspaceRoot, projPath);
+      if (!await fs4.pathExists(absProjection)) {
+        continue;
+      }
+      const isAgentsMd = projPath === "AGENTS.md";
+      const managed = await this.isManagedProjection(absProjection, isAgentsMd);
+      if (!managed && !force) {
+        throw new Error(
+          `Projection ${projPath} has user modifications. Use --force to remove.`
+        );
+      }
+      await this.safeRemoveProjection(absProjection);
+      await this.removeEmptyProjectionDirs(workspaceRoot, projPath);
+    }
+  }
+  async safeRemoveProjection(absPath) {
+    try {
+      const lstat = await fs4.lstat(absPath);
+      if (lstat.isSymbolicLink()) {
+        await fs4.unlink(absPath);
+        return;
+      }
+    } catch {
+    }
+    await fs4.remove(absPath);
+  }
+  /**
+   * Installed-addon freshness (plan 003): after a child bundle (one with a
+   * `parentBundle`) is removed, re-render the parent's coordinator rule + team
+   * manifest excluding every remaining installed bundle in the lockfile, so the
+   * removed addon returns to the parent's recommendedAddons. Presentation-free:
+   * the two projection files carry the managed marker trustees inside (rule) and
+   * are overwritten directly via fs-extra. If a parent artifact does not exist in
+   * the workspace (parent not installed as its own bundle), it is skipped.
+   */
+  async refreshParentCoordination(bundleName, workspaceRoot, lockfile, scope) {
+    const bundleDef = await this.registry.getBundle(bundleName);
+    if (!bundleDef?.parentBundle) return;
+    const parentDef = await this.registry.getBundle(bundleDef.parentBundle);
+    if (!parentDef) return;
+    const parentResolved = await this.registry.resolve(parentDef.name).catch(() => null);
+    if (!parentResolved) return;
+    const registryDir = this.registry.getRegistryDir();
+    const projection = await ClineProjector.planCompoundProjection(
+      parentDef,
+      scope,
+      parentResolved,
+      registryDir,
+      lockfile.installed.bundles
+    );
+    for (const artifact of projection) {
+      if (artifact.kind !== "rule" && artifact.kind !== "team-manifest") continue;
+      if (artifact.content === void 0) continue;
+      const dest = path6.join(workspaceRoot, artifact.relPath);
+      if (!await fs4.pathExists(dest)) continue;
+      await fs4.writeFile(dest, artifact.content, "utf8");
+      const hash = await this.calculateHash(dest);
+      if (lockfile.projections?.[artifact.relPath]) {
+        lockfile.projections[artifact.relPath].hash = hash;
+      }
+    }
+  }
+  parseHosts(options) {
+    if (options.hosts && options.hosts.length > 0) return options.hosts;
+    if (options.target) {
+      const raw = Array.isArray(options.target) ? options.target.join(",") : options.target;
+      const parsed = raw.split(",").map((s) => s.trim().toLowerCase());
+      const valid = parsed.filter(isKnownHost);
+      if (valid.length > 0) return valid;
+    }
+    return ["agents"];
+  }
+  parseScope(options) {
+    if (options.global) return "global";
+    return options.scope || "project";
+  }
+  async safeRemove(targetDir, relPath) {
+    const fullPath = path6.join(targetDir, relPath);
+    if (relPath.startsWith("skills" + path6.sep) || relPath.startsWith("skills/")) {
+      const parts = relPath.split(/[/\\]/);
+      if (parts.length >= 2) {
+        const skillDir = path6.join(targetDir, parts[0], parts[1]);
+        try {
+          const lstat = await fs4.lstat(skillDir);
+          if (lstat.isSymbolicLink()) {
+            await fs4.unlink(skillDir);
+            return;
+          }
+        } catch {
+        }
+      }
+    }
+    try {
+      const lstat = await fs4.lstat(fullPath);
+      if (lstat.isSymbolicLink()) {
+        await fs4.unlink(fullPath);
+        return;
+      }
+    } catch {
+    }
+    await fs4.remove(fullPath);
+  }
+  async uninstall(identifier, options = {}) {
+    const scope = this.parseScope(options);
+    const hosts = this.parseHosts(options);
+    const targetDirs = hosts.map((h) => AgentHostAdapter.resolveHostDir(scope, h, options.targetDir));
+    const resolved = await this.registry.resolve(identifier).catch(() => null);
+    const totalRemoved = [];
+    for (const targetDir of targetDirs) {
+      const subPaths = AgentHostAdapter.getSubPaths(targetDir);
+      if (!await fs4.pathExists(subPaths.lockfile)) {
+        continue;
+      }
+      const lockfile = await fs4.readJson(subPaths.lockfile);
+      const removedFiles = [];
+      if (resolved && resolved.targetBundle) {
+        const bundleName = resolved.targetBundle;
+        if (lockfile.installed.bundles.includes(bundleName)) {
+          if (!options.dryRun) {
+            const workspaceRoot = path6.resolve(path6.dirname(targetDir));
+            const ownedFiles = Object.entries(lockfile.files).filter(([, m]) => (m.owners ?? (m.bundle ? [m.bundle] : [])).includes(bundleName));
+            const ownedProjections = lockfile.projections ? Object.values(lockfile.projections).filter((p) => p.owners.includes(bundleName)).length : 0;
+            if (ownedFiles.length === 0 && ownedProjections === 0) {
+              throw new Error(`No installed assets found matching "${bundleName}".`);
+            }
+            if (lockfile.projections) {
+              for (const [projRelPath, proj] of Object.entries(lockfile.projections)) {
+                if (proj.owners.includes(bundleName)) {
+                  proj.owners = proj.owners.filter((o) => o !== bundleName);
+                  if (proj.owners.length === 0) {
+                    const absProjection = path6.join(workspaceRoot, projRelPath);
+                    if (await fs4.pathExists(absProjection)) {
+                      if (proj.managedMarker) {
+                        const managed = await this.isManagedProjection(absProjection, projRelPath === "AGENTS.md");
+                        if (!managed && !options.force) {
+                          throw new Error(`Projection ${projRelPath} has user modifications. Use --force to remove.`);
+                        }
+                      } else {
+                        const currentHash = await this.calculateHash(absProjection).catch(() => null);
+                        if (currentHash && currentHash !== proj.hash && !options.force) {
+                          throw new Error(`Projection ${projRelPath} has user modifications. Use --force to remove.`);
+                        }
+                      }
+                      await this.safeRemoveProjection(absProjection);
+                      await this.removeEmptyProjectionDirs(workspaceRoot, projRelPath);
+                    }
+                    delete lockfile.projections[projRelPath];
+                  }
+                }
+              }
+            }
+            for (const [relPath, assetMeta] of Object.entries(lockfile.files)) {
+              const assetOwners = assetMeta.owners ?? (assetMeta.bundle ? [assetMeta.bundle] : []);
+              if (!assetOwners.includes(bundleName)) continue;
+              const newOwners = assetOwners.filter((o) => o !== bundleName);
+              if (newOwners.length === 0) {
+                if (assetMeta.projectedTo && assetMeta.projectedTo.length > 0) {
+                  await this.removeProjections(workspaceRoot, assetMeta.projectedTo, options.force);
+                }
+                const fullPath = path6.join(targetDir, relPath);
+                if (await fs4.pathExists(fullPath) || await fs4.pathExists(fullPath).catch(() => false)) {
+                  if (!options.force && assetMeta.method !== "symlink") {
+                    const currentHash = await this.calculateHash(fullPath).catch(() => null);
+                    if (currentHash && currentHash !== assetMeta.hash) {
+                      throw new Error(`File ${relPath} has user modifications. Use --force to remove.`);
+                    }
+                  }
+                  await this.safeRemove(targetDir, relPath);
+                  removedFiles.push(relPath);
+                }
+                delete lockfile.files[relPath];
+              } else {
+                lockfile.files[relPath] = { ...assetMeta, owners: newOwners };
+              }
+            }
+            lockfile.installed.bundles = lockfile.installed.bundles.filter((b) => b !== bundleName);
+            if (lockfile.bundleVersions) {
+              delete lockfile.bundleVersions[bundleName];
+            }
+            const surviving = lockfile.installed.bundles.filter((b) => b !== bundleName);
+            const survival = /* @__PURE__ */ new Set();
+            for (const b of surviving) {
+              const bdef = await this.registry.getBundle(b);
+              if (!bdef) continue;
+              if (bdef.orchestrator) survival.add(`agents/${bdef.orchestrator}`);
+              (bdef.agents || []).forEach((a) => survival.add(`agents/${a}`));
+              (bdef.skills || []).forEach((s) => survival.add(`skills/${s}/SKILL.md`));
+              (bdef.workflows || []).forEach((w) => survival.add(`workflows/${w}`));
+            }
+            lockfile.installed.agents = lockfile.installed.agents.filter((a) => survival.has(`agents/${a}`));
+            lockfile.installed.skills = lockfile.installed.skills.filter((s) => survival.has(`skills/${s}/SKILL.md`));
+            lockfile.installed.workflows = lockfile.installed.workflows.filter((w) => survival.has(`workflows/${w}`));
+            await this.refreshParentCoordination(bundleName, workspaceRoot, lockfile, scope);
+            await fs4.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
+          } else {
+            removedFiles.push(...resolved.agents, ...resolved.skills, ...resolved.workflows);
+          }
+        }
+      } else {
+        const itemTargetRelPaths = Object.keys(lockfile.files).filter((p) => p.includes(identifier));
+        if (!options.dryRun) {
+          for (const relPath of itemTargetRelPaths) {
+            const fullPath = path6.join(targetDir, relPath);
+            if (await fs4.pathExists(fullPath) || await fs4.pathExists(fullPath).catch(() => false)) {
+              if (!options.force && lockfile.files[relPath]?.method !== "symlink") {
+                const currentHash = await this.calculateHash(fullPath).catch(() => null);
+                const assetMeta = lockfile.files[relPath];
+                if (currentHash && assetMeta && currentHash !== assetMeta.hash) {
+                  throw new Error(`File ${relPath} has user modifications. Use --force to remove.`);
+                }
+              }
+              await this.safeRemove(targetDir, relPath);
+              removedFiles.push(relPath);
+            }
+            delete lockfile.files[relPath];
+          }
+          await fs4.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
+        } else {
+          removedFiles.push(...itemTargetRelPaths);
+        }
+      }
+      totalRemoved.push(...removedFiles);
+    }
+    if (totalRemoved.length === 0 && !options.dryRun) {
+      throw new Error(`No installed assets found matching "${identifier}".`);
+    }
+    return { removed: totalRemoved, targetDirs, dryRun: options.dryRun || false };
+  }
+};
+
+// src/core/inventory.ts
+import path7 from "path";
+import os2 from "os";
+import fs5 from "fs-extra";
+var InventoryScanner = class _InventoryScanner {
+  registry;
+  constructor(registry2) {
+    this.registry = registry2 || new RegistryResolver();
+  }
+  static formatDisplayLocation(scope, host, targetDir) {
+    const home = os2.homedir();
+    const cwd = process.cwd();
+    let prettyPath = targetDir;
+    if (targetDir.startsWith(cwd)) {
+      const rel = path7.relative(cwd, targetDir);
+      prettyPath = rel ? `./${rel.replace(/\\/g, "/")}` : ".";
+    } else if (targetDir.startsWith(home)) {
+      const rel = path7.relative(home, targetDir);
+      prettyPath = `~/${rel.replace(/\\/g, "/")}`;
+    }
+    return `[${scope}: ${prettyPath}]`;
+  }
+  parseHosts(options) {
+    if (options.hosts && options.hosts.length > 0) return options.hosts;
+    if (options.target) {
+      const raw = Array.isArray(options.target) ? options.target.join(",") : options.target;
+      const parsed = raw.split(",").map((s) => s.trim().toLowerCase());
+      const valid = parsed.filter((h) => KNOWN_HOST_IDS.includes(h));
+      if (valid.length > 0) return valid;
+    }
+    return [...KNOWN_HOST_IDS];
+  }
+  async scan(options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const hosts = this.parseHosts(options);
+    const scopes = [];
+    if (options.global || options.scope === "global") {
+      scopes.push("global");
+    } else if (options.scope === "project") {
+      scopes.push("project");
+    } else {
+      scopes.push("project", "global");
+    }
+    const candidateDirs = [];
+    if (options.targetDir) {
+      candidateDirs.push({
+        dir: path7.resolve(options.targetDir),
+        scope: options.scope || "project",
+        host: hosts[0] || "agents"
+      });
+    } else {
+      for (const scope of scopes) {
+        for (const host of hosts) {
+          const dir = AgentHostAdapter.resolveHostDir(scope, host);
+          candidateDirs.push({ dir, scope, host });
+        }
+      }
+    }
+    const allRecords = [];
+    const bundleRecords = [];
+    const standaloneRecords = [];
+    const scannedTargetDirs = /* @__PURE__ */ new Set();
+    for (const item of candidateDirs) {
+      const lockfilePath = path7.join(item.dir, "agents-united.json");
+      if (!await fs5.pathExists(lockfilePath)) {
+        continue;
+      }
+      scannedTargetDirs.add(item.dir);
+      let lockfile;
+      try {
+        lockfile = await fs5.readJson(lockfilePath);
+      } catch {
+        continue;
+      }
+      const displayLocation = _InventoryScanner.formatDisplayLocation(item.scope, item.host, item.dir);
+      const bundleOwnedSkills = /* @__PURE__ */ new Set();
+      const bundleOwnedAgents = /* @__PURE__ */ new Set();
+      const bundleOwnedWorkflows = /* @__PURE__ */ new Set();
+      const installedBundleNames = lockfile.installed?.bundles || [];
+      for (const bundleName of installedBundleNames) {
+        const bundleDef = await this.registry.getBundle(bundleName).catch(() => null);
+        const resolvedBundle = await this.registry.resolve(bundleName).catch(() => null);
+        const installedVersion = lockfile.bundleVersions?.[bundleName] || "1.0.0";
+        const upstreamVersion = bundleDef?.version || "1.0.0";
+        let driftStatus = "up-to-date";
+        if (installedVersion !== upstreamVersion) {
+          driftStatus = "outdated";
+        }
+        let fileCount = 0;
+        if (lockfile.files) {
+          fileCount = Object.values(lockfile.files).filter((f) => f.bundle === bundleName).length;
+        }
+        if (resolvedBundle) {
+          resolvedBundle.skills?.forEach((s) => bundleOwnedSkills.add(s));
+          resolvedBundle.agents?.forEach((a) => {
+            bundleOwnedAgents.add(a);
+            bundleOwnedAgents.add(a.replace(/\.md$/, ""));
+          });
+          resolvedBundle.workflows?.forEach((w) => {
+            bundleOwnedWorkflows.add(w);
+            bundleOwnedWorkflows.add(w.replace(/\.md$/, ""));
+          });
+        }
+        if (bundleDef) {
+          if (bundleDef.orchestrator) {
+            bundleOwnedAgents.add(bundleDef.orchestrator);
+            bundleOwnedAgents.add(bundleDef.orchestrator.replace(/\.md$/, ""));
+          }
+          bundleDef.skills?.forEach((s) => bundleOwnedSkills.add(s));
+          bundleDef.agents?.forEach((a) => {
+            bundleOwnedAgents.add(a);
+            bundleOwnedAgents.add(a.replace(/\.md$/, ""));
+          });
+          bundleDef.workflows?.forEach((w) => {
+            bundleOwnedWorkflows.add(w);
+            bundleOwnedWorkflows.add(w.replace(/\.md$/, ""));
+          });
+        }
+        const record = {
+          id: `${bundleName}@${item.scope}:${item.host}`,
+          name: bundleName,
+          type: "bundle",
+          scope: item.scope,
+          host: item.host,
+          targetDir: item.dir,
+          displayLocation,
+          installedVersion,
+          upstreamVersion,
+          driftStatus,
+          method: lockfile.method || "symlink",
+          fileCount,
+          title: bundleDef?.name || bundleName,
+          description: bundleDef?.description
+        };
+        allRecords.push(record);
+        bundleRecords.push(record);
+      }
+      const installedSkills = lockfile.installed?.skills || [];
+      for (const skillName of installedSkills) {
+        if (bundleOwnedSkills.has(skillName)) continue;
+        const record = {
+          id: `skill:${skillName}@${item.scope}:${item.host}`,
+          name: skillName,
+          type: "skill",
+          scope: item.scope,
+          host: item.host,
+          targetDir: item.dir,
+          displayLocation,
+          installedVersion: "1.0.0",
+          upstreamVersion: "1.0.0",
+          driftStatus: "up-to-date",
+          method: lockfile.method || "symlink",
+          fileCount: 1,
+          title: skillName,
+          description: `Standalone skill (${skillName})`
+        };
+        allRecords.push(record);
+        standaloneRecords.push(record);
+      }
+      const installedAgents = lockfile.installed?.agents || [];
+      for (const agentFile of installedAgents) {
+        if (bundleOwnedAgents.has(agentFile)) continue;
+        const agentName = agentFile.replace(/\.md$/, "");
+        const record = {
+          id: `agent:${agentName}@${item.scope}:${item.host}`,
+          name: agentName,
+          type: "agent",
+          scope: item.scope,
+          host: item.host,
+          targetDir: item.dir,
+          displayLocation,
+          installedVersion: "1.0.0",
+          upstreamVersion: "1.0.0",
+          driftStatus: "up-to-date",
+          method: lockfile.method || "symlink",
+          fileCount: 1,
+          title: agentName,
+          description: `Standalone agent (${agentFile})`
+        };
+        allRecords.push(record);
+        standaloneRecords.push(record);
+      }
+    }
+    return {
+      records: allRecords,
+      bundles: bundleRecords,
+      standaloneItems: standaloneRecords,
+      targetDirs: Array.from(scannedTargetDirs)
+    };
+  }
+};
+
+// src/core/updater.ts
+import path8 from "path";
+import crypto3 from "crypto";
+import fs6 from "fs-extra";
+var UpdateEngine = class {
+  registry;
+  scanner;
+  installer;
+  constructor(registry2, scanner2, installer2) {
+    this.registry = registry2 || new RegistryResolver();
+    this.scanner = scanner2 || new InventoryScanner(this.registry);
+    this.installer = installer2 || new InstallEngine(this.registry);
+  }
+  async calculateHash(filePath) {
+    const buffer = await fs6.readFile(filePath);
+    return "sha256:" + crypto3.createHash("sha256").update(buffer).digest("hex");
+  }
+  /**
+   * Determines whether a projected file still carries our managed marker (plan 007
+   * M5). Agent projections place the marker as the first body line after frontmatter;
+   * the AGENTS.md bridge has no frontmatter so it is checked over the whole content.
+   */
+  async isManagedProjection(absPath, isAgentsMd) {
+    const content = await fs6.readFile(absPath, "utf8");
+    if (isAgentsMd) {
+      return content.includes("managed-by: agents-united");
+    }
+    return HostProjector.hasManagedMarker(content);
+  }
+  /**
+   * Returns the first user-modified projection path belonging to a record, or '' when
+   * every recorded projection still carries the managed marker.
+   */
+  async staleProjection(record, lockfile) {
+    let workspaceRoot = path8.dirname(record.targetDir);
+    for (const assetMeta of Object.values(lockfile.files)) {
+      if (assetMeta.bundle !== record.name) continue;
+      if (!assetMeta.projectedTo || assetMeta.projectedTo.length === 0) continue;
+      for (const projPath of assetMeta.projectedTo) {
+        const absProjection = path8.join(workspaceRoot, projPath);
+        if (await fs6.pathExists(absProjection)) {
+          const managed = await this.isManagedProjection(absProjection, projPath === "AGENTS.md");
+          if (!managed) {
+            return projPath;
+          }
+        }
+      }
+    }
+    return "";
+  }
+  async checkUpdates(options = {}) {
+    const inventory = await this.scanner.scan(options);
+    const items = [];
+    for (const record of inventory.records) {
+      const hasUpdate = record.driftStatus === "outdated" || record.installedVersion !== record.upstreamVersion;
+      items.push({
+        record,
+        hasUpdate,
+        installedVersion: record.installedVersion,
+        upstreamVersion: record.upstreamVersion,
+        reason: hasUpdate ? `Upstream version (${record.upstreamVersion}) is newer than installed version (${record.installedVersion})` : void 0
+      });
+    }
+    const outdatedCount = items.filter((i) => i.hasUpdate).length;
+    const upToDateCount = items.filter((i) => !i.hasUpdate).length;
+    return {
+      items,
+      outdatedCount,
+      upToDateCount,
+      totalCount: items.length
+    };
+  }
+  async update(targets, options = {}) {
+    const inventory = await this.scanner.scan({
+      scope: options.scope,
+      global: options.global,
+      hosts: options.hosts,
+      target: options.target,
+      targetDir: options.targetDir,
+      cwd: options.cwd
+    });
+    const isAll = targets === "__all__" || targets === "*" || Array.isArray(targets) && targets.includes("__all__");
+    const targetList = Array.isArray(targets) ? targets : [targets];
+    const recordsToUpdate = inventory.records.filter((r) => {
+      if (isAll) return true;
+      return targetList.includes(r.name) || targetList.includes(r.id);
+    });
+    if (recordsToUpdate.length === 0) {
+      return {
+        updated: [],
+        skipped: [],
+        targetDirs: inventory.targetDirs,
+        dryRun: options.dryRun || false
+      };
+    }
+    if (options.dryRun) {
+      return {
+        updated: recordsToUpdate,
+        skipped: [],
+        targetDirs: inventory.targetDirs,
+        dryRun: true
+      };
+    }
+    const updated = [];
+    const skipped = [];
+    for (const record of recordsToUpdate) {
+      const lockfilePath = path8.join(record.targetDir, "agents-united.json");
+      if (!await fs6.pathExists(lockfilePath)) {
+        continue;
+      }
+      const lockfile = await fs6.readJson(lockfilePath);
+      if (record.method === "copy" && !options.force && lockfile.files) {
+        let hasConflict = false;
+        let conflictRelPath = "";
+        for (const [relPath, assetMeta] of Object.entries(lockfile.files)) {
+          if (assetMeta.bundle === record.name || relPath.includes(record.name)) {
+            const fullPath = path8.join(record.targetDir, relPath);
+            if (await fs6.pathExists(fullPath)) {
+              const currentHash = await this.calculateHash(fullPath).catch(() => null);
+              if (currentHash && currentHash !== assetMeta.hash) {
+                hasConflict = true;
+                conflictRelPath = relPath;
+                break;
+              }
+            }
+          }
+        }
+        if (hasConflict) {
+          skipped.push({
+            record,
+            reason: `User modifications detected in ${conflictRelPath}. Use --force to overwrite.`
+          });
+          continue;
+        }
+      }
+      if (!options.force && lockfile.files) {
+        const stale = await this.staleProjection(record, lockfile);
+        if (stale) {
+          skipped.push({
+            record,
+            reason: `User modifications detected in projection ${stale}. Use --force to overwrite.`
+          });
+          continue;
+        }
+      }
+      await this.installer.install(record.name, {
+        scope: record.scope,
+        method: record.method,
+        hosts: [record.host],
+        targetDir: record.targetDir,
+        fanout: options.fanout,
+        force: true
+        // force overwrite since we passed collision check above
+      });
+      if (await fs6.pathExists(lockfilePath)) {
+        const updatedLockfile = await fs6.readJson(lockfilePath);
+        updatedLockfile.bundleVersions = updatedLockfile.bundleVersions || {};
+        updatedLockfile.bundleVersions[record.name] = record.upstreamVersion;
+        await fs6.writeJson(lockfilePath, updatedLockfile, { spaces: 2 });
+      }
+      record.installedVersion = record.upstreamVersion;
+      record.driftStatus = "up-to-date";
+      updated.push(record);
+    }
+    return {
+      updated,
+      skipped,
+      targetDirs: inventory.targetDirs,
+      dryRun: false
+    };
+  }
+};
+
+// src/core/doctor.ts
+import path10 from "path";
+import fs8 from "fs-extra";
+import YAML2 from "yaml";
+
+// src/core/cline-capabilities.ts
+import path9 from "path";
+import fs7 from "fs-extra";
+import { execFile } from "child_process";
+var defaultProcessRunner = (executable, args, options) => {
+  return new Promise((resolve) => {
+    const timeout = options?.timeoutMs ?? 5e3;
+    try {
+      execFile(
+        executable,
+        args,
+        {
+          cwd: options?.cwd,
+          env: options?.env ? { ...process.env, ...options.env } : process.env,
+          timeout,
+          shell: false
+        },
+        (error, stdout, stderr) => {
+          if (error) {
+            const exitCode = typeof error.code === "number" ? error.code : 1;
+            resolve({
+              exitCode,
+              stdout: (stdout || "").toString(),
+              stderr: (stderr || error.message || "").toString()
+            });
+          } else {
+            resolve({
+              exitCode: 0,
+              stdout: (stdout || "").toString(),
+              stderr: (stderr || "").toString()
+            });
+          }
+        }
+      );
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      resolve({
+        exitCode: 1,
+        stdout: "",
+        stderr: msg
+      });
+    }
+  });
+};
+var ClineCapabilityProbe = class {
+  runner;
+  customResolver;
+  constructor(runner, options) {
+    this.runner = runner || defaultProcessRunner;
+    this.customResolver = options?.resolveExecutable;
+  }
+  /**
+   * Safe executable resolution across POSIX and Windows layouts.
+   */
+  resolveExecutable() {
+    if (this.customResolver) {
+      return this.customResolver();
+    }
+    const envBin = process.env.CLINE_BIN_PATH;
+    if (envBin && path9.isAbsolute(envBin) && fs7.existsSync(envBin)) {
+      return {
+        executable: envBin,
+        prefixArgs: [],
+        source: "env-binary"
+      };
+    }
+    const pathEnv = process.env.PATH || "";
+    const pathSeparator = process.platform === "win32" ? ";" : ":";
+    const dirs = pathEnv.split(pathSeparator).filter(Boolean);
+    if (process.platform === "win32") {
+      const exeNames = ["cline.cmd", "cline.bat", "cline.exe", "cline"];
+      for (const dir of dirs) {
+        for (const exeName of exeNames) {
+          const fullPath = path9.join(dir, exeName);
+          if (fs7.existsSync(fullPath)) {
+            const adjacentWrapper1 = path9.join(dir, "node_modules", "cline", "bin", "cline");
+            const adjacentWrapper2 = path9.join(dir, "node_modules", "@cline", "cline", "bin", "cline");
+            if (fs7.existsSync(adjacentWrapper1)) {
+              return {
+                executable: process.execPath,
+                prefixArgs: [adjacentWrapper1],
+                source: "node-wrapper"
+              };
+            }
+            if (fs7.existsSync(adjacentWrapper2)) {
+              return {
+                executable: process.execPath,
+                prefixArgs: [adjacentWrapper2],
+                source: "node-wrapper"
+              };
+            }
+            return {
+              executable: fullPath,
+              prefixArgs: [],
+              source: "path-executable"
+            };
+          }
+        }
+      }
+    } else {
+      for (const dir of dirs) {
+        const fullPath = path9.join(dir, "cline");
+        if (fs7.existsSync(fullPath)) {
+          return {
+            executable: fullPath,
+            prefixArgs: [],
+            source: "path-executable"
+          };
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Run read-only capability probe against local Cline.
+   */
+  async probe() {
+    const cmd = this.resolveExecutable();
+    const diagnostics = [];
+    if (!cmd) {
+      diagnostics.push("Cline executable not found on PATH or via CLINE_BIN_PATH.");
+      return {
+        installed: false,
+        namedTeams: false,
+        rolePresetConsumer: "unknown",
+        diagnostics
+      };
+    }
+    let version;
+    try {
+      const verRes = await this.runner(cmd.executable, [...cmd.prefixArgs, "version"], {
+        timeoutMs: 5e3
+      });
+      if (verRes.exitCode === 0) {
+        version = verRes.stdout.trim().split("\n")[0]?.trim();
+      } else {
+        diagnostics.push(`Cline version check failed (exit code ${verRes.exitCode}): ${verRes.stderr.trim()}`);
+        return {
+          installed: false,
+          command: cmd,
+          namedTeams: false,
+          rolePresetConsumer: "unknown",
+          diagnostics
+        };
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      diagnostics.push(`Error executing Cline version check: ${msg}`);
+      return {
+        installed: false,
+        command: cmd,
+        namedTeams: false,
+        rolePresetConsumer: "unknown",
+        diagnostics
+      };
+    }
+    let namedTeams = false;
+    try {
+      const probeRes = await this.runner(
+        cmd.executable,
+        [...cmd.prefixArgs, "--team-name", "agents-united-capability-probe", "version"],
+        { timeoutMs: 5e3 }
+      );
+      if (probeRes.exitCode === 0) {
+        namedTeams = true;
+      } else {
+        diagnostics.push(`Named teams probe returned non-zero (exit code ${probeRes.exitCode}). Falling back to adaptive session.`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      diagnostics.push(`Named teams probe failed: ${msg}`);
+    }
+    return {
+      installed: true,
+      version,
+      command: cmd,
+      namedTeams,
+      rolePresetConsumer: "unknown",
+      diagnostics
+    };
+  }
+};
+
+// src/core/doctor.ts
+var DoctorEngine = class {
+  static async isManagedProjection(absPath, isAgentsMd) {
+    const content = await fs8.readFile(absPath, "utf8");
+    if (isAgentsMd) {
+      return content.includes("managed-by: agents-united");
+    }
+    return HostProjector.hasManagedMarker(content);
+  }
+  static async runDoctor(targetDir, host) {
+    const root = AgentHostAdapter.resolveHostDir("project", "agents", targetDir);
+    const subPaths = AgentHostAdapter.getSubPaths(root);
+    const issues = [];
+    const warnings = [];
+    let agentsCount = 0;
+    let skillsCount = 0;
+    let workflowsCount = 0;
+    let manifest;
+    let clineCapability;
+    let isInitialized = false;
+    const lockfileExists = await fs8.pathExists(subPaths.lockfile);
+    const agentsDirExists = await fs8.pathExists(subPaths.agentsDir);
+    if (lockfileExists) {
+      try {
+        const parsed = await fs8.readJson(subPaths.lockfile);
+        manifest = parsed;
+        agentsCount = parsed.installed?.agents?.length || 0;
+        skillsCount = parsed.installed?.skills?.length || 0;
+        workflowsCount = parsed.installed?.workflows?.length || 0;
+        isInitialized = true;
+      } catch (err) {
+        issues.push(`Corrupt lockfile at ${subPaths.lockfile}: ${err.message}`);
+      }
+    } else if (agentsDirExists) {
+      warnings.push(`No lockfile found at ${subPaths.lockfile}, but agent files were detected in ${subPaths.agentsDir}. Run 'agents update' to sync.`);
+    }
+    if (await fs8.pathExists(subPaths.agentsDir)) {
+      const agentFiles = await fs8.readdir(subPaths.agentsDir);
+      for (const file of agentFiles) {
+        if (file.endsWith(".md")) {
+          const content = await fs8.readFile(path10.join(subPaths.agentsDir, file), "utf8");
+          const frontmatterMatch = content.match(/^---\r?\n([\s\S]+?)\r?\n---/);
+          if (!frontmatterMatch) {
+            warnings.push(`Agent ${file} is missing YAML frontmatter.`);
+          } else {
+            try {
+              const meta = YAML2.parse(frontmatterMatch[1]);
+              if (!meta.name) issues.push(`Agent ${file} missing 'name' in frontmatter.`);
+              if (!meta.description) warnings.push(`Agent ${file} missing 'description'.`);
+              if (!meta.model) warnings.push(`Agent ${file} missing 'model' definition.`);
+            } catch (err) {
+              issues.push(`Invalid YAML in agent ${file}: ${err.message}`);
+            }
+          }
+        }
+      }
+    }
+    if (manifest) {
+      const workspaceRoot = path10.resolve(path10.dirname(root));
+      for (const [relPath, assetMeta] of Object.entries(manifest.files)) {
+        const projectedTo = assetMeta.projectedTo;
+        if (!projectedTo || projectedTo.length === 0) continue;
+        for (const projPath of projectedTo) {
+          const absProjection = path10.join(workspaceRoot, projPath);
+          if (!await fs8.pathExists(absProjection)) {
+            warnings.push(
+              `Missing projection ${projPath} for canonical ${relPath}. Re-run: agents add ... --fanout`
+            );
+            continue;
+          }
+          const managed = await this.isManagedProjection(absProjection, projPath === "AGENTS.md");
+          if (!managed) {
+            warnings.push(`user-modified projection ${projPath}`);
+          }
+        }
+      }
+      if (manifest.projections) {
+        for (const [projRelPath, proj] of Object.entries(manifest.projections)) {
+          const absPath = path10.join(workspaceRoot, projRelPath);
+          if (!await fs8.pathExists(absPath)) {
+            warnings.push(`Missing compound projection ${projRelPath} (owners: ${proj.owners.join(", ")}).`);
+            continue;
+          }
+          if (proj.managedMarker) {
+            const managed = await this.isManagedProjection(absPath, projRelPath === "AGENTS.md");
+            if (!managed) {
+              warnings.push(`user-modified projection ${projRelPath}`);
+            }
+          }
+        }
+      }
+      const installedBundles = manifest.installed?.bundles ?? [];
+      const fileOwnersOf = (rec) => rec.owners ?? (rec.bundle ? [rec.bundle] : []);
+      if (manifest.projections) {
+        for (const [projRelPath, proj] of Object.entries(manifest.projections)) {
+          for (const owner of proj.owners) {
+            if (!installedBundles.includes(owner)) {
+              warnings.push(`Projection ${projRelPath} is owned by bundle "${owner}" which is not in installed.bundles.`);
+            }
+          }
+        }
+      }
+      for (const [relPath, rec] of Object.entries(manifest.files)) {
+        for (const owner of fileOwnersOf(rec)) {
+          if (!installedBundles.includes(owner)) {
+            warnings.push(`File record ${relPath} is owned by bundle "${owner}" which is not in installed.bundles.`);
+          }
+        }
+      }
+      for (const bundleName of installedBundles) {
+        const fileCount = Object.values(manifest.files).filter((m) => fileOwnersOf(m).includes(bundleName)).length;
+        if (fileCount === 0) {
+          warnings.push(`Installed bundle "${bundleName}" owns zero file records.`);
+        }
+      }
+    }
+    if (host === "cline") {
+      const probe = new ClineCapabilityProbe();
+      clineCapability = await probe.probe();
+      if (!clineCapability.installed) {
+        warnings.push("Cline executable was not detected on PATH or via CLINE_BIN_PATH.");
+      }
+    }
+    return {
+      valid: issues.length === 0,
+      targetDir: root,
+      isInitialized,
+      issues,
+      warnings,
+      agentsCount,
+      skillsCount,
+      workflowsCount,
+      clineCapability
+    };
+  }
+};
+
+// src/core/cline-launcher.ts
+import path11 from "path";
+import os3 from "os";
+import crypto4 from "crypto";
+import fs9 from "fs-extra";
+var ClineLauncher = class _ClineLauncher {
+  probe;
+  runner;
+  constructor(probe, runner) {
+    this.probe = probe || new ClineCapabilityProbe();
+    this.runner = runner || defaultProcessRunner;
+  }
+  /**
+   * Generate stable team name: au-<bundle>-<first-8-sha256-of-workspace>
+   */
+  static generateTeamName(bundleName, workspace) {
+    const sanitizedBundle = bundleName.replace(/[^A-Za-z0-9_-]/g, "-");
+    const hash = crypto4.createHash("sha256").update(path11.resolve(workspace)).digest("hex").slice(0, 8);
+    const prefix = `au-${sanitizedBundle}`;
+    const maxPrefixLen = 64 - 9;
+    const truncatedPrefix = prefix.slice(0, maxPrefixLen);
+    return `${truncatedPrefix}-${hash}`;
+  }
+  /**
+   * Validate custom team names against safe identifier requirements.
+   */
+  static validateTeamName(name) {
+    return /^[A-Za-z0-9_-]{1,64}$/.test(name);
+  }
+  /**
+   * Resolve an installed bundle for Cline activation.
+   */
+  async resolveInstallation(bundleName, options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const isGlobal = !!options.global;
+    let targetDir;
+    let scope;
+    let workspace;
+    if (isGlobal) {
+      targetDir = AgentHostAdapter.resolveHostDir("global", "agents");
+      scope = "global";
+      workspace = os3.homedir();
+    } else {
+      workspace = cwd;
+      targetDir = path11.join(cwd, ".agents");
+      scope = "project";
+    }
+    const lockfilePath = path11.join(targetDir, "agents-united.json");
+    if (!await fs9.pathExists(lockfilePath)) {
+      if (!isGlobal) {
+        const globalTarget = AgentHostAdapter.resolveHostDir("global", "agents");
+        const globalLockfile = path11.join(globalTarget, "agents-united.json");
+        if (await fs9.pathExists(globalLockfile)) {
+          const gLock = await fs9.readJson(globalLockfile);
+          if (gLock.installed?.bundles?.includes(bundleName)) {
+            return this.resolveInstallation(bundleName, { ...options, global: true });
+          }
+        }
+      }
+      throw new Error(`Bundle '${bundleName}' is not installed in ${scope} scope.`);
+    }
+    const lockfile = await fs9.readJson(lockfilePath);
+    if (!lockfile.installed?.bundles?.includes(bundleName)) {
+      throw new Error(`Bundle '${bundleName}' is not installed in ${scope} scope.`);
+    }
+    const hasClineFanout = (lockfile.fanout || []).includes("cline");
+    const manifestRel = `.agents/plugins/${bundleName}/agents-united/teams/${bundleName}.yaml`;
+    const manifestPath = path11.join(workspace, manifestRel);
+    if (!hasClineFanout || !await fs9.pathExists(manifestPath)) {
+      throw new Error(
+        `Bundle '${bundleName}' is not projected to Cline. Run 'agents update ${bundleName} --fanout cline' first.`
+      );
+    }
+    return {
+      scope,
+      workspace,
+      lockfile,
+      manifestPath
+    };
+  }
+  /**
+   * Plan activation strategy, argv, and bootstrap prompt without launching process.
+   */
+  planActivation(options) {
+    const {
+      bundleName,
+      workspace,
+      scope,
+      report,
+      prompt,
+      teamName: customTeamName,
+      allowAddons,
+      headless,
+      orchestrator
+    } = options;
+    const command = report.command || {
+      executable: "cline",
+      prefixArgs: [],
+      source: "path-executable"
+    };
+    let teamName = _ClineLauncher.generateTeamName(bundleName, workspace);
+    if (customTeamName) {
+      if (!_ClineLauncher.validateTeamName(customTeamName)) {
+        throw new Error(
+          `Invalid team name "${customTeamName}". Must match [A-Za-z0-9_-] and be at most 64 characters.`
+        );
+      }
+      teamName = customTeamName;
+    }
+    const strategy = report.namedTeams ? "named-team" : "adaptive-session";
+    const manifestRel = scope === "global" ? `~/.agents/plugins/${bundleName}/agents-united/teams/${bundleName}.yaml` : `.agents/plugins/${bundleName}/agents-united/teams/${bundleName}.yaml`;
+    const coordinatorFile = (orchestrator || "orchestrator-engineering.md").replace(/\.md$/, "");
+    const coordinatorCanonical = `.agents/agents/${coordinatorFile}.md`;
+    const addonPolicyText = allowAddons ? "Addon auto-installation is pre-authorized for this session." : `Before installing any recommended addon, explain the requirement to the user and request explicit confirmation to run: agents add <addon> -t cline ${scope === "global" ? "-g " : ""}-y.`;
+    const pluginInstallText = `Before proceeding, ensure you have installed this bundle's plugin by running: cline plugin install .agents/plugins/${bundleName}`;
+    const taskText = prompt && prompt.trim().length > 0 ? `User task: ${prompt.trim()}` : "Please introduce your coordinator role to the user and ask for their first task.";
+    const bootstrapPrompt = [
+      `You are coordinating the "${bundleName}" team in Agents United.`,
+      `Read the Team Manifest at "${manifestRel}" and your coordinator role definition at "${coordinatorCanonical}" before acting.`,
+      `Use specialist roles only when necessary.`,
+      addonPolicyText,
+      pluginInstallText,
+      taskText
+    ].join("\n\n");
+    const argv = [...command.prefixArgs];
+    if (strategy === "named-team") {
+      argv.push("--team-name", teamName);
+    }
+    argv.push("--cwd", workspace);
+    if (!headless) {
+      argv.push("-i");
+    }
+    argv.push(bootstrapPrompt);
+    return {
+      bundleName,
+      scope,
+      workspace,
+      teamName,
+      strategy,
+      executable: command.executable,
+      argv,
+      bootstrapPrompt
+    };
+  }
+  /**
+   * Launch Cline session using argument array.
+   */
+  async launch(plan) {
+    const { spawn } = await import("child_process");
+    const child = spawn(plan.executable, plan.argv, {
+      cwd: plan.workspace,
+      stdio: "inherit",
+      shell: false
+    });
+    await new Promise((resolve, reject) => {
+      child.on("error", reject);
+      child.on("exit", (code) => {
+        if (code === 0 || code === null) {
+          resolve();
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+};
+
+// src/core/prerequisites.ts
+import path13 from "path";
+import os5 from "os";
+import fs11 from "fs-extra";
+
+// src/core/mcp-locations.ts
+import path12 from "path";
+import os4 from "os";
+import fs10 from "fs-extra";
+var McpLocationRegistry = class _McpLocationRegistry {
+  /**
+   * Declarative catalog of known MCP configuration files across AI tools, CLIs, extensions, and workspaces.
+   */
+  static LOCATIONS = [
+    // --- Google Antigravity & Gemini ---
+    {
+      id: "antigravity-global",
+      host: "gemini",
+      category: "cli",
+      label: "Google Antigravity & Gemini Global Config",
+      resolvePath: (_, home) => path12.join(home, ".gemini", "config", "mcp_config.json"),
+      isPrimary: true
+    },
+    {
+      id: "antigravity-system",
+      host: "gemini",
+      category: "desktop",
+      label: "Google Antigravity System Config",
+      resolvePath: (_, home) => path12.join(home, ".gemini", "antigravity", "mcp_config.json")
+    },
+    {
+      id: "antigravity-workspace",
+      host: "gemini",
+      category: "workspace",
+      label: "Google Antigravity Local Workspace Config",
+      resolvePath: (cwd) => path12.join(cwd, ".gemini", "config", "mcp_config.json")
+    },
+    {
+      id: "gemini-appdata",
+      host: "gemini",
+      category: "cli",
+      label: "Google Gemini AppData Config",
+      resolvePath: (_, __, appData) => path12.join(appData, "gemini", "config", "mcp_config.json")
+    },
+    // --- Cline CLI & VS Code Extension ---
+    {
+      id: "cline-cli-settings",
+      host: "cline",
+      category: "cli",
+      label: "Cline CLI MCP Settings",
+      resolvePath: (_, home) => path12.join(home, ".cline", "data", "settings", "cline_mcp_settings.json"),
+      isPrimary: true
+    },
+    {
+      id: "cline-extension-settings",
+      host: "cline",
+      category: "extension",
+      label: "Cline VS Code Extension Global Settings",
+      resolvePath: (_, __, appData) => path12.join(appData, "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
+    },
+    {
+      id: "cline-insiders-extension-settings",
+      host: "cline",
+      category: "extension",
+      label: "Cline VS Code Insiders Extension Settings",
+      resolvePath: (_, __, appData) => path12.join(appData, "Code - Insiders", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
+    },
+    {
+      id: "cline-legacy-settings",
+      host: "cline",
+      category: "cli",
+      label: "Cline Home Legacy Settings",
+      resolvePath: (_, home) => path12.join(home, ".cline", "settings", "cline_mcp_settings.json")
+    },
+    {
+      id: "cline-home-flat",
+      host: "cline",
+      category: "cli",
+      label: "Cline Home Flat Settings",
+      resolvePath: (_, home) => path12.join(home, "cline_mcp_settings.json")
+    },
+    {
+      id: "cline-workspace-flat",
+      host: "cline",
+      category: "workspace",
+      label: "Cline Workspace Settings",
+      resolvePath: (cwd) => path12.join(cwd, "cline_mcp_settings.json")
+    },
+    {
+      id: "cline-workspace-dot",
+      host: "cline",
+      category: "workspace",
+      label: "Cline Workspace .cline/mcp.json",
+      resolvePath: (cwd) => path12.join(cwd, ".cline", "mcp.json")
+    },
+    // --- Roo Code Extension ---
+    {
+      id: "roo-code-extension-settings",
+      host: "cline",
+      category: "extension",
+      label: "Roo Code VS Code Extension Settings",
+      resolvePath: (_, __, appData) => path12.join(appData, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "cline_mcp_settings.json")
+    },
+    // --- Cursor IDE / CLI ---
+    {
+      id: "cursor-workspace",
+      host: "cursor",
+      category: "workspace",
+      label: "Cursor Workspace Config",
+      resolvePath: (cwd) => path12.join(cwd, ".cursor", "mcp.json"),
+      isPrimary: true
+    },
+    {
+      id: "cursor-global",
+      host: "cursor",
+      category: "desktop",
+      label: "Cursor Global User Config",
+      resolvePath: (_, home) => path12.join(home, ".cursor", "mcp.json")
+    },
+    // --- Claude Code CLI & Claude Desktop ---
+    {
+      id: "claude-workspace-dot",
+      host: "claude",
+      category: "workspace",
+      label: "Claude Code Workspace Config",
+      resolvePath: (cwd) => path12.join(cwd, ".claude", "mcp.json"),
+      isPrimary: true
+    },
+    {
+      id: "claude-workspace-flat",
+      host: "claude",
+      category: "workspace",
+      label: "Claude Workspace claude.json",
+      resolvePath: (cwd) => path12.join(cwd, "claude.json")
+    },
+    {
+      id: "claude-global-dot",
+      host: "claude",
+      category: "cli",
+      label: "Claude Code Global Config",
+      resolvePath: (_, home) => path12.join(home, ".claude", "mcp.json")
+    },
+    {
+      id: "claude-global-flat",
+      host: "claude",
+      category: "cli",
+      label: "Claude Code Global claude.json",
+      resolvePath: (_, home) => path12.join(home, "claude.json")
+    },
+    {
+      id: "claude-desktop-global",
+      host: "claude",
+      category: "desktop",
+      label: "Claude Desktop Global Config",
+      resolvePath: (_, __, appData) => path12.join(appData, "Claude", "claude_desktop_config.json")
+    },
+    // --- Windsurf IDE ---
+    {
+      id: "windsurf-global",
+      host: "windsurf",
+      category: "desktop",
+      label: "Windsurf Global Config",
+      resolvePath: (_, home) => path12.join(home, ".codeium", "windsurf", "mcp_config.json"),
+      isPrimary: true
+    },
+    {
+      id: "windsurf-appdata",
+      host: "windsurf",
+      category: "desktop",
+      label: "Windsurf AppData Config",
+      resolvePath: (_, __, appData) => path12.join(appData, "Windsurf", "mcp_config.json")
+    },
+    // --- OpenCode & Codex ---
+    {
+      id: "opencode-workspace",
+      host: "opencode",
+      category: "workspace",
+      label: "OpenCode Workspace Config",
+      resolvePath: (cwd) => path12.join(cwd, ".opencode", "mcp.json"),
+      isPrimary: true
+    },
+    {
+      id: "opencode-global",
+      host: "opencode",
+      category: "cli",
+      label: "OpenCode Global Config",
+      resolvePath: (_, home) => path12.join(home, ".config", "opencode", "mcp.json")
+    }
+  ];
+  /**
+   * Discovers all MCP configuration files across the filesystem, inspecting existence and parsing server definitions.
+   */
+  static async discoverAll(cwd = process.cwd()) {
+    const homeDir = os4.homedir();
+    const appData = process.env.APPDATA || (process.platform === "darwin" ? path12.join(homeDir, "Library", "Application Support") : path12.join(homeDir, ".config"));
+    const results = [];
+    const seenPaths = /* @__PURE__ */ new Set();
+    for (const desc of _McpLocationRegistry.LOCATIONS) {
+      const resolved = path12.normalize(desc.resolvePath(cwd, homeDir, appData));
+      const key = resolved.toLowerCase();
+      if (seenPaths.has(key)) continue;
+      seenPaths.add(key);
+      const exists = await fs10.pathExists(resolved);
+      let serverCount = 0;
+      let servers;
+      if (exists) {
+        try {
+          const config = await fs10.readJson(resolved);
+          const rawServers = config?.mcpServers || config?.servers || config;
+          if (rawServers && typeof rawServers === "object") {
+            servers = rawServers;
+            serverCount = Object.keys(rawServers).length;
+          }
+        } catch {
+        }
+      }
+      results.push({
+        id: desc.id,
+        host: desc.host,
+        category: desc.category,
+        label: desc.label,
+        path: resolved,
+        exists,
+        serverCount,
+        servers,
+        isPrimary: desc.isPrimary
+      });
+    }
+    return results;
+  }
+  /**
+   * Returns discovered locations filtered for specific host(s).
+   */
+  static async discoverForHosts(hosts, cwd = process.cwd()) {
+    const all = await _McpLocationRegistry.discoverAll(cwd);
+    const hostSet = new Set(hosts.map((h) => h === "agents" ? "gemini" : h));
+    return all.filter((loc) => hostSet.has(loc.host));
+  }
+  /**
+   * Resolves the primary target write path for a given host runtime.
+   */
+  static getPrimaryWritePath(host, cwd = process.cwd()) {
+    const homeDir = os4.homedir();
+    const appData = process.env.APPDATA || (process.platform === "darwin" ? path12.join(homeDir, "Library", "Application Support") : path12.join(homeDir, ".config"));
+    const targetHost = host === "agents" ? "gemini" : host;
+    const desc = _McpLocationRegistry.LOCATIONS.find((l) => l.host === targetHost && l.isPrimary);
+    if (desc) {
+      return path12.normalize(desc.resolvePath(cwd, homeDir, appData));
+    }
+    return path12.normalize(path12.join(cwd, ".cursor", "mcp.json"));
+  }
+};
+
+// src/core/prerequisites.ts
+var PrerequisiteChecker = class _PrerequisiteChecker {
+  /**
+   * Discovers all candidate and existing MCP configuration files across AI hosts
+   */
+  static async discoverHostConfigFiles(cwd = process.cwd()) {
+    const discovered = await McpLocationRegistry.discoverAll(cwd);
+    return discovered.map((d) => ({
+      host: d.host,
+      label: d.label,
+      path: d.path,
+      exists: d.exists,
+      serverCount: d.serverCount
+    }));
+  }
+  /**
+   * Helper that checks if a configured MCP server key or its configuration payload matches the target MCP name
+   */
+  static matchesMcpServer(targetMcpName, serverKey, serverConfig = {}) {
+    const targetNorm = targetMcpName.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const keyNorm = serverKey.toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (keyNorm === targetNorm) return true;
+    if (keyNorm.includes(targetNorm)) return true;
+    if (targetNorm.includes(keyNorm)) return true;
+    const strippedKey = keyNorm.replace(/^githubcom/g, "").replace(/^mcp/g, "").replace(/mcp$/g, "").replace(/^server/g, "").replace(/server$/g, "");
+    if (strippedKey === targetNorm || strippedKey.length > 2 && targetNorm.includes(strippedKey) || targetNorm.length > 2 && strippedKey.includes(targetNorm)) {
+      return true;
+    }
+    const cmd = String(serverConfig?.command || "").toLowerCase();
+    const args = Array.isArray(serverConfig?.args) ? serverConfig.args.map((a) => String(a).toLowerCase()).join(" ") : "";
+    const fullExec = `${cmd} ${args}`;
+    if (targetMcpName === "github") {
+      if (fullExec.includes("github") || fullExec.includes("ghcr.io/github")) return true;
+    }
+    if (targetMcpName === "playwright") {
+      if (fullExec.includes("playwright")) return true;
+    }
+    if (targetMcpName === "markitdown") {
+      if (fullExec.includes("markitdown")) return true;
+    }
+    if (targetMcpName === "chrome-devtools-mcp" || targetMcpName === "chrome-devtools") {
+      if (fullExec.includes("chrome-devtools")) return true;
+    }
+    if (targetMcpName === "stitch") {
+      if (fullExec.includes("stitch") || fullExec.includes("stitch.googleapis.com")) return true;
+    }
+    if (targetMcpName === "figma") {
+      if (fullExec.includes("figma")) return true;
+    }
+    if (targetMcpName === "firecrawl") {
+      if (fullExec.includes("firecrawl")) return true;
+    }
+    if (targetMcpName === "context7") {
+      if (fullExec.includes("context7")) return true;
+    }
+    if (targetMcpName === "supabase") {
+      if (fullExec.includes("supabase")) return true;
+    }
+    const url = String(serverConfig?.url || serverConfig?.serverUrl || "").toLowerCase();
+    if (url.includes(targetNorm)) return true;
+    if (targetMcpName === "stitch" && url.includes("stitch.googleapis.com")) return true;
+    if (targetMcpName === "context7" && url.includes("context7.com")) return true;
+    if (targetMcpName === "firecrawl" && url.includes("firecrawl.dev")) return true;
+    if (targetMcpName === "supabase" && url.includes("supabase.com")) return true;
+    return false;
+  }
+  /**
+   * Discovers whether an MCP server is configured across supported host runtimes
+   * (Antigravity/Gemini, Cursor, Cline, Claude Code, etc.)
+   */
+  static async isMcpConfigured(mcpName, cwd = process.cwd()) {
+    const discovered = await McpLocationRegistry.discoverAll(cwd);
+    const foundInConfigs = [];
+    const missingInConfigs = [];
+    for (const file of discovered) {
+      if (!file.exists) {
+        missingInConfigs.push({
+          id: file.id,
+          host: file.host,
+          label: file.label,
+          path: file.path
+        });
+        continue;
+      }
+      let matched = false;
+      if (file.servers && typeof file.servers === "object") {
+        for (const [key, serverDef] of Object.entries(file.servers)) {
+          if (_PrerequisiteChecker.matchesMcpServer(mcpName, key, serverDef)) {
+            const isDisabled = serverDef?.disabled === true;
+            foundInConfigs.push({
+              id: file.id,
+              host: file.host,
+              label: file.label,
+              path: file.path,
+              disabled: isDisabled,
+              serverKey: key
+            });
+            matched = true;
+            break;
+          }
+        }
+      }
+      if (!matched) {
+        missingInConfigs.push({
+          id: file.id,
+          host: file.host,
+          label: file.label,
+          path: file.path
+        });
+      }
+    }
+    const homeDir = os5.homedir();
+    const dirCandidates = [
+      path13.join(cwd, ".gemini", "antigravity", "mcp"),
+      path13.join(homeDir, ".gemini", "antigravity", "mcp")
+    ];
+    for (const dir of dirCandidates) {
+      if (await fs11.pathExists(dir)) {
+        const entries = await fs11.readdir(dir).catch(() => []);
+        for (const entry of entries) {
+          if (_PrerequisiteChecker.matchesMcpServer(mcpName, entry, {})) {
+            foundInConfigs.push({
+              id: "antigravity-dir",
+              host: "gemini",
+              label: "Google Antigravity MCP Directory",
+              path: path13.join(dir, entry),
+              disabled: false,
+              serverKey: entry
+            });
+            break;
+          }
+        }
+      }
+    }
+    const isConfigured = foundInConfigs.length > 0;
+    const firstFound = foundInConfigs[0];
+    return {
+      configured: isConfigured,
+      host: firstFound?.host,
+      location: firstFound?.path,
+      disabled: firstFound?.disabled,
+      serverKey: firstFound?.serverKey,
+      foundInConfigs,
+      missingInConfigs
+    };
+  }
+  /**
+   * Checks if an npm package is installed in node_modules or declared in package.json
+   */
+  static async isPackageInstalled(pkgName, cwd = process.cwd()) {
+    const modulePath = path13.join(cwd, "node_modules", ...pkgName.split("/"));
+    if (await fs11.pathExists(modulePath)) {
+      return { installed: true, location: modulePath };
+    }
+    const pkgJsonPath = path13.join(cwd, "package.json");
+    if (await fs11.pathExists(pkgJsonPath)) {
+      try {
+        const pkg = await fs11.readJson(pkgJsonPath);
+        const deps = {
+          ...pkg.dependencies,
+          ...pkg.devDependencies,
+          ...pkg.peerDependencies
+        };
+        if (deps[pkgName]) {
+          return { installed: true, location: pkgJsonPath };
+        }
+      } catch {
+      }
+    }
+    return { installed: false };
+  }
+  /**
+   * Checks if an environment variable is defined in process.env or local .env files
+   */
+  static async isEnvVarSet(varName, cwd = process.cwd(), customEnv) {
+    const envSource = customEnv || process.env;
+    if (envSource[varName] && envSource[varName]?.trim() !== "") {
+      return { set: true, source: "process.env" };
+    }
+    const envFiles = [
+      path13.join(cwd, ".env.local"),
+      path13.join(cwd, ".env")
+    ];
+    for (const envFile of envFiles) {
+      if (await fs11.pathExists(envFile)) {
+        try {
+          const content = await fs11.readFile(envFile, "utf8");
+          const lines = content.split("\n");
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("#") || !trimmed.includes("=")) continue;
+            const [k, ...v] = trimmed.split("=");
+            if (k.trim() === varName && v.join("=").trim() !== "") {
+              return { set: true, source: path13.basename(envFile) };
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    return { set: false };
+  }
+  /**
+   * Evaluates all prerequisites declared on a bundle, supporting target host scoping and multi-host partial breakdowns
+   */
+  async evaluate(bundle, options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const env = options.env || process.env;
+    const tier = bundle.tier || "domain";
+    const prereqs = bundle.prerequisites || {};
+    const targetHosts = options.targetHosts || ["agents"];
+    const targetHostKeys = new Set(targetHosts.map((h) => h === "agents" ? "gemini" : h));
+    const items = [];
+    if (prereqs.requiredMcps && prereqs.requiredMcps.length > 0) {
+      for (const mcp of prereqs.requiredMcps) {
+        const check = await _PrerequisiteChecker.isMcpConfigured(mcp.name, cwd);
+        const relevantFound = check.foundInConfigs.filter((c) => targetHostKeys.has(c.host));
+        const hostCleanNames = {
+          gemini: "Google Antigravity",
+          agents: "Google Antigravity",
+          cline: "Cline",
+          cursor: "Cursor",
+          claude: "Claude Code",
+          opencode: "OpenCode",
+          windsurf: "Windsurf"
+        };
+        const detectedHostLabels = Array.from(new Set(relevantFound.map((c) => hostCleanNames[c.host] || c.host)));
+        const detectedHostKeys = new Set(relevantFound.map((c) => c.host));
+        const missingHostKeys = Array.from(targetHostKeys).filter((h) => !detectedHostKeys.has(h));
+        const missingHostLabels = missingHostKeys.map((h) => hostCleanNames[h] || h);
+        let satisfied = false;
+        let status = "missing";
+        let details = "Not found in host MCP configuration";
+        if (relevantFound.length > 0 && missingHostKeys.length === 0) {
+          satisfied = true;
+          status = "ok";
+          details = `Configured in ${detectedHostLabels.join(", ")}`;
+        } else if (relevantFound.length > 0 && missingHostKeys.length > 0) {
+          satisfied = false;
+          status = "partial";
+          details = `Detected in ${detectedHostLabels.join(", ")}; Missing in ${missingHostLabels.join(", ")}`;
+        } else if (check.foundInConfigs.length > 0 && relevantFound.length === 0) {
+          const otherLabels = Array.from(new Set(check.foundInConfigs.map((c) => hostCleanNames[c.host] || c.host)));
+          satisfied = false;
+          status = "partial";
+          details = `Detected in ${otherLabels.join(", ")}; Missing in target (${Array.from(targetHostKeys).map((h) => hostCleanNames[h] || h).join(", ")})`;
+        }
+        items.push({
+          type: "mcp",
+          name: mcp.name,
+          purpose: mcp.purpose,
+          satisfied,
+          status,
+          details,
+          optionalForBrainstorming: mcp.optionalForBrainstorming ?? true,
+          detectedInHosts: detectedHostLabels,
+          missingInHosts: missingHostLabels
+        });
+      }
+    }
+    if (prereqs.requiredPackages && prereqs.requiredPackages.length > 0) {
+      for (const pkg of prereqs.requiredPackages) {
+        const check = await _PrerequisiteChecker.isPackageInstalled(pkg, cwd);
+        items.push({
+          type: "package",
+          name: pkg,
+          satisfied: check.installed,
+          status: check.installed ? "ok" : "missing",
+          details: check.installed ? "Installed in workspace" : "Not found in node_modules or package.json",
+          optionalForBrainstorming: false
+        });
+      }
+    }
+    if (prereqs.requiredEnvVars && prereqs.requiredEnvVars.length > 0) {
+      for (const envVar of prereqs.requiredEnvVars) {
+        const check = await _PrerequisiteChecker.isEnvVarSet(envVar, cwd, env);
+        items.push({
+          type: "env",
+          name: envVar,
+          satisfied: check.set,
+          status: check.set ? "ok" : "missing",
+          details: check.set ? `Defined in ${check.source}` : "Environment variable not set",
+          optionalForBrainstorming: true
+        });
+      }
+    }
+    const hasPrerequisites = items.length > 0;
+    const allSatisfied = items.length === 0 || items.every((i) => i.satisfied);
+    const operationalPossible = allSatisfied;
+    return {
+      bundleName: bundle.name,
+      tier,
+      hasPrerequisites,
+      allSatisfied,
+      operationalPossible,
+      items,
+      modes: bundle.modes
+    };
+  }
+  /**
+   * Returns canonical command and environment definitions for known MCP servers
+   */
+  static getMcpDefinition(mcpName, mode = "operational", envVars = {}) {
+    const norm = mcpName.trim().toLowerCase();
+    switch (norm) {
+      case "github":
+        return {
+          command: "npx",
+          args: ["-y", "@modelcontextprotocol/server-github"],
+          ...mode === "operational" && (envVars.GITHUB_PERSONAL_ACCESS_TOKEN || process.env.GITHUB_PERSONAL_ACCESS_TOKEN) ? { env: { GITHUB_PERSONAL_ACCESS_TOKEN: envVars.GITHUB_PERSONAL_ACCESS_TOKEN || process.env.GITHUB_PERSONAL_ACCESS_TOKEN || "" } } : {}
+        };
+      case "firecrawl":
+        return {
+          command: "npx",
+          args: ["-y", "firecrawl-mcp"],
+          ...mode === "operational" && (envVars.FIRECRAWL_API_KEY || process.env.FIRECRAWL_API_KEY) ? { env: { FIRECRAWL_API_KEY: envVars.FIRECRAWL_API_KEY || process.env.FIRECRAWL_API_KEY || "" } } : mode === "limited-operational" && envVars.FIRECRAWL_API_URL ? { env: { FIRECRAWL_API_URL: envVars.FIRECRAWL_API_URL } } : {}
+        };
+      case "context7":
+        return {
+          command: "npx",
+          args: ["-y", "@upstash/context7-mcp"],
+          ...mode === "operational" && envVars.UPSTASH_REDIS_REST_URL && envVars.UPSTASH_REDIS_REST_TOKEN ? { env: { UPSTASH_REDIS_REST_URL: envVars.UPSTASH_REDIS_REST_URL, UPSTASH_REDIS_REST_TOKEN: envVars.UPSTASH_REDIS_REST_TOKEN } } : {}
+        };
+      case "playwright":
+        return {
+          command: "npx",
+          args: ["-y", "@executeautomation/playwright-mcp-server"]
+        };
+      case "markitdown":
+        return {
+          command: "uvx",
+          args: ["markitdown-mcp"]
+        };
+      case "chrome-devtools-mcp":
+      case "chrome-devtools":
+        return {
+          command: "npx",
+          args: ["-y", "chrome-devtools-mcp"]
+        };
+      case "stitch":
+        return {
+          command: "npx",
+          args: ["-y", "mcp-remote", "https://stitch.googleapis.com/mcp"],
+          ...mode === "operational" && (envVars.STITCH_API_KEY || process.env.STITCH_API_KEY) ? { env: { STITCH_API_KEY: envVars.STITCH_API_KEY || process.env.STITCH_API_KEY || "" } } : {}
+        };
+      case "figma":
+        return {
+          command: "npx",
+          args: ["-y", "ai-figma-mcp"],
+          ...mode === "operational" && (envVars.FIGMA_ACCESS_TOKEN || process.env.FIGMA_ACCESS_TOKEN) ? { env: { FIGMA_ACCESS_TOKEN: envVars.FIGMA_ACCESS_TOKEN || process.env.FIGMA_ACCESS_TOKEN || "" } } : {}
+        };
+      default:
+        return {
+          command: "npx",
+          args: ["-y", norm]
+        };
+    }
+  }
+  /**
+   * Generates client-specific MCP configuration objects for Cursor, Cline, Claude, or Antigravity
+   */
+  static generateClientConfig(client, mcpNames, mode = "operational", envVars = {}) {
+    const servers = {};
+    for (const name of mcpNames) {
+      const def = _PrerequisiteChecker.getMcpDefinition(name, mode, envVars);
+      if (client === "cline") {
+        servers[name] = {
+          ...def,
+          disabled: false,
+          autoApprove: []
+        };
+      } else {
+        servers[name] = def;
+      }
+    }
+    return { mcpServers: servers };
+  }
+  /**
+   * Attempts to automatically provision a missing MCP server using the native CLI.
+   */
+  static async provisionMcpServer(mcpName, options = {}) {
+    try {
+      const { execSync } = await import("child_process");
+      const cmd = `npx @antigravity/cli mcp add ${mcpName} --type stdio`;
+      const output = execSync(cmd, {
+        cwd: options.cwd || process.cwd(),
+        env: options.env || process.env,
+        encoding: "utf8"
+      });
+      return { success: true, output };
+    } catch (err) {
+      return { success: false, output: err.message || String(err) };
+    }
+  }
+  /**
+   * Automatically configures missing MCP servers into a specific MCP JSON configuration file,
+   * activating disabled servers and appending missing definitions.
+   */
+  static async autoConfigureConfigFile(targetFilePath, mcpNames, mode = "operational", envVars = {}) {
+    await fs11.ensureDir(path13.dirname(targetFilePath));
+    let existingConfig = {};
+    if (await fs11.pathExists(targetFilePath)) {
+      try {
+        existingConfig = await fs11.readJson(targetFilePath);
+      } catch {
+        existingConfig = {};
+      }
+    }
+    const isServersProp = Boolean(existingConfig.servers && !existingConfig.mcpServers);
+    const existingServers = (isServersProp ? existingConfig.servers : existingConfig.mcpServers) || {};
+    const addedServers = [];
+    const enabledServers = [];
+    for (const mcp of mcpNames) {
+      let foundKey = null;
+      for (const [key, serverDef] of Object.entries(existingServers)) {
+        if (_PrerequisiteChecker.matchesMcpServer(mcp, key, serverDef)) {
+          foundKey = key;
+          if (serverDef?.disabled === true) {
+            existingServers[key].disabled = false;
+            enabledServers.push(key);
+          }
+          break;
+        }
+      }
+      if (!foundKey) {
+        const def = _PrerequisiteChecker.getMcpDefinition(mcp, mode, envVars);
+        existingServers[mcp] = def;
+        addedServers.push(mcp);
+      }
+    }
+    if (isServersProp) {
+      existingConfig.servers = existingServers;
+    } else {
+      existingConfig.mcpServers = existingServers;
+    }
+    await fs11.writeJson(targetFilePath, existingConfig, { spaces: 2 });
+    return {
+      success: true,
+      targetFile: targetFilePath,
+      addedServers,
+      enabledServers
+    };
+  }
+  /**
+   * Automatically configures missing MCP servers into a specific AI host's configuration file.
+   */
+  static async autoConfigureHost(host, mcpNames, cwd = process.cwd(), mode = "operational", envVars = {}) {
+    const targetFile = McpLocationRegistry.getPrimaryWritePath(host, cwd);
+    const res = await _PrerequisiteChecker.autoConfigureConfigFile(targetFile, mcpNames, mode, envVars);
+    return {
+      configured: res.success,
+      targetFile: res.targetFile,
+      addedServers: [...res.addedServers, ...res.enabledServers]
+    };
+  }
+  /**
+   * Automatically installs missing NPM packages into the workspace.
+   */
+  static async autoInstallPackages(packages, cwd = process.cwd()) {
+    try {
+      const { execSync } = await import("child_process");
+      const cmd = `npm install -D ${packages.join(" ")}`;
+      const output = execSync(cmd, { cwd, encoding: "utf8" });
+      return { success: true, output };
+    } catch (err) {
+      return { success: false, output: err.message || String(err) };
+    }
+  }
+};
+
+// src/cli.ts
+var cli = cac("agents-united");
+var registry = new RegistryResolver();
+var installer = new InstallEngine(registry);
+var uninstaller = new UninstallEngine(registry);
+var scanner = new InventoryScanner(registry);
+var updater = new UpdateEngine(registry, scanner, installer);
+function detectWorkspaceHosts(cwd = process.cwd()) {
+  const detected = [];
+  for (const host of Object.values(HOST_REGISTRY)) {
+    const found = host.detectionMarkers.some((marker) => fs12.pathExistsSync(path14.join(cwd, marker)));
+    if (found) detected.push(host.id);
+  }
+  return detected;
+}
+function renderProjections(projections) {
+  const byHost = /* @__PURE__ */ new Map();
+  for (const p of projections) {
+    const list = byHost.get(p.host) ?? [];
+    list.push(p);
+    byHost.set(p.host, list);
+  }
+  const lines = [];
+  for (const [host, items] of byHost) {
+    lines.push(`${HOST_REGISTRY[host]?.label ?? host} \u2014 ${items.length} file${items.length > 1 ? "s" : ""}`);
+    for (const p of items) {
+      lines.push(`  \u2192 ${p.path}`);
+      for (const w of p.warnings) lines.push(pc.yellow(`  \u26A0 ${w}`));
+    }
+  }
+  return lines.join("\n");
+}
+var BUNDLE_DISPLAY_NAMES = {
+  "software-engineering": {
+    title: "Software Engineering Team",
+    summary: "Autonomous dev lead, backend/frontend architects, TDD & git guardrails"
+  },
+  "mobile-development": {
+    title: "Mobile Development Team",
+    summary: "iOS (SwiftUI), Android (Compose) & Cross-Platform (React Native/Flutter)"
+  },
+  "frontend-engineering": {
+    title: "Frontend Architecture Team",
+    summary: "Next.js/React App Router, Server Components & Web Vitals"
+  },
+  "backend-distributed-systems": {
+    title: "Backend & Distributed Systems Team",
+    summary: "Microservices, Kafka/RabbitMQ event streams & DB migrations"
+  },
+  "qa-automation": {
+    title: "QA & Test Automation Team",
+    summary: "Playwright E2E automation, test matrix planning & chaos engineering"
+  },
+  "devops-engineering": {
+    title: "DevOps & Delivery Pipeline Team",
+    summary: "CI/CD automation, Docker/K8s, Infrastructure as Code & release engineering"
+  },
+  "ai-ml-engineering": {
+    title: "AI & Machine Learning Engineering Team",
+    summary: "Serverless GPU deployment, LLM fine-tuning, RAG vector pipelines & AI safety guardrails"
+  },
+  "sysops-sre": {
+    title: "SysOps & Site Reliability Team",
+    summary: "99.999% uptime, Prometheus telemetry, incident triage & disaster recovery"
+  },
+  "system-architecture": {
+    title: "System Architecture Team",
+    summary: "High-level distributed systems, API schemas, and ADR planning"
+  },
+  "product-design": {
+    title: "Product Design Team",
+    summary: "UI/UX designers, design systems architect, and prototyping"
+  },
+  "growth-marketing": {
+    title: "Growth & Marketing Team",
+    summary: "Growth strategists, creative visual designer, content pipeline & conversion optimization"
+  },
+  "seo-content-marketing": {
+    title: "SEO & Content Marketing Team",
+    summary: "Programmatic SEO, technical SEO audits, content pipeline automation & schema markup"
+  },
+  "performance-paid-acquisition": {
+    title: "Performance & Paid Acquisition Team",
+    summary: "Multi-channel PPC (Google/Meta/LinkedIn), ROAS/CAC attribution & ad copy testing"
+  },
+  "product-led-growth": {
+    title: "Product-Led Growth Team",
+    summary: "Onboarding CRO, signup funnel optimization, viral referral loops & paywalls"
+  },
+  "lifecycle-email-marketing": {
+    title: "Lifecycle & Email Marketing Team",
+    summary: "Automated email drip sequences, churn prevention playbooks & newsletter workflows"
+  },
+  "security-operations": {
+    title: "Security Operations Team",
+    summary: "AppSec engineer, threat modeling, and vulnerability audits"
+  },
+  "deep-research": {
+    title: "Deep Research Team",
+    summary: "Technical research lead, literature review, and Socratic mentor"
+  },
+  "business-strategy": {
+    title: "Business Strategy Team",
+    summary: "Market analysts, monetization experts, and executive spec panels"
+  },
+  "digital-agency": {
+    title: "Digital Agency (TBA soon)",
+    summary: "Full-service digital product agency with web dev, mobile, design, SEO, and growth marketing"
+  },
+  "universal-orchestration": {
+    title: "Universal Orchestration",
+    summary: "Prime Orchestrator front door: routes to the correct department Essentials bundle and hands off"
+  },
+  "universal-skills": {
+    title: "Universal Meta-Skills",
+    summary: "Domain-agnostic Socratic grilling, spec generation, handoff, and domain modeling"
+  },
+  "design-systems-ops": {
+    title: "Design Systems & Ops Team",
+    summary: "Token governance, component libraries, design handoff & version control workflows"
+  },
+  "design-research-testing": {
+    title: "Design Research & Testing Team",
+    summary: "Usability testing, user journey mapping, interactive prototypes & AI prototype refactoring"
+  },
+  "full": {
+    title: "All-in-One Autonomous Department",
+    summary: "Complete suite with all 7 team leads, 38 agents, and all skills & workflows"
+  }
+};
+cli.command("add [identifier]", "Add a bundle, agent, skill, or workflow to project or global configuration").option("-g, --global", "Install globally into home directory (~/.agents/)").option("-s, --symlink", "Create symbolic links to central registry cache (default / recommended)").option("--copy", "Create independent standalone copies of asset files").option("-t, --target <hosts>", "Which assistants to set up (agents = main library; claude, cursor, cline, opencode, codex get translated copies)", { default: "agents" }).option("--fanout <hosts>", "Also make translated copies for these assistants: claude, cursor, cline, opencode, codex").option("--mode <mode>", "Execution mode for organization bundles (operational | brainstorming)", { default: "operational" }).option("--allow-missing-prereqs", "Proceed with installation even if some prerequisites are missing").option("--allow-under-construction", "Allow installation of bundles marked as under construction").option("-y, --yes", "Skip confirmation prompts").option("-f, --force", "Force overwrite user modified files").option("--start", "Start the installed team in Cline immediately after setup").option("--dry-run", "Simulate installation without writing files").action(async (targetIdentifier, options = {}) => {
+  intro(pc.cyan("Agents United \u2014 AI Agent Ecosystem"));
+  let identifier = targetIdentifier;
+  let scope = options.global ? "global" : "project";
+  let method = options.copy ? "copy" : "symlink";
+  let hosts = options.target ? (Array.isArray(options.target) ? options.target : options.target.split(",")).map(
+    (h) => h.trim().toLowerCase()
+  ) : ["agents"];
+  const unknownHosts = hosts.filter((h) => !isKnownHost(h));
+  if (unknownHosts.length > 0) {
+    note(`Ignoring unknown host id(s): ${unknownHosts.join(", ")}`, "Invalid target");
+    hosts = hosts.filter(isKnownHost);
+    if (hosts.length === 0) hosts = ["agents"];
+  }
+  const flagPlan = planInstallTargets(hosts);
+  hosts = flagPlan.hosts;
+  if (flagPlan.addedCanonicalStore) {
+    note(
+      "Added .agents/ \u2014 the main library your assistants share.\nEach assistant you picked gets its own translated copy. Edit only .agents/.",
+      "Main library"
+    );
+  }
+  let fanout = flagPlan.fanout;
+  if (options.fanout) {
+    const rawFanout = Array.isArray(options.fanout) ? options.fanout : String(options.fanout).split(",");
+    const parsedFanout = rawFanout.map((h) => h.trim().toLowerCase());
+    const invalidFanout = parsedFanout.filter((h) => !isKnownHost(h) || !HOST_REGISTRY[h].projectionCapable);
+    if (invalidFanout.length > 0) {
+      note(
+        `Ignoring invalid fanout host id(s): ${invalidFanout.join(", ")}. Valid ids: ${KNOWN_HOST_IDS.filter((h) => HOST_REGISTRY[h].projectionCapable).join(", ")}`,
+        "Invalid fanout"
+      );
+    }
+    fanout = Array.from(/* @__PURE__ */ new Set([...fanout, ...parsedFanout.filter((h) => isKnownHost(h) && HOST_REGISTRY[h].projectionCapable)]));
+  }
+  const isInteractive = process.stdout.isTTY && !options.yes;
+  if (isInteractive && !options.global && !options.copy && !options.symlink && options.target === "agents") {
+    const detectedHosts = detectWorkspaceHosts();
+    if (detectedHosts.length > 0) {
+      note(
+        detectedHosts.map((h) => `  \u2714 Detected .${HOST_REGISTRY[h].projectDir === "." ? "" : "/"}${HOST_REGISTRY[h].projectDir === "." ? "AGENTS.md" : HOST_REGISTRY[h].projectDir}`).join("\n"),
+        "Workspace Environment Discovery"
+      );
+    }
+    const hostSelection = await multiselect({
+      message: "1. Which AI tools should we configure agent teams & personas for?",
+      options: [
+        {
+          value: "agents",
+          label: HOST_REGISTRY.agents.label,
+          hint: detectedHosts.includes("agents") ? "found in this project" : "the master library where all skills & agents live \u2014 always included"
+        },
+        {
+          value: "claude",
+          label: HOST_REGISTRY.claude.label,
+          hint: detectedHosts.includes("claude") ? "found in this project" : "orchestrator & subagent personas for Claude Code"
+        },
+        {
+          value: "cursor",
+          label: HOST_REGISTRY.cursor.label,
+          hint: detectedHosts.includes("cursor") ? "found in this project" : "orchestrator & subagent personas for Cursor IDE"
+        },
+        {
+          value: "cline",
+          label: HOST_REGISTRY.cline.label,
+          hint: detectedHosts.includes("cline") ? "found in this project" : "roles, skills, coordinator rules & team manifests for Cline"
+        },
+        {
+          value: "opencode",
+          label: HOST_REGISTRY.opencode.label,
+          hint: detectedHosts.includes("opencode") ? "found in this project" : "orchestrator & subagent personas for OpenCode"
+        },
+        {
+          value: "codex",
+          label: HOST_REGISTRY.codex.label,
+          hint: detectedHosts.includes("codex") ? "found in this project" : "root index linking orchestrators, subagents & skills for Codex, Copilot, Aider & Zed"
+        },
+        {
+          value: "gemini",
+          label: HOST_REGISTRY.gemini.label,
+          hint: detectedHosts.includes("gemini") ? "found in this project" : "older Antigravity 1.0 / Gemini folder"
+        }
+      ],
+      initialValues: detectedHosts.length > 0 ? detectedHosts : ["agents"],
+      required: true
+    });
+    if (Array.isArray(hostSelection) && hostSelection.length > 0) {
+      const wizardPlan = planInstallTargets(hostSelection);
+      hosts = wizardPlan.hosts;
+      fanout = Array.from(/* @__PURE__ */ new Set([...fanout, ...wizardPlan.fanout]));
+      if (wizardPlan.addedCanonicalStore) {
+        note(
+          "Added .agents/ \u2014 the master repository library your tools share.\nEach tool you selected gets its own orchestrators and subagents. Edit only .agents/.",
+          "Master library"
+        );
+      }
+    }
+    const scopeSelection = await select({
+      message: "2. Select Installation Scope:",
+      options: [
+        {
+          value: "project",
+          label: "Project Scope (Recommended)",
+          hint: "Workspace directory; tracked in Git & shared with team via lockfile"
+        },
+        {
+          value: "global",
+          label: "Global Scope (-g / --global)",
+          hint: "User home directory (~/.agents/); available across all workspaces on machine"
+        }
+      ]
+    });
+    if (typeof scopeSelection === "string") {
+      scope = scopeSelection;
+    }
+    const methodSelection = await select({
+      message: "3. Select Installation Method:",
+      options: [
+        {
+          value: "symlink",
+          label: "Symlink Mode (Recommended)",
+          hint: "Single source of truth; package updates reflect instantly"
+        },
+        {
+          value: "copy",
+          label: "Copy Mode",
+          hint: "Independent standalone files; supports offline isolated modifications"
+        }
+      ]
+    });
+    if (typeof methodSelection === "string") {
+      method = methodSelection;
+    }
+  }
+  if (!identifier) {
+    const bundles = await registry.listBundles();
+    const domainMeta = {
+      universal: { label: "Universal Autonomous Department", icon: "\u{1F310} " },
+      engineering: { label: "Software Engineering & Delivery", icon: "\u{1F6E0}\uFE0F " },
+      architecture: { label: "System Architecture & SRE", icon: "\u{1F3DB}\uFE0F " },
+      design: { label: "Product Design & UI/UX", icon: "\u{1F3A8} " },
+      marketing: { label: "Growth & Marketing Operations", icon: "\u{1F4C8} " },
+      security: { label: "Security Operations", icon: "\u{1F512} " },
+      research: { label: "Deep Technical Research", icon: "\u{1F52C} " },
+      business: { label: "Business Strategy & Economics", icon: "\u{1F4BC} " },
+      organization: { label: "Organization Bundles (Experimental / Cross-Functional)", icon: "\u{1F3E2} " }
+    };
+    let selectedBundle;
+    while (!selectedBundle) {
+      const domainOptions = Object.entries(domainMeta).map(([domainKey, meta]) => {
+        const count = bundles.filter((b) => b.domain === domainKey || domainKey === "organization" && b.tier === "organization").length;
+        return {
+          value: domainKey,
+          label: `${meta.icon} ${meta.label}`,
+          hint: domainKey === "universal" ? "meta-skills baseline + full suite" : domainKey === "organization" ? "cross-functional teams with prerequisites" : `${count} specialized team${count > 1 ? "s" : ""}`
+        };
+      });
+      domainOptions.push({
+        value: "__search__",
+        label: "\u{1F50D} Search by name / keyword...",
+        hint: "custom keyword search"
+      });
+      const selectedDomain = await select({
+        message: "4. Select Department Domain / Category:",
+        options: domainOptions
+      });
+      if (typeof selectedDomain !== "string") {
+        outro(pc.yellow("Installation cancelled."));
+        return;
+      }
+      if (selectedDomain === "__search__") {
+        const searchQuery = await text({
+          message: "Enter keyword to search:",
+          placeholder: "e.g. mobile, playwright, react, backend, agency"
+        });
+        if (typeof searchQuery !== "string" || !searchQuery.trim()) {
+          continue;
+        }
+        const searchResults = await registry.find(searchQuery.trim());
+        const matchOptions = [
+          ...searchResults.bundles.map((b) => ({
+            value: b.name,
+            label: `[Bundle] ${BUNDLE_DISPLAY_NAMES[b.name]?.title || b.name} (${b.name})`,
+            hint: b.description
+          })),
+          ...searchResults.agents.map((a) => ({
+            value: a.replace(/\.md$/, ""),
+            label: `[Agent] ${a}`,
+            hint: "autonomous agent"
+          })),
+          ...searchResults.skills.map((s2) => ({
+            value: s2,
+            label: `[Skill] ${s2}`,
+            hint: "specialized skill"
+          })),
+          ...searchResults.workflows.map((w) => ({
+            value: w.replace(/\.md$/, ""),
+            label: `[Workflow] ${w}`,
+            hint: "guided workflow"
+          })),
+          {
+            value: "__back__",
+            label: "\u{1F519} Back to Department Selection",
+            hint: ""
+          }
+        ];
+        if (matchOptions.length === 1) {
+          note(`No items found matching "${searchQuery}".`, "Search Results");
+          continue;
+        }
+        const chosenMatch = await select({
+          message: `Search Results for "${searchQuery}":`,
+          options: matchOptions
+        });
+        if (typeof chosenMatch === "string" && chosenMatch !== "__back__") {
+          selectedBundle = chosenMatch;
+          break;
+        }
+        continue;
+      }
+      const domainBundles = bundles.filter((b) => b.domain === selectedDomain || selectedDomain === "organization" && b.tier === "organization");
+      const subTeamOptions = [];
+      if (domainBundles.length > 1 && selectedDomain !== "organization" && selectedDomain !== "universal") {
+        subTeamOptions.push({
+          value: `__all_domain__:${selectedDomain}`,
+          label: `\u{1F31F} Install Entire ${domainMeta[selectedDomain]?.label || selectedDomain} (${domainBundles.length} Bundles)`,
+          hint: "installs all sub-teams under this department"
+        });
+      }
+      const sortedBundles = [...domainBundles].sort((a, b) => {
+        if (a.name === "universal-orchestration") return -1;
+        if (b.name === "universal-orchestration") return 1;
+        if (a.name === "universal-skills") return -1;
+        if (b.name === "universal-skills") return 1;
+        if (!a.parentBundle && b.parentBundle) return -1;
+        if (a.parentBundle && !b.parentBundle) return 1;
+        return a.name.localeCompare(b.name);
+      });
+      sortedBundles.forEach((b, idx) => {
+        const isLast = idx === sortedBundles.length - 1;
+        const branch = sortedBundles.length > 1 ? isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 " : "";
+        const meta = BUNDLE_DISPLAY_NAMES[b.name];
+        const isEssentials = !b.parentBundle && b.name !== "full" && b.tier !== "organization" && b.name !== "universal-skills" && b.name !== "universal-orchestration";
+        const title = meta ? meta.title : b.name;
+        let statusBadge = "";
+        if (b.name === "universal-skills") statusBadge = pc.green(" \u2B50 [Recommended Baseline]");
+        else if (b.status === "under-construction") statusBadge = pc.yellow(" \u{1F6A7} [Under Construction]");
+        else if (b.status === "needs-audit") statusBadge = pc.magenta(" \u26A0\uFE0F [Needs Audit]");
+        else if (b.status === "experimental") statusBadge = pc.cyan(" [Experimental]");
+        else if (b.status === "deprecated") statusBadge = pc.red(" [Deprecated]");
+        const labelText = isEssentials ? `Essentials: ${title}${statusBadge}` : `${title}${statusBadge}`;
+        const summary = meta ? meta.summary : b.description;
+        subTeamOptions.push({
+          value: b.name,
+          label: `${branch}\u{1F4E6} ${labelText} (${b.name})`,
+          hint: summary
+        });
+      });
+      subTeamOptions.push({
+        value: "__back__",
+        label: "\u{1F519} Back to Department Selection",
+        hint: ""
+      });
+      const chosenSubTeam = await select({
+        message: `Select Package / Team Bundle to install in ${domainMeta[selectedDomain]?.label || selectedDomain}:`,
+        options: subTeamOptions
+      });
+      if (typeof chosenSubTeam !== "string") {
+        outro(pc.yellow("Installation cancelled."));
+        return;
+      }
+      if (chosenSubTeam === "__back__") {
+        continue;
+      }
+      if (chosenSubTeam.startsWith("__all_domain__:")) {
+        const dName = chosenSubTeam.replace("__all_domain__:", "");
+        const dTitle = domainMeta[dName]?.label || dName;
+        const proceed = await confirm({
+          message: `\u26A0\uFE0F  You are about to install ALL ${domainBundles.length} sub-teams under "${dTitle}". Proceed?`,
+          initialValue: true
+        });
+        if (!proceed || typeof proceed !== "boolean") {
+          continue;
+        }
+        selectedBundle = `domain:${dName}`;
+        break;
+      }
+      selectedBundle = chosenSubTeam;
+      break;
+    }
+    identifier = selectedBundle;
+  }
+  if (!identifier) {
+    outro(pc.yellow("No package specified."));
+    return;
+  }
+  const targetBundleDef = await registry.getBundle(identifier);
+  if (targetBundleDef && targetBundleDef.status === "under-construction") {
+    if (isInteractive) {
+      note(
+        `The bundle "${targetBundleDef.name}" is currently under active construction (status: under-construction).
+Its orchestrators, workflows, and specialized skills are being authored and are not ready for production use.
+
+Planned Capabilities:
+\u2022 Lead Orchestrator with Firecrawl & GitHub MCP tool calling
+\u2022 Full-stack web, design & SEO delivery workflows
+\u2022 Dual Execution Modes (Operational / Brainstorming)`,
+        "\u{1F6A7} Under Construction Gate"
+      );
+      const underConstructionChoice = await select({
+        message: pc.yellow(`"${targetBundleDef.name}" is currently under construction. How would you like to proceed?`),
+        options: [
+          {
+            value: "abort",
+            label: "\u{1F6D1} Abort installation (Recommended)",
+            hint: "return without modifying workspace files"
+          },
+          {
+            value: "allow",
+            label: "\u26A0\uFE0F  Install in-development draft anyway (--allow-under-construction)",
+            hint: "proceed with in-progress placeholder assets"
+          }
+        ]
+      });
+      if (underConstructionChoice === "abort" || typeof underConstructionChoice !== "string") {
+        outro(pc.yellow(`Installation cancelled. "${targetBundleDef.name}" is under construction.`));
+        return;
+      }
+    } else {
+      if (!options.allowUnderConstruction && !options.force) {
+        outro(
+          pc.red(
+            `Error: Cannot install "${targetBundleDef.name}" \u2014 this bundle is currently under construction.
+To bypass this gate and install draft assets anyway, pass: --allow-under-construction or --force`
+          )
+        );
+        process.exit(1);
+      }
+    }
+  }
+  let executionMode = options.mode || "operational";
+  if (targetBundleDef && (targetBundleDef.prerequisites || targetBundleDef.tier === "organization")) {
+    const checker = new PrerequisiteChecker();
+    const prereqEval = await checker.evaluate(targetBundleDef, { cwd: process.cwd(), targetHosts: hosts });
+    if (prereqEval.hasPrerequisites) {
+      const checkLines = [];
+      for (const item of prereqEval.items) {
+        const typeLabel = item.type === "mcp" ? "MCP" : item.type === "env" ? "Env" : "Pkg";
+        let icon = pc.green("\u2713");
+        let statusText = pc.green("Detected");
+        if (!item.satisfied) {
+          if (item.status === "partial") {
+            icon = pc.yellow("~");
+            statusText = pc.yellow("Partial");
+          } else {
+            icon = pc.red("\u2717");
+            statusText = pc.red("Missing");
+          }
+        }
+        const details = pc.dim(`(${item.details || ""})`);
+        checkLines.push(`  ${icon} [${typeLabel}] ${pc.bold(item.name)}: ${statusText} ${details}`);
+      }
+      note(
+        checkLines.join("\n"),
+        `Prerequisite Evaluation: ${targetBundleDef.name} (${targetBundleDef.tier === "organization" ? "Organization Bundle" : "Prerequisites Required"})`
+      );
+      if (prereqEval.allSatisfied) {
+        executionMode = options.mode || "operational";
+        note(pc.green("All prerequisites are satisfied! Running in Fully Operational Mode."), "Prerequisites Ready");
+      } else {
+        executionMode = options.mode || "limited-operational";
+        note(
+          pc.cyan(
+            "\u26A1 Adaptive Tooling: Limited Operational / Brainstorming Mode ready.\nYour Lead Orchestrator will automatically detect active tools and guide in-session configuration seamlessly."
+          ),
+          "Operational Envelope"
+        );
+      }
+    }
+  }
+  const s = spinner();
+  s.start(`Resolving "${identifier}"...`);
+  try {
+    const result = await installer.install(identifier, {
+      scope,
+      method,
+      hosts,
+      fanout,
+      mode: executionMode,
+      allowMissingPrereqs: options.allowMissingPrereqs,
+      yes: options.yes,
+      force: options.force,
+      dryRun: options.dryRun
+    });
+    s.stop(`Resolved assets for "${identifier}"`);
+    if (options.dryRun) {
+      outro(pc.yellow(`[DRY RUN] Would install ${result.installed.agents.length} agents, ${result.installed.skills.length} skills to ${result.targetDirs.join(", ")}`));
+      if (result.projections.length > 0) {
+        note(renderProjections(result.projections), "Projection Plan (dry run)");
+      }
+      if (options.start && result.projections.some((p) => p.host === "cline")) {
+        const bundleName = result.installed.targetBundle || identifier;
+        note(`Would start Cline team for bundle "${bundleName}".`, "Start in Cline (dry run)");
+      }
+      return;
+    }
+    note(
+      `Bundle: ${result.installed.targetBundle || "Single Item"}
+Scope: ${scope}
+Method: ${result.method}
+Targets: ${hosts.join(", ")}
+Agents: ${result.installed.agents.join(", ") || "None"}
+Skills: ${result.installed.skills.join(", ") || "None"}
+Target Directories: ${result.targetDirs.join("\n  ")}` + (result.projections.length > 0 ? `
+
+Projections:
+${renderProjections(result.projections)}` : ""),
+      "Installation Success"
+    );
+    const hasClineProjection = result.projections.some((p) => p.host === "cline");
+    if (options.start && !hasClineProjection) {
+      throw new Error("--start requires Cline projection. Add -t cline or --fanout cline.");
+    }
+    if (hasClineProjection) {
+      const bundleName = result.installed.targetBundle || identifier;
+      if (options.start) {
+        if (options.dryRun) {
+          note(`Would start Cline team for bundle "${bundleName}".`, "Start in Cline (dry run)");
+        } else {
+          note(`Launching Cline team for "${bundleName}"...`, "Starting Cline");
+          const launcher = new ClineLauncher();
+          const probe = new ClineCapabilityProbe();
+          const probeReport = await probe.probe();
+          if (probeReport.installed) {
+            const targetBundleDef2 = await registry.getBundle(bundleName);
+            const plan = launcher.planActivation({
+              bundleName,
+              workspace: process.cwd(),
+              scope,
+              report: probeReport,
+              orchestrator: targetBundleDef2?.orchestrator
+            });
+            await launcher.launch(plan);
+          } else {
+            note(pc.yellow("Cline executable not detected. Install Cline CLI to run: agents start " + bundleName), "Cline Not Found");
+          }
+        }
+      } else if (isInteractive && !options.dryRun) {
+        const startChoice = await select({
+          message: `Start the ${bundleName} team in Cline now?`,
+          options: [
+            { value: "start", label: "\u{1F680} Start in Cline" },
+            { value: "copy", label: `\u{1F4CB} Copy command (agents start ${bundleName})` },
+            { value: "later", label: "\u23F3 Later" }
+          ]
+        });
+        if (startChoice === "start") {
+          const launcher = new ClineLauncher();
+          const probe = new ClineCapabilityProbe();
+          const probeReport = await probe.probe();
+          if (probeReport.installed) {
+            const targetBundleDef2 = await registry.getBundle(bundleName);
+            const plan = launcher.planActivation({
+              bundleName,
+              workspace: process.cwd(),
+              scope,
+              report: probeReport,
+              orchestrator: targetBundleDef2?.orchestrator
+            });
+            await launcher.launch(plan);
+          } else {
+            note(pc.yellow("Cline executable not detected. Install Cline CLI to run: agents start " + bundleName), "Cline Not Found");
+          }
+        } else if (startChoice === "copy") {
+          note(`Run 'agents start ${bundleName}' to launch the team in Cline anytime.`, "Start Command");
+        }
+      } else if (!options.dryRun) {
+        note(pc.cyan(`Tip: Run 'agents start ${bundleName}' to launch the team in Cline.`), "Start in Cline");
+      }
+    }
+    if (!options.dryRun && hosts.includes("agents") && result.projections.length === 0) {
+      note(
+        pc.yellow(
+          `Tip: only Antigravity reads the main library (.agents/) directly.
+To use this bundle in Cline, Claude Code & others: agents update ${identifier} --fanout cline,claude`
+        ),
+        "One library, every assistant"
+      );
+    }
+    if (!options.dryRun && targetBundleDef?.tier === "organization") {
+      note(
+        pc.cyan(
+          "\u{1F4A1} In-Session MCP Setup: Your Lead Orchestrator will automatically check your runtime tools\nand guide configuration of live browser automation, design tokens, or cloud APIs on demand."
+        ),
+        "Adaptive Tooling"
+      );
+    }
+    outro(pc.green(`\u2714 Installed "${identifier}" successfully!`));
+  } catch (err) {
+    s.stop(pc.red("Failed resolution"));
+    outro(pc.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+cli.command("remove [identifier]", "Remove an installed bundle, agent, skill, or workflow").alias("uninstall").option("-g, --global", "Uninstall from global home directory").option("-t, --target <hosts>", "Target agent host runtimes", { default: "agents" }).option("-y, --yes", "Skip confirmation prompts").option("-f, --force", "Force removal of modified files").option("--dry-run", "Simulate removal without unlinking files").action(async (targetIdentifier, options = {}) => {
+  intro(pc.cyan("Agents United \u2014 Remove Package"));
+  let identifier = targetIdentifier;
+  let selectedRecord;
+  const isInteractive = process.stdout.isTTY && !options.yes;
+  if (!identifier) {
+    const inventory = await scanner.scan({
+      global: options.global,
+      target: options.target
+    });
+    if (inventory.records.length === 0) {
+      outro(pc.yellow("No installed packages found in project or global configuration."));
+      return;
+    }
+    if (!isInteractive) {
+      outro(pc.red("Package identifier required in non-interactive mode. Usage: agents remove <identifier>"));
+      return;
+    }
+    const itemOptions = inventory.records.map((record) => {
+      const meta = BUNDLE_DISPLAY_NAMES[record.name];
+      const title = meta?.title || record.title || record.name;
+      const icon = record.type === "bundle" ? "\u{1F4E6}" : record.type === "skill" ? "\u26A1" : "\u{1F916}";
+      const typeLabel = record.type !== "bundle" ? `[${record.type}] ` : "";
+      const badge = pc.cyan(record.displayLocation);
+      const versionTag = pc.dim(`(v${record.installedVersion})`);
+      return {
+        value: record.id,
+        label: `${icon} ${typeLabel}${title} ${badge} ${versionTag}`,
+        hint: `${record.fileCount} file${record.fileCount > 1 ? "s" : ""} \u2014 ${record.description || record.name}`
+      };
+    });
+    const selectedId = await select({
+      message: "Select an installed package to remove:",
+      options: itemOptions
+    });
+    if (typeof selectedId !== "string") {
+      outro(pc.yellow("Removal cancelled."));
+      return;
+    }
+    selectedRecord = inventory.records.find((r) => r.id === selectedId);
+    if (selectedRecord) {
+      identifier = selectedRecord.name;
+    } else {
+      identifier = selectedId;
+    }
+  }
+  const s = spinner();
+  s.start(`Removing "${identifier}"...`);
+  try {
+    const result = await uninstaller.uninstall(identifier, {
+      scope: selectedRecord?.scope || (options.global ? "global" : "project"),
+      global: options.global,
+      target: selectedRecord ? [selectedRecord.host] : options.target,
+      targetDir: selectedRecord?.targetDir,
+      yes: options.yes,
+      force: options.force,
+      dryRun: options.dryRun
+    });
+    s.stop(`Uninstall processed`);
+    if (options.dryRun) {
+      outro(pc.yellow(`[DRY RUN] Would remove ${result.removed.length} assets from ${result.targetDirs.join(", ")}`));
+      return;
+    }
+    outro(pc.green(`\u2714 Successfully removed ${result.removed.length} files matching "${identifier}"`));
+  } catch (err) {
+    s.stop(pc.red("Uninstall failed"));
+    outro(pc.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+cli.command("update [identifier]", "Update installed packages to upstream registry versions").alias("upgrade").option("-g, --global", "Update global packages in home directory").option("-t, --target <hosts>", "Target agent host runtimes").option("--fanout <hosts>", "Also project the canonical .agents/ store into these runtimes during update (claude, cursor, cline, opencode, codex)").option("-a, --all", "Update all installed packages without prompting").option("-y, --yes", "Skip confirmation prompts").option("-f, --force", "Force overwrite user modified files").option("--start", "Start the updated team in Cline immediately after update").option("--dry-run", "Simulate update without writing files").action(async (targetIdentifier, options = {}) => {
+  intro(pc.cyan("Agents United \u2014 Package Update Engine"));
+  let updateFanout;
+  if (options.fanout !== void 0) {
+    const rawFanout = Array.isArray(options.fanout) ? options.fanout : String(options.fanout).split(",");
+    const parsedFanout = rawFanout.map((h) => h.trim().toLowerCase()).filter(Boolean);
+    const invalidFanout = parsedFanout.filter((h) => !isKnownHost(h) || !HOST_REGISTRY[h].projectionCapable);
+    if (invalidFanout.length > 0) {
+      note(
+        pc.yellow(
+          `Ignoring invalid fanout host id(s): ${invalidFanout.join(", ")}. Valid ids: ${KNOWN_HOST_IDS.filter((h) => HOST_REGISTRY[h].projectionCapable).join(", ")}`
+        ),
+        "Invalid fanout"
+      );
+    }
+    updateFanout = parsedFanout.filter((h) => isKnownHost(h) && HOST_REGISTRY[h].projectionCapable);
+  }
+  const s = spinner();
+  s.start("Checking installed package inventory & upstream drift...");
+  const report = await updater.checkUpdates({
+    global: options.global,
+    target: options.target
+  });
+  s.stop("Inventory discovery complete");
+  if (report.totalCount === 0) {
+    outro(pc.yellow("No installed packages found in project or global configuration."));
+    return;
+  }
+  const isInteractive = process.stdout.isTTY && !options.yes && !options.all;
+  let targetsToUpdate = [];
+  if (targetIdentifier) {
+    targetsToUpdate = [targetIdentifier];
+  } else if (options.all || options.yes || !isInteractive) {
+    targetsToUpdate = "__all__";
+  } else {
+    const statusMessage = `Total Installed Packages: ${report.totalCount}
+Updates Available: ${report.outdatedCount > 0 ? pc.yellow(pc.bold(`${report.outdatedCount} package${report.outdatedCount > 1 ? "s" : ""} can be updated`)) : pc.green("0 (All up to date)")}`;
+    note(statusMessage, "Inventory Status");
+    const menuOptions = [];
+    if (report.outdatedCount > 0) {
+      menuOptions.push({
+        value: "__all_outdated__",
+        label: `\u26A1 Update All Outdated Packages (${report.outdatedCount} available)`,
+        hint: "batch upgrade all packages with newer upstream versions"
+      });
+    }
+    menuOptions.push({
+      value: "__selective__",
+      label: "\u{1F4E6} Selectively Pick Packages to Update",
+      hint: "choose specific bundles or items from an interactive list"
+    });
+    menuOptions.push({
+      value: "__resync_all__",
+      label: `\u{1F504} Re-sync / Repair All Packages (${report.totalCount})`,
+      hint: "re-link or re-copy all packages to guarantee full integrity"
+    });
+    const action = await select({
+      message: "Select update action:",
+      options: menuOptions
+    });
+    if (typeof action !== "string") {
+      outro(pc.yellow("Update cancelled."));
+      return;
+    }
+    if (action === "__all_outdated__") {
+      targetsToUpdate = report.items.filter((i) => i.hasUpdate).map((i) => i.record.name);
+    } else if (action === "__resync_all__") {
+      targetsToUpdate = "__all__";
+    } else if (action === "__selective__") {
+      const itemOptions = report.items.map((item) => {
+        const meta = BUNDLE_DISPLAY_NAMES[item.record.name];
+        const title = meta?.title || item.record.title || item.record.name;
+        const badge = pc.cyan(item.record.displayLocation);
+        const versionDiff = item.hasUpdate ? pc.yellow(`(v${item.installedVersion} \u2192 v${item.upstreamVersion}) [UPDATE]`) : pc.dim(`(v${item.installedVersion}) [UP TO DATE]`);
+        return {
+          value: item.record.name,
+          label: `\u{1F4E6} ${title} ${badge} ${versionDiff}`,
+          hint: item.record.description || item.record.name
+        };
+      });
+      const initialValues = report.items.filter((i) => i.hasUpdate).map((i) => i.record.name);
+      const selection = await multiselect({
+        message: "Select packages to update:",
+        options: itemOptions,
+        initialValues: initialValues.length > 0 ? initialValues : void 0,
+        required: true
+      });
+      if (!Array.isArray(selection) || selection.length === 0) {
+        outro(pc.yellow("No packages selected for update."));
+        return;
+      }
+      targetsToUpdate = selection;
+    }
+  }
+  const updateSpinner = spinner();
+  updateSpinner.start("Updating packages...");
+  try {
+    const result = await updater.update(targetsToUpdate, {
+      global: options.global,
+      target: options.target,
+      force: options.force,
+      dryRun: options.dryRun,
+      fanout: updateFanout
+    });
+    updateSpinner.stop("Update completed");
+    if (options.dryRun) {
+      outro(pc.yellow(`[DRY RUN] Would update ${result.updated.length} packages in ${result.targetDirs.join(", ")}`));
+      return;
+    }
+    if (result.updated.length > 0) {
+      const unprojected = [];
+      for (const rec of result.updated) {
+        try {
+          const lf = await fs12.readJson(path14.join(rec.targetDir, "agents-united.json"));
+          if (!lf.fanout || lf.fanout.length === 0) unprojected.push(rec.name);
+        } catch {
+        }
+      }
+      if (unprojected.length > 0) {
+        note(
+          pc.yellow(
+            `Tip: not synced to other assistants yet (only Antigravity reads .agents/).
+To add Cline & friends: agents update ${unprojected[0]} --fanout cline,claude`
+          ),
+          "One library, every assistant"
+        );
+      }
+      const updatedList = result.updated.map((u) => `  \u2714 ${pc.bold(u.name)} ${pc.cyan(u.displayLocation)} ${pc.green(`(v${u.installedVersion})`)}`).join("\n");
+      note(updatedList, "Updated Packages");
+    }
+    if (result.skipped.length > 0) {
+      const skippedList = result.skipped.map((s2) => `  \u26A0 ${pc.yellow(s2.record.name)}: ${s2.reason}`).join("\n");
+      note(skippedList, "Skipped Packages (User Modifications)");
+    }
+    if (result.updated.length === 0 && result.skipped.length === 0) {
+      outro(pc.yellow("All packages are already up to date."));
+    } else {
+      outro(pc.green(`\u2714 Successfully processed update for ${result.updated.length} package${result.updated.length > 1 ? "s" : ""}!`));
+    }
+  } catch (err) {
+    updateSpinner.stop(pc.red("Update failed"));
+    outro(pc.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+function renderBundleDetailTree(bundle) {
+  if (bundle.name === "full") {
+    const lines2 = [];
+    lines2.push(`\u{1F4E6} ${pc.bold(pc.green("full"))} ${pc.cyan("(Universal Autonomous Department)")} ${pc.green("\u2B50 [Recommended]")}`);
+    lines2.push(`\u2502   ${pc.white("Complete suite with all 7 lead orchestrators, 38 subagents, 90 skills, and 63 workflows.")}`);
+    lines2.push(`\u2502`);
+    lines2.push(`\u251C\u2500\u2500 \u{1F916} Lead Orchestrators (7 department domains):`);
+    lines2.push(`\u2502   \u251C\u2500\u2500 \u{1F6E0}\uFE0F  ${pc.blue("orchestrator-engineering")} ${pc.dim("(Software Engineering & Delivery)")}`);
+    lines2.push(`\u2502   \u251C\u2500\u2500 \u{1F3DB}\uFE0F  ${pc.blue("orchestrator-system-architecture")} ${pc.dim("(System Architecture & SRE)")}`);
+    lines2.push(`\u2502   \u251C\u2500\u2500 \u{1F3A8}  ${pc.blue("orchestrator-design")} ${pc.dim("(Product Design & UI/UX)")}`);
+    lines2.push(`\u2502   \u251C\u2500\u2500 \u{1F4C8}  ${pc.blue("orchestrator-marketing")} ${pc.dim("(Growth & Marketing Operations)")}`);
+    lines2.push(`\u2502   \u251C\u2500\u2500 \u{1F512}  ${pc.blue("orchestrator-security")} ${pc.dim("(Security Operations)")}`);
+    lines2.push(`\u2502   \u251C\u2500\u2500 \u{1F52C}  ${pc.blue("orchestrator-research")} ${pc.dim("(Deep Technical Research)")}`);
+    lines2.push(`\u2502   \u2514\u2500\u2500 \u{1F4BC}  ${pc.blue("orchestrator-business")} ${pc.dim("(Business Strategy & Economics)")}`);
+    lines2.push(`\u251C\u2500\u2500 \u{1F916} Specialized Sub-Agents: ${pc.blue("38 worker agents across all 8 departments")}`);
+    lines2.push(`\u251C\u2500\u2500 \u26A1 Skills: ${pc.yellow("90 modular skills & runbooks")}`);
+    lines2.push(`\u251C\u2500\u2500 \u{1F504} Workflows: ${pc.magenta("63 guided multi-step workflows")}`);
+    lines2.push(`\u251C\u2500\u2500 \u{1F50C} Prerequisites: ${pc.dim("None (Self-contained universal suite)")}`);
+    lines2.push(`\u2514\u2500\u2500 \u{1F4A1} Execution Modes: ${pc.green("Operational")}`);
+    return lines2.join("\n");
+  }
+  const meta = BUNDLE_DISPLAY_NAMES[bundle.name];
+  const isEssentials = !bundle.parentBundle && bundle.name !== "full" && bundle.name !== "universal-skills" && bundle.name !== "universal-orchestration" && bundle.tier !== "organization";
+  const titleSuffix = isEssentials ? pc.cyan(" (Essentials Base)") : "";
+  const parentTag = bundle.parentBundle ? pc.gray(` [inherits: ${bundle.parentBundle}]`) : "";
+  const aliasesTag = bundle.aliases && bundle.aliases.length > 0 ? pc.gray(` [alias: ${bundle.aliases.join(", ")}]`) : "";
+  let statusBadge = "";
+  if (bundle.name === "universal-skills") statusBadge = pc.green(" \u2B50 [Recommended]");
+  else if (bundle.status === "under-construction") statusBadge = pc.yellow(" \u{1F6A7} [Under Construction]");
+  else if (bundle.status === "needs-audit") statusBadge = pc.magenta(" \u26A0\uFE0F [Needs Audit]");
+  else if (bundle.status === "experimental") statusBadge = pc.cyan(" [Experimental]");
+  else if (bundle.status === "deprecated") statusBadge = pc.red(" [Deprecated]");
+  else statusBadge = pc.green(" [Stable]");
+  const lines = [];
+  lines.push(`\u{1F4E6} ${pc.bold(pc.green(bundle.name))}${titleSuffix}${statusBadge}${parentTag}${aliasesTag}`);
+  lines.push(`\u2502   ${pc.white(bundle.description || meta?.summary || "")}`);
+  lines.push(`\u2502`);
+  if (bundle.orchestrator) {
+    const orchName = bundle.orchestrator.replace(/\.md$/, "");
+    lines.push(`\u251C\u2500\u2500 \u{1F916} Lead: ${pc.blue(pc.bold(orchName))}`);
+  } else {
+    lines.push(`\u251C\u2500\u2500 \u{1F916} Lead: ${pc.dim("None (Self-directed meta-skills)")}`);
+  }
+  if (bundle.agents && bundle.agents.length > 0) {
+    const subNames = bundle.agents.map((a) => a.replace(/^subagent-/, "").replace(/\.md$/, ""));
+    lines.push(`\u251C\u2500\u2500 \u{1F916} Sub-agents (${bundle.agents.length}):`);
+    if (subNames.length <= 5) {
+      subNames.forEach((name, sIdx) => {
+        const isLastSub = sIdx === subNames.length - 1;
+        const subBranch = isLastSub ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+        lines.push(`\u2502   ${subBranch} \u{1F916} ${pc.blue(name)}`);
+      });
+    } else {
+      subNames.slice(0, 4).forEach((name) => {
+        lines.push(`\u2502   \u251C\u2500\u2500 \u{1F916} ${pc.blue(name)}`);
+      });
+      lines.push(`\u2502   \u2514\u2500\u2500 \u{1F916} ${pc.dim(`(+${subNames.length - 4} more: ${subNames.slice(4).join(", ")})`)}`);
+    }
+  } else {
+    lines.push(`\u251C\u2500\u2500 \u{1F916} Sub-agents: ${pc.dim("None")}`);
+  }
+  if (bundle.skills && bundle.skills.length > 0) {
+    lines.push(`\u251C\u2500\u2500 \u26A1 Skills (${bundle.skills.length}):`);
+    if (bundle.skills.length <= 5) {
+      lines.push(`\u2502   \u2514\u2500\u2500 ${pc.yellow(bundle.skills.join(", "))}`);
+    } else {
+      lines.push(`\u2502   \u251C\u2500\u2500 ${pc.yellow(bundle.skills.slice(0, 5).join(", "))}`);
+      lines.push(`\u2502   \u2514\u2500\u2500 ${pc.dim(`(+${bundle.skills.length - 5} more: ${bundle.skills.slice(5).join(", ")})`)}`);
+    }
+  } else {
+    lines.push(`\u251C\u2500\u2500 \u26A1 Skills: ${pc.dim("Inherited from base bundle")}`);
+  }
+  if (bundle.workflows && bundle.workflows.length > 0) {
+    const wfNames = bundle.workflows.map((w) => w.replace(/^workflow-/, "").replace(/\.md$/, ""));
+    lines.push(`\u251C\u2500\u2500 \u{1F504} Workflows (${bundle.workflows.length}):`);
+    if (wfNames.length <= 4) {
+      lines.push(`\u2502   \u2514\u2500\u2500 ${pc.magenta(wfNames.join(", "))}`);
+    } else {
+      lines.push(`\u2502   \u251C\u2500\u2500 ${pc.magenta(wfNames.slice(0, 4).join(", "))}`);
+      lines.push(`\u2502   \u2514\u2500\u2500 ${pc.dim(`(+${wfNames.length - 4} more: ${wfNames.slice(4).join(", ")})`)}`);
+    }
+  } else {
+    lines.push(`\u251C\u2500\u2500 \u{1F504} Workflows: ${pc.dim("Inherited from base bundle")}`);
+  }
+  if (bundle.prerequisites) {
+    const prereqParts = [];
+    if (bundle.prerequisites.requiredMcps && bundle.prerequisites.requiredMcps.length > 0) {
+      prereqParts.push(`MCPs: ${bundle.prerequisites.requiredMcps.map((m) => m.name).join(", ")}`);
+    }
+    if (bundle.prerequisites.requiredPackages && bundle.prerequisites.requiredPackages.length > 0) {
+      prereqParts.push(`Packages: ${bundle.prerequisites.requiredPackages.join(", ")}`);
+    }
+    if (bundle.prerequisites.requiredEnvVars && bundle.prerequisites.requiredEnvVars.length > 0) {
+      prereqParts.push(`Env: ${bundle.prerequisites.requiredEnvVars.join(", ")}`);
+    }
+    if (prereqParts.length > 0) {
+      lines.push(`\u251C\u2500\u2500 \u{1F50C} Prerequisites: ${pc.yellow(prereqParts.join(" | "))}`);
+    }
+  } else {
+    lines.push(`\u251C\u2500\u2500 \u{1F50C} Prerequisites: ${pc.dim("None (Self-contained domain bundle)")}`);
+  }
+  if (bundle.modes) {
+    lines.push(`\u2514\u2500\u2500 \u{1F4A1} Execution Modes: ${pc.green("Operational")} (live MCPs) / ${pc.cyan("Brainstorming")} (advisory fallback)`);
+  } else {
+    lines.push(`\u2514\u2500\u2500 \u{1F4A1} Execution Modes: ${pc.green("Operational")}`);
+  }
+  return lines.join("\n");
+}
+function renderFullCatalogTree(bundles) {
+  intro(pc.cyan("Agents United \u2014 Registry Catalog Tree"));
+  const domainTitles = {
+    engineering: "\u{1F6E0}\uFE0F  Software Engineering & Delivery",
+    architecture: "\u{1F3DB}\uFE0F  System Architecture & SRE",
+    design: "\u{1F3A8}  Product Design & UI/UX",
+    marketing: "\u{1F4C8}  Growth & Marketing Operations",
+    security: "\u{1F512}  Security Operations",
+    research: "\u{1F52C}  Deep Technical Research",
+    business: "\u{1F4BC}  Business Strategy & Economics",
+    universal: "\u{1F310}  Universal Autonomous Department"
+  };
+  const domainOrder = [
+    "universal",
+    "engineering",
+    "architecture",
+    "design",
+    "marketing",
+    "security",
+    "research",
+    "business"
+  ];
+  const grouped = {};
+  const orgBundles = [];
+  for (const b of bundles) {
+    if (b.tier === "organization" || b.domain === "organization") {
+      orgBundles.push(b);
+      continue;
+    }
+    const d = b.domain || "other";
+    if (!grouped[d]) grouped[d] = [];
+    grouped[d].push(b);
+  }
+  for (const domainKey of domainOrder) {
+    const items = grouped[domainKey];
+    if (!items || items.length === 0) continue;
+    const header = domainTitles[domainKey] || `\u{1F4C1}  ${domainKey.toUpperCase()}`;
+    console.log(`
+${pc.bold(pc.magenta(header))} ${pc.dim(`(${items.length} bundle${items.length > 1 ? "s" : ""})`)}`);
+    items.forEach((b, bIdx) => {
+      const isLastBundle = bIdx === items.length - 1;
+      const bBranch = isLastBundle ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+      const subIndent = isLastBundle ? "    " : "\u2502   ";
+      const meta = BUNDLE_DISPLAY_NAMES[b.name];
+      const isEssentials = !b.parentBundle && b.name !== "full" && b.name !== "universal-skills" && b.name !== "universal-orchestration";
+      const titleSuffix = isEssentials ? pc.cyan(" (Essentials)") : "";
+      const parentTag = b.parentBundle ? pc.gray(` [inherits: ${b.parentBundle}]`) : "";
+      const aliasesTag = b.aliases && b.aliases.length > 0 ? pc.gray(` [alias: ${b.aliases.join(", ")}]`) : "";
+      let statusBadge = "";
+      if (b.name === "universal-skills") statusBadge = pc.green(" \u2B50 [Recommended]");
+      else if (b.status === "under-construction") statusBadge = pc.yellow(" \u{1F6A7} [Under Construction]");
+      else if (b.status === "needs-audit") statusBadge = pc.magenta(" \u26A0\uFE0F [Needs Audit]");
+      else if (b.status === "experimental") statusBadge = pc.cyan(" [Experimental]");
+      else if (b.status === "deprecated") statusBadge = pc.red(" [Deprecated]");
+      console.log(`${bBranch} \u{1F4E6} ${pc.bold(pc.green(b.name))}${titleSuffix}${statusBadge}${parentTag}${aliasesTag}`);
+      console.log(`${subIndent}\u2502   ${pc.white(b.description)}`);
+      if (b.orchestrator) {
+        const orchName = b.orchestrator.replace(/\.md$/, "");
+        console.log(`${subIndent}\u251C\u2500\u2500 \u{1F916} Lead: ${pc.blue(orchName)}`);
+      }
+      if (b.agents && b.agents.length > 0) {
+        const subNames = b.agents.map((a) => a.replace(/^subagent-/, "").replace(/\.md$/, ""));
+        const displaySubs = subNames.length > 3 ? `${subNames.slice(0, 3).join(", ")} (+${subNames.length - 3} more)` : subNames.join(", ");
+        console.log(`${subIndent}\u251C\u2500\u2500 \u{1F916} Sub-agents: ${pc.blue(displaySubs)}`);
+      }
+      if (b.skills && b.skills.length > 0) {
+        const displaySkills = b.skills.length > 3 ? `${b.skills.slice(0, 3).join(", ")} (+${b.skills.length - 3} more)` : b.skills.join(", ");
+        console.log(`${subIndent}\u251C\u2500\u2500 \u26A1 Skills: ${pc.yellow(displaySkills)}`);
+      }
+      if (b.workflows && b.workflows.length > 0) {
+        const wfNames = b.workflows.map((w) => w.replace(/^workflow-/, "").replace(/\.md$/, ""));
+        const displayWfs = wfNames.length > 3 ? `${wfNames.slice(0, 3).join(", ")} (+${wfNames.length - 3} more)` : wfNames.join(", ");
+        console.log(`${subIndent}\u2514\u2500\u2500 \u{1F504} Workflows: ${pc.magenta(displayWfs)}`);
+      } else {
+        console.log(`${subIndent}\u2514\u2500\u2500 \u{1F504} Workflows: ${pc.dim("Inherited from parent")}`);
+      }
+      if (!isLastBundle) {
+        console.log(`${subIndent}`);
+      }
+    });
+  }
+  if (orgBundles.length > 0) {
+    console.log(`
+${pc.bold(pc.cyan("\u{1F3E2}  Organization Bundles (Experimental / Cross-Functional)"))} ${pc.dim(`(${orgBundles.length} bundle${orgBundles.length > 1 ? "s" : ""})`)}`);
+    console.log(pc.dim("   Cross-domain teams modeled after real organizations. Require runtime prerequisites (MCPs/packages)."));
+    orgBundles.forEach((b, bIdx) => {
+      const isLastBundle = bIdx === orgBundles.length - 1;
+      const bBranch = isLastBundle ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+      const subIndent = isLastBundle ? "    " : "\u2502   ";
+      let statusBadge = "";
+      if (b.status === "under-construction") statusBadge = pc.yellow(" \u{1F6A7} [Under Construction (TBA)]");
+      else if (b.status === "needs-audit") statusBadge = pc.magenta(" \u26A0\uFE0F [Needs Audit]");
+      else if (b.status === "experimental") statusBadge = pc.cyan(" [Experimental]");
+      else if (b.status === "deprecated") statusBadge = pc.red(" [Deprecated]");
+      else statusBadge = pc.green(" [Stable]");
+      const prereqBadge = pc.dim(" [Prerequisites Required]");
+      console.log(`${bBranch} \u{1F3E2} ${pc.bold(pc.cyan(b.name))}${statusBadge}${prereqBadge}`);
+      console.log(`${subIndent}\u2502   ${pc.white(b.description)}`);
+      if (b.orchestrator) {
+        const orchName = b.orchestrator.replace(/\.md$/, "");
+        console.log(`${subIndent}\u251C\u2500\u2500 \u{1F916} Lead: ${pc.blue(orchName)}`);
+      }
+      if (b.agents && b.agents.length > 0) {
+        const subNames = b.agents.map((a) => a.replace(/^subagent-/, "").replace(/\.md$/, ""));
+        const displaySubs = subNames.length > 3 ? `${subNames.slice(0, 3).join(", ")} (+${subNames.length - 3} more)` : subNames.join(", ");
+        console.log(`${subIndent}\u251C\u2500\u2500 \u{1F916} Sub-agents: ${pc.blue(displaySubs)}`);
+      }
+      if (b.skills && b.skills.length > 0) {
+        const displaySkills = b.skills.length > 3 ? `${b.skills.slice(0, 3).join(", ")} (+${b.skills.length - 3} more)` : b.skills.join(", ");
+        console.log(`${subIndent}\u251C\u2500\u2500 \u26A1 Skills: ${pc.yellow(displaySkills)}`);
+      }
+      if (b.workflows && b.workflows.length > 0) {
+        const wfNames = b.workflows.map((w) => w.replace(/^workflow-/, "").replace(/\.md$/, ""));
+        const displayWfs = wfNames.length > 3 ? `${wfNames.slice(0, 3).join(", ")} (+${wfNames.length - 3} more)` : wfNames.join(", ");
+        console.log(`${subIndent}\u251C\u2500\u2500 \u{1F504} Workflows: ${pc.magenta(displayWfs)}`);
+      }
+      if (b.prerequisites) {
+        const prereqParts = [];
+        if (b.prerequisites.requiredMcps && b.prerequisites.requiredMcps.length > 0) {
+          prereqParts.push(`MCPs: ${b.prerequisites.requiredMcps.map((m) => m.name).join(", ")}`);
+        }
+        if (b.prerequisites.requiredPackages && b.prerequisites.requiredPackages.length > 0) {
+          prereqParts.push(`Packages: ${b.prerequisites.requiredPackages.join(", ")}`);
+        }
+        if (b.prerequisites.requiredEnvVars && b.prerequisites.requiredEnvVars.length > 0) {
+          prereqParts.push(`Env: ${b.prerequisites.requiredEnvVars.join(", ")}`);
+        }
+        if (prereqParts.length > 0) {
+          console.log(`${subIndent}\u251C\u2500\u2500 \u{1F50C} Prerequisites: ${pc.yellow(prereqParts.join(" | "))}`);
+        }
+      }
+      if (b.modes) {
+        console.log(`${subIndent}\u2514\u2500\u2500 \u{1F4A1} Execution Modes: ${pc.green("Operational")} (live MCPs) / ${pc.cyan("Brainstorming")} (advisory fallback)`);
+      } else {
+        console.log(`${subIndent}\u2514\u2500\u2500 \u{1F4A1} Execution Modes: ${pc.green("Operational")}`);
+      }
+      if (!isLastBundle) {
+        console.log(`${subIndent}`);
+      }
+    });
+  }
+  outro(pc.cyan('\nRun "agents add <bundle>" or select interactively to install.'));
+}
+async function handleBundleDetailView(bundle) {
+  const treeOutput = renderBundleDetailTree(bundle);
+  console.log(`
+${pc.bold(pc.cyan("\u250C\u2500\u2500 \u{1F4CB} Bundle Detail: " + pc.green(bundle.name) + " " + "\u2500".repeat(Math.max(2, 40 - bundle.name.length))))}`);
+  console.log(treeOutput);
+  console.log(`${pc.bold(pc.cyan("\u2514" + "\u2500".repeat(60)))}
+`);
+  const actionOptions = [
+    {
+      value: "install",
+      label: `\u{1F680} Install "${bundle.name}" bundle`,
+      hint: `run installer for ${bundle.name}`
+    },
+    {
+      value: "back_bundle",
+      label: `\u{1F519} Back to ${bundle.domain || "Department"} bundle list`,
+      hint: "explore other bundles in this category"
+    },
+    {
+      value: "back_dept",
+      label: `\u{1F3DB}\uFE0F Back to Department selection`,
+      hint: "explore other departments"
+    },
+    {
+      value: "exit",
+      label: `\u{1F6AA} Exit explorer`,
+      hint: "return to shell"
+    }
+  ];
+  const action = await select({
+    message: `Action for ${pc.bold(pc.green(bundle.name))}:`,
+    options: actionOptions
+  });
+  if (action === "install") {
+    if (bundle.status === "under-construction") {
+      note(
+        `The bundle "${bundle.name}" is currently under active construction (status: under-construction).
+Its orchestrators, workflows, and specialized skills are being authored and are not ready for production use.
+
+Planned Capabilities:
+\u2022 Lead Orchestrator with Firecrawl & GitHub MCP tool calling
+\u2022 Full-stack web, design & SEO delivery workflows
+\u2022 Dual Execution Modes (Operational / Brainstorming)`,
+        "\u{1F6A7} Under Construction Gate"
+      );
+      const underConstructionChoice = await select({
+        message: pc.yellow(`"${bundle.name}" is currently under construction. How would you like to proceed?`),
+        options: [
+          {
+            value: "abort",
+            label: "\u{1F6D1} Abort installation (Recommended)",
+            hint: "return without modifying workspace files"
+          },
+          {
+            value: "allow",
+            label: "\u26A0\uFE0F  Install in-development draft anyway (--allow-under-construction)",
+            hint: "proceed with in-progress placeholder assets"
+          }
+        ]
+      });
+      if (underConstructionChoice === "abort" || typeof underConstructionChoice !== "string") {
+        outro(pc.yellow(`Installation cancelled. "${bundle.name}" is under construction.`));
+        return "__back_bundle__";
+      }
+    }
+    let executionMode = "operational";
+    if (bundle.prerequisites || bundle.tier === "organization") {
+      const checker = new PrerequisiteChecker();
+      const prereqEval = await checker.evaluate(bundle);
+      if (prereqEval.hasPrerequisites) {
+        const checkLines = [];
+        for (const item of prereqEval.items) {
+          const typeLabel = item.type === "mcp" ? "MCP" : item.type === "env" ? "Env" : "Pkg";
+          const icon = item.satisfied ? pc.green("\u2713") : pc.red("\u2717");
+          const details = pc.dim(`(${item.details || ""})`);
+          checkLines.push(`  ${icon} [${typeLabel}] ${pc.bold(item.name)}: ${item.satisfied ? pc.green("Detected") : pc.red("Missing")} ${details}`);
+        }
+        note(
+          checkLines.join("\n"),
+          `Prerequisite Evaluation: ${bundle.name} (${bundle.tier === "organization" ? "Organization Bundle" : "Prerequisites Required"})`
+        );
+        if (!prereqEval.allSatisfied) {
+          const gateChoice = await select({
+            message: pc.yellow(`Prerequisites not fully satisfied for "${bundle.name}". How would you like to proceed?`),
+            options: [
+              {
+                value: "abort",
+                label: "\u{1F6D1} Abort and configure missing prerequisites (Recommended)",
+                hint: "exit and configure MCP servers, packages, or environment variables"
+              },
+              {
+                value: "brainstorming",
+                label: "\u{1F4A1} Install in Brainstorming Mode (Advisory & Spec generation only)",
+                hint: "runs in idea/planning mode without requiring live MCP tool connections"
+              },
+              {
+                value: "force",
+                label: "\u26A0\uFE0F  Force install in Operational Mode anyway",
+                hint: "proceed despite missing prerequisites (may fail during runtime calls)"
+              }
+            ]
+          });
+          if (gateChoice === "abort" || typeof gateChoice !== "string") {
+            outro(pc.yellow("Installation aborted. Please configure required MCPs and environment variables, then retry."));
+            return "__back_bundle__";
+          }
+          if (gateChoice === "brainstorming") {
+            executionMode = "brainstorming";
+            note(pc.cyan('Switched execution mode to "brainstorming" (idea/spec fallback mode).'), "Mode Selected");
+          } else if (gateChoice === "force") {
+            executionMode = "operational";
+            note(pc.yellow('Proceeding in "operational" mode with missing prerequisites.'), "Warning");
+          }
+        }
+      }
+    }
+    const detectedHosts = detectWorkspaceHosts();
+    let installHosts = ["agents"];
+    let installFanout = [];
+    if (detectedHosts.length > 0) {
+      const projectionHosts = detectedHosts.filter((h) => HOST_REGISTRY[h].projectionCapable);
+      installFanout = projectionHosts;
+      installHosts = detectedHosts.filter((h) => !HOST_REGISTRY[h].projectionCapable);
+      if (!installHosts.includes("agents")) installHosts.unshift("agents");
+    }
+    const installSpinner = spinner();
+    installSpinner.start(`Installing "${bundle.name}"...`);
+    try {
+      const result = await installer.install(bundle.name, {
+        scope: "project",
+        hosts: installHosts,
+        fanout: installFanout,
+        mode: executionMode,
+        method: "symlink"
+      });
+      installSpinner.stop(pc.green(`\u2714 Successfully installed ${bundle.name}!`));
+      note(
+        `Bundle: ${result.installed.targetBundle || bundle.name}
+Scope: project
+Method: ${result.method}
+Targets: ${installHosts.join(", ")}
+Agents: ${result.installed.agents.join(", ") || "None"}
+Skills: ${result.installed.skills.join(", ") || "None"}
+Target Directories: ${result.targetDirs.join("\n  ")}` + (result.projections.length > 0 ? `
+
+Projections:
+${renderProjections(result.projections)}` : ""),
+        "Installation Success"
+      );
+      outro(pc.green(`\u2728 Installation of "${bundle.name}" complete!`));
+    } catch (err) {
+      installSpinner.stop(pc.red("Installation failed"));
+      outro(pc.red(`Error: ${err.message}`));
+    }
+    return "__exit__";
+  } else if (action === "back_dept") {
+    return "__back_dept__";
+  } else if (action === "exit" || typeof action !== "string") {
+    return "__exit__";
+  }
+  return "__back_bundle__";
+}
+cli.command("list", "List available bundles grouped by department domain").alias("ls").option("--json", "Output bundles in JSON format").option("--tree", "Output full static catalog tree").option("--all", "Output full static catalog tree").action(async (options = {}) => {
+  const bundles = await registry.listBundles();
+  if (options.json) {
+    console.log(JSON.stringify(bundles, null, 2));
+    return;
+  }
+  const isInteractive = process.stdout.isTTY && !options.tree && !options.all;
+  if (!isInteractive) {
+    renderFullCatalogTree(bundles);
+    return;
+  }
+  intro(pc.cyan("\u{1F310} Agents United \u2014 Interactive Catalog Explorer"));
+  const domainMeta = {
+    universal: { label: "Universal Autonomous Department", icon: "\u{1F310} " },
+    engineering: { label: "Software Engineering & Delivery", icon: "\u{1F6E0}\uFE0F " },
+    architecture: { label: "System Architecture & SRE", icon: "\u{1F3DB}\uFE0F " },
+    design: { label: "Product Design & UI/UX", icon: "\u{1F3A8} " },
+    marketing: { label: "Growth & Marketing Operations", icon: "\u{1F4C8} " },
+    security: { label: "Security Operations", icon: "\u{1F512} " },
+    research: { label: "Deep Technical Research", icon: "\u{1F52C} " },
+    business: { label: "Business Strategy & Economics", icon: "\u{1F4BC} " },
+    organization: { label: "Organization Bundles (Experimental / Cross-Functional)", icon: "\u{1F3E2} " }
+  };
+  let activeDomain;
+  while (true) {
+    if (!activeDomain) {
+      const domainOptions = Object.entries(domainMeta).map(([domainKey, meta]) => {
+        const count = bundles.filter((b) => b.domain === domainKey || domainKey === "organization" && b.tier === "organization").length;
+        return {
+          value: domainKey,
+          label: `${meta.icon} ${meta.label}`,
+          hint: domainKey === "universal" ? "meta-skills baseline + full suite" : domainKey === "organization" ? "cross-functional teams with prerequisites" : `${count} specialized bundle${count > 1 ? "s" : ""}`
+        };
+      });
+      domainOptions.push({
+        value: "__search__",
+        label: "\u{1F50D} Search by name / keyword...",
+        hint: "find bundles, agents, skills or workflows"
+      });
+      domainOptions.push({
+        value: "__full_tree__",
+        label: "\u{1F333} View Full Static Catalog Tree",
+        hint: "expand all 18 bundles and 8 departments at once"
+      });
+      const selectedDomain = await select({
+        message: "Select Department Domain to explore:",
+        options: domainOptions
+      });
+      if (typeof selectedDomain !== "string") {
+        outro(pc.cyan("Catalog explorer closed."));
+        return;
+      }
+      if (selectedDomain === "__full_tree__") {
+        renderFullCatalogTree(bundles);
+        continue;
+      }
+      if (selectedDomain === "__search__") {
+        const query = await text({
+          message: "Enter keyword to search:",
+          placeholder: "e.g. mobile, playwright, react, backend, seo"
+        });
+        if (typeof query !== "string" || !query.trim()) {
+          continue;
+        }
+        const results = await registry.find(query.trim());
+        if (results.bundles.length === 0 && results.agents.length === 0 && results.skills.length === 0 && results.workflows.length === 0) {
+          note(`No items found matching "${query.trim()}".`, "Search Results");
+          continue;
+        }
+        const searchOptions = [
+          ...results.bundles.map((b) => ({
+            value: `bundle:${b.name}`,
+            label: `\u{1F4E6} [Bundle] ${BUNDLE_DISPLAY_NAMES[b.name]?.title || b.name} (${b.name})`,
+            hint: b.description
+          })),
+          {
+            value: "__back__",
+            label: "\u{1F519} Back to Department Selection",
+            hint: ""
+          }
+        ];
+        if (searchOptions.length === 1) {
+          note(`Found related agents/skills for "${query}", but no top-level bundles. Try browsing by department.`, "Search Results");
+          continue;
+        }
+        const chosen = await select({
+          message: `Search Results for "${query.trim()}":`,
+          options: searchOptions
+        });
+        if (typeof chosen === "string" && chosen.startsWith("bundle:")) {
+          const bundleName = chosen.replace(/^bundle:/, "");
+          const b = await registry.getBundle(bundleName);
+          if (b) {
+            const action2 = await handleBundleDetailView(b);
+            if (action2 === "__exit__") {
+              outro(pc.cyan("Catalog explorer closed."));
+              return;
+            }
+          }
+        }
+        continue;
+      }
+      activeDomain = selectedDomain;
+    }
+    const domainBundles = bundles.filter((b) => b.domain === activeDomain || activeDomain === "organization" && b.tier === "organization");
+    const sortedBundles = [...domainBundles].sort((a, b) => {
+      if (a.name === "universal-orchestration") return -1;
+      if (b.name === "universal-orchestration") return 1;
+      if (a.name === "universal-skills") return -1;
+      if (b.name === "universal-skills") return 1;
+      if (!a.parentBundle && b.parentBundle) return -1;
+      if (a.parentBundle && !b.parentBundle) return 1;
+      return a.name.localeCompare(b.name);
+    });
+    const bundleOptions = sortedBundles.map((b, idx) => {
+      const isLast = idx === sortedBundles.length - 1;
+      const branch = sortedBundles.length > 1 ? isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 " : "";
+      const meta = BUNDLE_DISPLAY_NAMES[b.name];
+      const isEssentials = !b.parentBundle && b.name !== "full" && b.name !== "universal-skills" && b.name !== "universal-orchestration" && b.tier !== "organization";
+      const titleSuffix = isEssentials ? pc.cyan(" (Essentials Base)") : "";
+      const parentTag = b.parentBundle ? pc.gray(` [inherits: ${b.parentBundle}]`) : "";
+      let badge = "";
+      if (b.name === "universal-skills") badge = pc.green(" \u2B50 [Recommended]");
+      else if (b.status === "under-construction") badge = pc.yellow(" \u{1F6A7} [Under Construction]");
+      else if (b.status === "needs-audit") badge = pc.magenta(" \u26A0\uFE0F [Needs Audit]");
+      else if (b.status === "experimental") badge = pc.cyan(" [Experimental]");
+      else if (b.status === "deprecated") badge = pc.red(" [Deprecated]");
+      return {
+        value: b.name,
+        label: `${branch}\u{1F4E6} ${meta?.title || b.name}${titleSuffix}${badge}${parentTag}`,
+        hint: b.description || meta?.summary || b.name
+      };
+    });
+    bundleOptions.push({
+      value: "__back_domain__",
+      label: "\u{1F519} Back to Department Selection",
+      hint: "choose another department domain"
+    });
+    const selectedBundleName = await select({
+      message: `${domainMeta[activeDomain]?.label || activeDomain} \u2014 Select bundle to open:`,
+      options: bundleOptions
+    });
+    if (typeof selectedBundleName !== "string") {
+      outro(pc.cyan("Catalog explorer closed."));
+      return;
+    }
+    if (selectedBundleName === "__back_domain__") {
+      activeDomain = void 0;
+      continue;
+    }
+    const bundle = await registry.getBundle(selectedBundleName);
+    if (!bundle) continue;
+    const action = await handleBundleDetailView(bundle);
+    if (action === "__exit__") {
+      outro(pc.cyan("Catalog explorer closed."));
+      return;
+    }
+    if (action === "__back_dept__") {
+      activeDomain = void 0;
+    }
+  }
+});
+cli.command("find [query]", "Search for agents, skills, workflows, or bundles in the registry").alias("search").option("-c, --category <domain>", "Filter search by domain (e.g. engineering, architecture, design)").option("-t, --type <type>", "Filter by item type (bundle, agent, skill, workflow)").option("--json", "Output results in JSON format").option("-i, --interactive", "Interactive selection to install matching item").action(async (query, options = {}) => {
+  const q = query || "";
+  const results = await registry.find(q, {
+    domain: options.category || options.domain,
+    type: options.type
+  });
+  if (options.json) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  const totalCount = results.bundles.length + results.agents.length + results.skills.length + results.workflows.length;
+  intro(pc.cyan(`Agents United - Search Results: "${q || "*"}" (${totalCount} found)`));
+  if (results.bundles.length > 0) {
+    console.log(pc.bold(`
+\u{1F4E6} Bundles (${results.bundles.length}):`));
+    results.bundles.forEach((b) => {
+      const meta = BUNDLE_DISPLAY_NAMES[b.name];
+      console.log(`  - ${pc.green(pc.bold(b.name))}: ${pc.white(meta?.title || b.name)} \u2014 ${pc.dim(b.description)}`);
+    });
+  }
+  if (results.agents.length > 0) {
+    console.log(pc.bold(`
+\u{1F916} Agents (${results.agents.length}):`));
+    results.agents.forEach((a) => {
+      const stem = a.replace(/\.md$/, "");
+      console.log(`  - ${pc.blue(stem)} ${pc.gray(`(${a})`)}`);
+    });
+  }
+  if (results.skills.length > 0) {
+    console.log(pc.bold(`
+\u26A1 Skills (${results.skills.length}):`));
+    results.skills.forEach((s) => console.log(`  - ${pc.yellow(s)}`));
+  }
+  if (results.workflows.length > 0) {
+    console.log(pc.bold(`
+\u{1F504} Workflows (${results.workflows.length}):`));
+    results.workflows.forEach((w) => {
+      const stem = w.replace(/\.md$/, "");
+      console.log(`  - ${pc.magenta(stem)} ${pc.gray(`(${w})`)}`);
+    });
+  }
+  if (totalCount === 0) {
+    console.log(pc.yellow(`
+No matching items found for "${q}". Try searching without filters or using "agents list".`));
+  }
+  if (options.interactive && totalCount > 0) {
+    const items = [
+      ...results.bundles.map((b) => ({ value: b.name, label: `[Bundle] ${b.name} \u2014 ${b.description}` })),
+      ...results.agents.map((a) => ({ value: a.replace(/\.md$/, ""), label: `[Agent] ${a}` })),
+      ...results.skills.map((s) => ({ value: s, label: `[Skill] ${s}` })),
+      ...results.workflows.map((w) => ({ value: w.replace(/\.md$/, ""), label: `[Workflow] ${w}` }))
+    ];
+    const selected = await select({
+      message: "Select an item to install:",
+      options: items
+    });
+    if (typeof selected === "string") {
+      const s = spinner();
+      s.start(`Installing "${selected}"...`);
+      try {
+        const res = await installer.install(selected, { scope: "project" });
+        s.stop(`Installed ${selected}`);
+        outro(pc.green(`\u2714 Successfully installed "${selected}"!`));
+      } catch (err) {
+        s.stop(pc.red("Installation failed"));
+        outro(pc.red(`Error: ${err.message}`));
+      }
+      return;
+    }
+  }
+  outro(pc.cyan('\nUse "agents add <name>" to install any match.'));
+});
+cli.command("init", "Initialize project workspace directory and install recommended bundle").option("-b, --bundle <bundle>", "Default bundle to install", { default: "software-engineering" }).option("-s, --symlink", "Use symlinks (default / recommended)").option("--copy", "Use standalone copies").option("-t, --target <hosts>", "Target agent hosts", { default: "agents" }).action(async (options) => {
+  intro(pc.cyan("Agents United - Initialize Workspace"));
+  const s = spinner();
+  s.start(`Initializing workspace with bundle "${options.bundle}"...`);
+  try {
+    const initTargets = (Array.isArray(options.target) ? options.target : String(options.target || "agents").split(",")).map((h) => h.trim().toLowerCase());
+    const initPlan = planInstallTargets(initTargets);
+    const result = await installer.install(options.bundle, {
+      scope: "project",
+      symlink: options.symlink,
+      copy: options.copy,
+      hosts: initPlan.hosts,
+      fanout: initPlan.fanout
+    });
+    s.stop(`Initialized ${result.targetDirs.join(", ")}`);
+    outro(pc.green(`\u2714 Initialized workspace with "${options.bundle}" bundle!`));
+  } catch (err) {
+    s.stop(pc.red("Initialization failed"));
+    outro(pc.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+cli.command("start <bundle> [prompt]", "Start an installed bundle team in its host runtime (e.g. Cline)").option("--host <host>", "Host runtime (default: auto-detect from lockfile fanout)").option("-g, --global", "Select global installation").option("--team <name>", "Override generated team name").option("--allow-addons", "Pre-authorize recommended addon installations for this session").option("--headless", "Run non-interactively without interactive TUI").option("--dry-run", "Print activation resolution and argv summary without launching").action(async (bundle, prompt, options = {}) => {
+  intro(pc.cyan("Agents United \u2014 Runtime Activation"));
+  const launcher = new ClineLauncher();
+  const probe = new ClineCapabilityProbe();
+  try {
+    const resolution = await launcher.resolveInstallation(bundle, {
+      global: options.global,
+      cwd: process.cwd()
+    });
+    const probeReport = await probe.probe();
+    if (!probeReport.installed && !options.dryRun) {
+      outro(pc.red(`Cline executable was not found on PATH or via CLINE_BIN_PATH. Please install Cline CLI or ensure it is accessible.`));
+      process.exit(1);
+    }
+    const bundleDef = await registry.getBundle(bundle);
+    const plan = launcher.planActivation({
+      bundleName: bundle,
+      workspace: resolution.workspace,
+      scope: resolution.scope,
+      report: probeReport,
+      prompt,
+      teamName: options.team,
+      allowAddons: options.allowAddons,
+      headless: options.headless,
+      orchestrator: bundleDef?.orchestrator
+    });
+    if (options.dryRun) {
+      note(
+        `Bundle: ${plan.bundleName}
+Scope: ${plan.scope}
+Workspace: ${plan.workspace}
+Team Name: ${plan.teamName}
+Strategy: ${plan.strategy}
+Executable: ${plan.executable}
+Argv: ${plan.argv.map((a) => a.includes(" ") || a.includes("\n") ? `"${a.replace(/\n/g, "\\n")}"` : a).join(" ")}`,
+        "Activation Plan (dry run)"
+      );
+      outro(pc.yellow("Dry run complete. No processes launched."));
+      return;
+    }
+    note(
+      `Team: ${pc.bold(plan.teamName)}
+Strategy: ${pc.cyan(plan.strategy)}
+Workspace: ${plan.workspace}`,
+      "Starting Cline Team"
+    );
+    await launcher.launch(plan);
+    outro(pc.green(`\u2714 Cline session finished.`));
+  } catch (err) {
+    outro(pc.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+cli.command("doctor", "Verify health of installed agents, frontmatter schemas, and hooks").option("--host <host>", "Audit specific host runtime (e.g. cline)").action(async (options = {}) => {
+  intro(pc.cyan("\u{1FA7A} Agents United \u2014 Health Doctor"));
+  const report = await DoctorEngine.runDoctor(void 0, options.host);
+  if (!report.isInitialized || report.agentsCount === 0 && report.skillsCount === 0 && report.workflowsCount === 0 && report.issues.length === 0) {
+    console.log(`  ${pc.bold("\u{1F4E6} Status:")}   ${pc.yellow("No agents or bundles installed in this workspace.")}`);
+    console.log(`  ${pc.bold("\u{1F4CD} Location:")} ${pc.dim(report.targetDir)}
+`);
+    console.log(pc.bold(pc.cyan("\u{1F4A1} Get Started:")));
+    console.log(`  \u{1F449} ${pc.bold("agents add")}                      Launch the interactive installation wizard`);
+    console.log(`  \u{1F449} ${pc.bold("agents add software-engineering")} Install the engineering essentials team`);
+    console.log(`  \u{1F449} ${pc.bold("agents list")}                     Browse all 23 bundles and 8 departments
+`);
+    if (report.clineCapability) {
+      console.log(pc.bold(pc.cyan("Cline Runtime & Compound Projection Audit:")));
+      console.log(`  Installed: ${report.clineCapability.installed ? pc.green("\u2714 Detected") : pc.yellow("\u2716 Not Found")}`);
+      if (report.clineCapability.version) {
+        console.log(`  Version: ${report.clineCapability.version}`);
+      }
+      console.log(`  Named Teams: ${report.clineCapability.namedTeams ? pc.green("\u2714 Supported") : pc.yellow("\u2716 Unsupported (Adaptive fallback)")}
+`);
+    }
+    if (report.warnings.length > 0) {
+      console.log(pc.yellow(pc.bold("\u26A0\uFE0F  Warnings:")));
+      report.warnings.forEach((w) => console.log(`  \u26A0 ${w}`));
+      console.log();
+    }
+    outro(pc.blue("\u2728 Workspace is ready for initialization."));
+    return;
+  }
+  console.log(`  \u{1F916} Installed Agents:    ${pc.bold(report.agentsCount.toString())}`);
+  console.log(`  \u26A1 Installed Skills:    ${pc.bold(report.skillsCount.toString())}`);
+  console.log(`  \u{1F504} Installed Workflows: ${pc.bold(report.workflowsCount.toString())}
+`);
+  if (report.clineCapability) {
+    console.log(pc.bold(pc.cyan("Cline Runtime & Compound Projection Audit:")));
+    console.log(`  Installed: ${report.clineCapability.installed ? pc.green("\u2714 Detected") : pc.yellow("\u2716 Not Found")}`);
+    if (report.clineCapability.version) {
+      console.log(`  Version: ${report.clineCapability.version}`);
+    }
+    console.log(`  Named Teams: ${report.clineCapability.namedTeams ? pc.green("\u2714 Supported") : pc.yellow("\u2716 Unsupported (Adaptive fallback)")}`);
+    console.log(`  Role Definitions: ${report.agentsCount} prepared (activation via "agents start")
+`);
+  }
+  if (report.issues.length > 0) {
+    console.log(pc.red(pc.bold("\u274C Issues Found:")));
+    report.issues.forEach((i) => console.log(`  \u2716 ${i}`));
+    console.log();
+  }
+  if (report.warnings.length > 0) {
+    console.log(pc.yellow(pc.bold("\u26A0\uFE0F  Warnings:")));
+    report.warnings.forEach((w) => console.log(`  \u26A0 ${w}`));
+    console.log();
+  }
+  if (report.valid && report.issues.length === 0) {
+    outro(pc.green("\u2714 All installed agents and frontmatter schemas are healthy!"));
+  } else {
+    outro(pc.red("\u2716 Doctor found issues in workspace configuration."));
+    process.exit(1);
+  }
+});
+cli.help();
+cli.version("1.0.0");
+cli.parse();
+export {
+  detectWorkspaceHosts
+};
+//# sourceMappingURL=cli.js.map