agents-united 1.0.0 → 1.2.0

package/dist/cli.js

@@ -3,7 +3,9 @@
 // src/cli.ts
 import { cac } from "cac";
 import pc from "picocolors";
-import { intro, outro, spinner, note } from "@clack/prompts";
+import { intro, outro, spinner, note, select, multiselect, confirm, text } from "@clack/prompts";
+import fs11 from "fs-extra";
+import path13 from "path";
 
 // src/core/registry.ts
 import path from "path";
@@ -43,22 +45,63 @@ var RegistryResolver = class {
   }
   async getBundle(bundleName) {
     const manifest = await this.loadBundles();
-    return manifest.bundles[bundleName] || null;
+    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 resolve(identifier) {
+  async getBundlesByDomain(domain) {
     const manifest = await this.loadBundles();
-    const bundle = manifest.bundles[identifier];
+    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();
-      if (bundle.orchestrator) agents.add(bundle.orchestrator);
-      if (bundle.agents) bundle.agents.forEach((a) => agents.add(a));
       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),
@@ -97,76 +140,626 @@ var RegistryResolver = class {
     }
     throw new Error(`Item or bundle "${identifier}" not found in registry.`);
   }
-  async find(query) {
+  async find(query = "", options) {
     const manifest = await this.loadBundles();
-    const q = query.toLowerCase();
-    const matchedBundles = Object.values(manifest.bundles).filter(
-      (b) => b.name.toLowerCase().includes(q) || b.description.toLowerCase().includes(q)
-    );
+    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 (await fs.pathExists(agentsDir)) {
-      const files = await fs.readdir(agentsDir);
-      matchedAgents = files.filter((f) => f.toLowerCase().includes(q));
+    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 (await fs.pathExists(skillsDir)) {
-      const dirs = await fs.readdir(skillsDir);
-      matchedSkills = dirs.filter((d) => d.toLowerCase().includes(q));
+    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
+      skills: matchedSkills,
+      workflows: matchedWorkflows
     };
   }
 };
 
 // src/core/installer.ts
-import path3 from "path";
+import path5 from "path";
 import crypto from "crypto";
-import fs2 from "fs-extra";
+import fs3 from "fs-extra";
 
 // src/core/adapter.ts
-import path2 from "path";
+import path3 from "path";
 import os from "os";
-var TargetAdapter = class {
-  static resolveTargetDir(scope = "workspace", overrideDir) {
+
+// 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 path2.resolve(overrideDir);
+      return path3.resolve(overrideDir);
     }
+    if (!isKnownHost(host)) {
+      host = "agents";
+    }
+    const home = os.homedir();
+    const cwd = process.cwd();
     if (scope === "global") {
-      const home = os.homedir();
-      return path2.join(home, ".gemini", "config");
+      return resolveHostGlobalDir(host, home);
     }
-    return path2.resolve(process.cwd(), ".agents");
+    return resolveHostProjectDir(host, cwd);
   }
   static getSubPaths(targetDir) {
     return {
-      agentsDir: path2.join(targetDir, "agents"),
-      skillsDir: path2.join(targetDir, "skills"),
-      workflowsDir: path2.join(targetDir, "workflows"),
-      rulesDir: path2.join(targetDir, "rules"),
-      lockfile: path2.join(targetDir, "agents-united.json")
+      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.
+   */
+  static renderTeamManifest(bundle, scope) {
+    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 || [];
+    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 (.cline/rules/agents-united-<bundle>.md).
+   */
+  static renderCoordinatorRule(bundle, scope) {
+    const marker = `<!-- managed-by: agents-united | profile: cline | bundle: ${bundle.name} | do not edit -->`;
+    const manifestRelPath = scope === "global" ? `~/.cline/agents-united/teams/${bundle.name}.yaml` : `.cline/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 || [];
+    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.
+   */
+  static async planCompoundProjection(bundle, scope, resolved, registryDir) {
+    const artifacts = [];
+    const baseDir = scope === "global" ? ".cline" : ".cline";
+    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);
+    artifacts.push({
+      kind: "rule",
+      relPath: `${baseDir}/rules/agents-united-${bundle.name}.md`.replace(/\\/g, "/"),
+      content: ruleContent,
+      managedMarker: true
+    });
+    const manifestContent = this.renderTeamManifest(bundle, scope);
+    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"
+];
+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 {
+var InstallEngine = class _InstallEngine {
   registry;
   constructor(registry2) {
     this.registry = registry2 || new RegistryResolver();
   }
   async calculateHash(filePath) {
-    const buffer = await fs2.readFile(filePath);
+    const buffer = await fs3.readFile(filePath);
     return "sha256:" + crypto.createHash("sha256").update(buffer).digest("hex");
   }
   async readLockfile(lockfilePath) {
-    if (await fs2.pathExists(lockfilePath)) {
+    if (await fs3.pathExists(lockfilePath)) {
       try {
-        return await fs2.readJson(lockfilePath);
+        return await fs3.readJson(lockfilePath);
       } catch {
       }
     }
@@ -182,272 +775,2330 @@ var InstallEngine = class {
       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);
+    }
+  }
+  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 artifacts = await ClineProjector.planCompoundProjection(bundleDef, scope, resolved, registryDir);
+          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 owners = existingProj?.owners ? Array.from(/* @__PURE__ */ new Set([...existingProj.owners, bundleName])) : [bundleName];
+            lockfile.projections[artifact.relPath] = {
+              host: "cline",
+              kind: artifact.kind,
+              canonical: artifact.canonical,
+              owners,
+              hash: deployedHash,
+              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);
+            }
+          }
+          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 = options.global ? "global" : options.scope || "workspace";
-    const targetDir = TargetAdapter.resolveTargetDir(scope, options.targetDir);
-    const subPaths = TargetAdapter.getSubPaths(targetDir);
+    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) {
-      return { installed: resolved, targetDir, dryRun: true };
+      const projections2 = hasCanonicalAgents ? await this.buildProjections(fanoutHosts, resolved, registryDir, scope, options.targetDir) : [];
+      return { installed: resolved, targetDirs, dryRun: true, method, projections: projections2 };
     }
-    await fs2.ensureDir(subPaths.agentsDir);
-    await fs2.ensureDir(subPaths.skillsDir);
-    await fs2.ensureDir(subPaths.workflowsDir);
-    await fs2.ensureDir(subPaths.rulesDir);
-    const lockfile = await this.readLockfile(subPaths.lockfile);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    for (const agentFile of resolved.agents) {
-      const src = path3.join(registryDir, "agents", agentFile);
-      const dest = path3.join(subPaths.agentsDir, agentFile);
-      if (await fs2.pathExists(dest) && !options.force) {
-        const existingHash = await this.calculateHash(dest);
-        const relPath2 = path3.relative(targetDir, dest);
-        if (lockfile.files[relPath2] && lockfile.files[relPath2].hash !== existingHash) {
-          throw new Error(`File ${relPath2} has user modifications. Use --force to overwrite.`);
-        }
-      }
-      await fs2.copy(src, dest, { overwrite: true });
-      const hash = await this.calculateHash(dest);
-      const relPath = path3.relative(targetDir, dest);
-      lockfile.files[relPath] = {
-        hash,
-        bundle: resolved.targetBundle,
-        installedAt: now
-      };
-      if (!lockfile.installed.agents.includes(agentFile)) {
-        lockfile.installed.agents.push(agentFile);
+    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;
       }
-    }
-    for (const skillName of resolved.skills) {
-      const src = path3.join(registryDir, "skills", skillName);
-      const dest = path3.join(subPaths.skillsDir, skillName);
-      if (await fs2.pathExists(dest) && !options.force) {
-      }
-      await fs2.copy(src, dest, { overwrite: true });
-      const skillFile = path3.join(dest, "SKILL.md");
-      if (await fs2.pathExists(skillFile)) {
-        const hash = await this.calculateHash(skillFile);
-        const relPath = path3.relative(targetDir, skillFile);
+      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 = path5.relative(targetDir, dest);
+        const previousProjections = lockfile.files[relPath]?.projectedTo;
         lockfile.files[relPath] = {
           hash,
           bundle: resolved.targetBundle,
-          installedAt: now
+          method: actualMethod,
+          installedAt: now,
+          ...previousProjections ? { projectedTo: previousProjections } : {}
         };
+        if (!lockfile.installed.agents.includes(agentFile)) {
+          lockfile.installed.agents.push(agentFile);
+        }
       }
-      if (!lockfile.installed.skills.includes(skillName)) {
-        lockfile.installed.skills.push(skillName);
-      }
-    }
-    for (const workflowFile of resolved.workflows) {
-      const src = path3.join(registryDir, "workflows", workflowFile);
-      const dest = path3.join(subPaths.workflowsDir, workflowFile);
-      await fs2.copy(src, dest, { overwrite: true });
-      const hash = await this.calculateHash(dest);
-      const relPath = path3.relative(targetDir, dest);
-      lockfile.files[relPath] = {
-        hash,
-        bundle: resolved.targetBundle,
-        installedAt: now
-      };
-      if (!lockfile.installed.workflows.includes(workflowFile)) {
-        lockfile.installed.workflows.push(workflowFile);
+      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 = path5.relative(targetDir, path5.join(subPaths.skillsDir, skillName, "SKILL.md"));
+          const previousProjections = lockfile.files[relPath]?.projectedTo;
+          lockfile.files[relPath] = {
+            hash,
+            bundle: resolved.targetBundle,
+            method: actualMethod,
+            installedAt: now,
+            ...previousProjections ? { projectedTo: previousProjections } : {}
+          };
+        }
+        if (!lockfile.installed.skills.includes(skillName)) {
+          lockfile.installed.skills.push(skillName);
+        }
       }
-    }
-    for (const ruleFile of resolved.rules) {
-      const src = path3.join(registryDir, "rules", ruleFile);
-      const dest = path3.join(subPaths.rulesDir, ruleFile);
-      if (await fs2.pathExists(src)) {
-        await fs2.copy(src, dest, { overwrite: true });
-        const hash = await this.calculateHash(dest);
-        const relPath = path3.relative(targetDir, dest);
+      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 = path5.relative(targetDir, dest);
+        const previousProjections = lockfile.files[relPath]?.projectedTo;
         lockfile.files[relPath] = {
           hash,
           bundle: resolved.targetBundle,
-          installedAt: now
+          method: actualMethod,
+          installedAt: now,
+          ...previousProjections ? { projectedTo: previousProjections } : {}
         };
+        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 = path5.relative(targetDir, dest);
+          lockfile.files[relPath] = {
+            hash,
+            bundle: resolved.targetBundle,
+            method: actualMethod,
+            installedAt: now
+          };
+        }
+      }
+      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 });
     }
-    if (resolved.targetBundle && !lockfile.installed.bundles.includes(resolved.targetBundle)) {
-      lockfile.installed.bundles.push(resolved.targetBundle);
-    }
-    await fs2.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
-    return { installed: resolved, targetDir, dryRun: false };
+    return { installed: resolved, targetDirs, dryRun: false, method, projections };
   }
 };
 
 // src/core/uninstaller.ts
-import path4 from "path";
+import path6 from "path";
 import crypto2 from "crypto";
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 var UninstallEngine = class {
   registry;
   constructor(registry2) {
     this.registry = registry2 || new RegistryResolver();
   }
   async calculateHash(filePath) {
-    const buffer = await fs3.readFile(filePath);
+    const buffer = await fs4.readFile(filePath);
     return "sha256:" + crypto2.createHash("sha256").update(buffer).digest("hex");
   }
-  async uninstall(identifier, options = {}) {
-    const scope = options.global ? "global" : options.scope || "workspace";
-    const targetDir = TargetAdapter.resolveTargetDir(scope, options.targetDir);
-    const subPaths = TargetAdapter.getSubPaths(targetDir);
-    if (!await fs3.pathExists(subPaths.lockfile)) {
-      throw new Error(`No agents-united.json lockfile found in ${targetDir}. Nothing to uninstall.`);
+  /**
+   * 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");
     }
-    const lockfile = await fs3.readJson(subPaths.lockfile);
-    const resolved = await this.registry.resolve(identifier).catch(() => null);
-    const removedFiles = [];
-    if (resolved && resolved.targetBundle) {
-      const bundleName = resolved.targetBundle;
-      if (!lockfile.installed.bundles.includes(bundleName)) {
-        throw new Error(`Bundle "${bundleName}" is not currently installed.`);
-      }
-      if (options.dryRun) {
-        return { removed: resolved.agents.concat(resolved.skills, resolved.workflows), targetDir, dryRun: true };
-      }
-      for (const [relPath, assetMeta] of Object.entries(lockfile.files)) {
-        if (assetMeta.bundle === bundleName) {
-          const fullPath = path4.join(targetDir, relPath);
-          if (await fs3.pathExists(fullPath)) {
-            if (!options.force) {
-              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 fs3.remove(fullPath);
-            removedFiles.push(relPath);
-          }
-          delete lockfile.files[relPath];
-        }
-      }
-      lockfile.installed.bundles = lockfile.installed.bundles.filter((b) => b !== bundleName);
-      if (resolved.agents) {
-        lockfile.installed.agents = lockfile.installed.agents.filter((a) => !resolved.agents.includes(a));
+    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;
       }
-      if (resolved.skills) {
-        lockfile.installed.skills = lockfile.installed.skills.filter((s) => !resolved.skills.includes(s));
+      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;
       }
-      if (resolved.workflows) {
-        lockfile.installed.workflows = lockfile.installed.workflows.filter((w) => !resolved.workflows.includes(w));
+      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 fs3.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
-      return { removed: removedFiles, targetDir, dryRun: false };
+      await this.safeRemoveProjection(absProjection);
+      await this.removeEmptyProjectionDirs(workspaceRoot, projPath);
     }
-    const itemTargetRelPaths = Object.keys(lockfile.files).filter((p) => p.includes(identifier));
-    if (itemTargetRelPaths.length === 0) {
-      throw new Error(`No installed assets found matching "${identifier}".`);
+  }
+  async safeRemoveProjection(absPath) {
+    try {
+      const lstat = await fs4.lstat(absPath);
+      if (lstat.isSymbolicLink()) {
+        await fs4.unlink(absPath);
+        return;
+      }
+    } catch {
     }
-    if (options.dryRun) {
-      return { removed: itemTargetRelPaths, targetDir, dryRun: true };
+    await fs4.remove(absPath);
+  }
+  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;
     }
-    for (const relPath of itemTargetRelPaths) {
-      const fullPath = path4.join(targetDir, relPath);
-      if (await fs3.pathExists(fullPath)) {
-        if (!options.force) {
-          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.`);
+    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 {
         }
-        await fs3.remove(fullPath);
-        removedFiles.push(relPath);
       }
-      delete lockfile.files[relPath];
     }
-    await fs3.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
-    return { removed: removedFiles, targetDir, dryRun: false };
-  }
-};
-
-// src/core/doctor.ts
-import path5 from "path";
-import fs4 from "fs-extra";
-import parseYaml from "yaml";
-var DoctorEngine = class {
-  static async runDoctor(targetDir) {
-    const root = TargetAdapter.resolveTargetDir("workspace", targetDir);
-    const subPaths = TargetAdapter.getSubPaths(root);
-    const issues = [];
-    const warnings = [];
-    let agentsCount = 0;
-    let skillsCount = 0;
-    let workflowsCount = 0;
-    if (!await fs4.pathExists(subPaths.lockfile)) {
-      warnings.push(`No lockfile found at ${subPaths.lockfile}. Workspace might not be initialized.`);
-    } else {
-      try {
-        const manifest = await fs4.readJson(subPaths.lockfile);
-        agentsCount = manifest.installed.agents.length;
-        skillsCount = manifest.installed.skills.length;
-        workflowsCount = manifest.installed.workflows.length;
-      } catch (err) {
-        issues.push(`Corrupt lockfile at ${subPaths.lockfile}: ${err.message}`);
+    try {
+      const lstat = await fs4.lstat(fullPath);
+      if (lstat.isSymbolicLink()) {
+        await fs4.unlink(fullPath);
+        return;
       }
+    } catch {
     }
-    if (await fs4.pathExists(subPaths.agentsDir)) {
-      const agentFiles = await fs4.readdir(subPaths.agentsDir);
-      for (const file of agentFiles) {
-        if (file.endsWith(".md")) {
-          const content = await fs4.readFile(path5.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.`);
+    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));
+            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)) {
+              if (assetMeta.bundle === bundleName) {
+                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];
+              }
+            }
+            lockfile.installed.bundles = lockfile.installed.bundles.filter((b) => b !== bundleName);
+            if (lockfile.bundleVersions) {
+              delete lockfile.bundleVersions[bundleName];
+            }
+            if (resolved.agents) {
+              lockfile.installed.agents = lockfile.installed.agents.filter((a) => !resolved.agents.includes(a));
+            }
+            if (resolved.skills) {
+              lockfile.installed.skills = lockfile.installed.skills.filter((s) => !resolved.skills.includes(s));
+            }
+            if (resolved.workflows) {
+              lockfile.installed.workflows = lockfile.installed.workflows.filter((w) => !resolved.workflows.includes(w));
+            }
+            await fs4.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
           } else {
-            try {
-              const meta = parseYaml.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}`);
+            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);
     }
-    return {
-      valid: issues.length === 0,
-      issues,
-      warnings,
-      agentsCount,
-      skillsCount,
-      workflowsCount
-    };
+    if (totalRemoved.length === 0 && !options.dryRun) {
+      throw new Error(`No installed assets found matching "${identifier}".`);
+    }
+    return { removed: totalRemoved, targetDirs, dryRun: options.dryRun || false };
   }
 };
 
-// src/cli.ts
-var cli = cac("agents-united");
-var registry = new RegistryResolver();
+// 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}`);
+            }
+          }
+        }
+      }
+    }
+    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 = `.cline/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
+    } = 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" ? `~/.cline/agents-united/teams/${bundleName}.yaml` : `.cline/agents-united/teams/${bundleName}.yaml`;
+    const coordinatorCanonical = `.agents/agents/orchestrator-engineering.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 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,
+      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 path12 from "path";
+import os4 from "os";
+import fs10 from "fs-extra";
+var PrerequisiteChecker = class _PrerequisiteChecker {
+  /**
+   * 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 normName = mcpName.trim().toLowerCase();
+    const homeDir = os4.homedir();
+    const localCursor = [
+      path12.join(cwd, ".cursor", "mcp.json"),
+      path12.join(cwd, "cursor.mcp.json")
+    ];
+    for (const cand of localCursor) {
+      if (await fs10.pathExists(cand)) {
+        try {
+          const config = await fs10.readJson(cand);
+          const servers = config?.mcpServers || config?.servers || config;
+          if (servers && (servers[normName] || servers[mcpName])) {
+            return { configured: true, host: "cursor", location: cand };
+          }
+        } catch {
+        }
+      }
+    }
+    const localCline = [
+      path12.join(cwd, "cline_mcp_settings.json"),
+      path12.join(cwd, ".cline", "mcp.json")
+    ];
+    for (const cand of localCline) {
+      if (await fs10.pathExists(cand)) {
+        try {
+          const config = await fs10.readJson(cand);
+          const servers = config?.mcpServers || config?.servers || config;
+          if (servers && (servers[normName] || servers[mcpName])) {
+            return { configured: true, host: "cline", location: cand };
+          }
+        } catch {
+        }
+      }
+    }
+    const localClaude = [
+      path12.join(cwd, "claude.json"),
+      path12.join(cwd, ".claude", "mcp.json")
+    ];
+    for (const cand of localClaude) {
+      if (await fs10.pathExists(cand)) {
+        try {
+          const config = await fs10.readJson(cand);
+          const servers = config?.mcpServers || config?.servers || config;
+          if (servers && (servers[normName] || servers[mcpName])) {
+            return { configured: true, host: "claude", location: cand };
+          }
+        } catch {
+        }
+      }
+    }
+    const localGemini = [
+      path12.join(cwd, ".gemini", "antigravity", "mcp", normName),
+      path12.join(cwd, ".gemini", "antigravity", "mcp")
+    ];
+    for (const cand of localGemini) {
+      if (await fs10.pathExists(cand)) {
+        if (cand.endsWith(normName)) {
+          return { configured: true, host: "gemini", location: cand };
+        }
+        const entries = await fs10.readdir(cand).catch(() => []);
+        if (entries.some((e) => e.toLowerCase() === normName || e.toLowerCase().startsWith(`${normName}.`))) {
+          return { configured: true, host: "gemini", location: cand };
+        }
+      }
+    }
+    const globalGemini = [
+      path12.join(homeDir, ".gemini", "antigravity", "mcp", normName),
+      path12.join(homeDir, ".gemini", "antigravity", "mcp")
+    ];
+    for (const cand of globalGemini) {
+      if (await fs10.pathExists(cand)) {
+        if (cand.endsWith(normName)) {
+          return { configured: true, host: "gemini", location: cand };
+        }
+        const entries = await fs10.readdir(cand).catch(() => []);
+        if (entries.some((e) => e.toLowerCase() === normName || e.toLowerCase().startsWith(`${normName}.`))) {
+          return { configured: true, host: "gemini", location: cand };
+        }
+      }
+    }
+    const globalCursor = [path12.join(homeDir, ".cursor", "mcp.json")];
+    for (const cand of globalCursor) {
+      if (await fs10.pathExists(cand)) {
+        try {
+          const config = await fs10.readJson(cand);
+          const servers = config?.mcpServers || config?.servers || config;
+          if (servers && (servers[normName] || servers[mcpName])) {
+            return { configured: true, host: "cursor", location: cand };
+          }
+        } catch {
+        }
+      }
+    }
+    const globalCline = [path12.join(homeDir, "cline_mcp_settings.json")];
+    for (const cand of globalCline) {
+      if (await fs10.pathExists(cand)) {
+        try {
+          const config = await fs10.readJson(cand);
+          const servers = config?.mcpServers || config?.servers || config;
+          if (servers && (servers[normName] || servers[mcpName])) {
+            return { configured: true, host: "cline", location: cand };
+          }
+        } catch {
+        }
+      }
+    }
+    const globalClaude = [
+      path12.join(homeDir, "claude.json"),
+      path12.join(homeDir, ".claude", "mcp.json")
+    ];
+    for (const cand of globalClaude) {
+      if (await fs10.pathExists(cand)) {
+        try {
+          const config = await fs10.readJson(cand);
+          const servers = config?.mcpServers || config?.servers || config;
+          if (servers && (servers[normName] || servers[mcpName])) {
+            return { configured: true, host: "claude", location: cand };
+          }
+        } catch {
+        }
+      }
+    }
+    return { configured: false };
+  }
+  /**
+   * Checks if an npm package is installed in node_modules or declared in package.json
+   */
+  static async isPackageInstalled(pkgName, cwd = process.cwd()) {
+    const modulePath = path12.join(cwd, "node_modules", ...pkgName.split("/"));
+    if (await fs10.pathExists(modulePath)) {
+      return { installed: true, location: modulePath };
+    }
+    const pkgJsonPath = path12.join(cwd, "package.json");
+    if (await fs10.pathExists(pkgJsonPath)) {
+      try {
+        const pkg = await fs10.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 = [
+      path12.join(cwd, ".env.local"),
+      path12.join(cwd, ".env")
+    ];
+    for (const envFile of envFiles) {
+      if (await fs10.pathExists(envFile)) {
+        try {
+          const content = await fs10.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: path12.basename(envFile) };
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    return { set: false };
+  }
+  /**
+   * Evaluates all prerequisites declared on a bundle
+   */
+  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 items = [];
+    if (prereqs.requiredMcps && prereqs.requiredMcps.length > 0) {
+      for (const mcp of prereqs.requiredMcps) {
+        const check = await _PrerequisiteChecker.isMcpConfigured(mcp.name, cwd);
+        items.push({
+          type: "mcp",
+          name: mcp.name,
+          purpose: mcp.purpose,
+          satisfied: check.configured,
+          status: check.configured ? "ok" : "missing",
+          details: check.configured ? `Configured in ${check.host || "host"}` : "Not found in host MCP configuration",
+          optionalForBrainstorming: mcp.optionalForBrainstorming ?? true
+        });
+      }
+    }
+    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
+    };
+  }
+};
+
+// src/cli.ts
+var cli = cac("agents-united");
+var registry = new RegistryResolver();
 var installer = new InstallEngine(registry);
 var uninstaller = new UninstallEngine(registry);
-cli.command("add <identifier>", "Add a bundle, agent, skill, or workflow to workspace or global configuration").option("-g, --global", "Install globally to ~/.gemini/config/").option("-y, --yes", "Skip confirmation prompts").option("-f, --force", "Force overwrite user modified files").option("--dry-run", "Simulate installation without writing files").action(async (identifier, options) => {
-  intro(pc.cyan("Agents United - Add Package"));
+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) => fs11.pathExistsSync(path13.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-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-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";
+        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);
+    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: ${targetBundleDef.name} (${targetBundleDef.tier === "organization" ? "Organization Bundle" : "Prerequisites Required"})`
+      );
+      if (!prereqEval.allSatisfied) {
+        if (isInteractive) {
+          const gateChoice = await select({
+            message: pc.yellow(`Prerequisites not fully satisfied for "${targetBundleDef.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;
+          }
+          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");
+          }
+        } else {
+          if (options.mode === "brainstorming") {
+            executionMode = "brainstorming";
+          } else if (options.force || options.allowMissingPrereqs) {
+            executionMode = "operational";
+          } else {
+            const missingList = prereqEval.items.filter((i) => !i.satisfied).map((i) => `${i.type}:${i.name}`).join(", ");
+            outro(
+              pc.red(
+                `Error: Prerequisites not satisfied for "${targetBundleDef.name}".
+Missing items: ${missingList}
+
+To install in fallback mode: agents add ${identifier} --mode brainstorming
+To bypass prerequisite gate: agents add ${identifier} --allow-missing-prereqs`
+              )
+            );
+            process.exit(1);
+          }
+        }
+      }
+    }
+  }
   const s = spinner();
   s.start(`Resolving "${identifier}"...`);
   try {
     const result = await installer.install(identifier, {
-      global: options.global,
+      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.targetDir}`));
+      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 Directory: ${result.targetDir}`,
+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 plan = launcher.planActivation({
+              bundleName,
+              workspace: process.cwd(),
+              scope,
+              report: probeReport
+            });
+            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 plan = launcher.planActivation({
+              bundleName,
+              workspace: process.cwd(),
+              scope,
+              report: probeReport
+            });
+            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"
+      );
+    }
     outro(pc.green(`\u2714 Installed "${identifier}" successfully!`));
   } catch (err) {
     s.stop(pc.red("Failed resolution"));
@@ -455,20 +3106,67 @@ Target Directory: ${result.targetDir}`,
     process.exit(1);
   }
 });
-cli.command("remove <identifier>", "Remove a bundle, agent, skill, or workflow").alias("uninstall").option("-g, --global", "Uninstall from global ~/.gemini/config/").option("-y, --yes", "Skip confirmation prompts").option("-f, --force", "Force removal of modified files").option("--dry-run", "Simulate removal without unlinking files").action(async (identifier, options) => {
-  intro(pc.cyan("Agents United - Remove Package"));
+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.targetDir}`));
+      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}"`));
@@ -478,35 +3176,811 @@ cli.command("remove <identifier>", "Remove a bundle, agent, skill, or workflow")
     process.exit(1);
   }
 });
-cli.command("list", "List available and installed bundles").alias("ls").action(async () => {
-  intro(pc.cyan("Agents United - Available Bundles"));
-  const bundles = await registry.listBundles();
+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 fs11.readJson(path13.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.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) {
-    console.log(`  ${pc.bold(pc.green(b.name))}`);
-    console.log(`    ${pc.dim(b.description)}`);
-    console.log(`    ${pc.gray(`Orchestrator: ${b.orchestrator} | Skills: ${b.skills?.length || 0} | Workflows: ${b.workflows?.length || 0}`)}
+    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";
+      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-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.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;
+    }
   }
-  outro(pc.cyan('Run "npx agents-united add <bundle>" to install a bundle.'));
 });
-cli.command("find <query>", "Search for agents, skills, or bundles in the registry").alias("search").action(async (query) => {
-  intro(pc.cyan(`Agents United - Search: "${query}"`));
-  const results = await registry.find(query);
-  console.log(pc.bold("\nMatching Bundles:"));
-  results.bundles.forEach((b) => console.log(`  - ${pc.green(b.name)}: ${pc.dim(b.description)}`));
-  console.log(pc.bold("\nMatching Agents:"));
-  results.agents.forEach((a) => console.log(`  - ${pc.blue(a)}`));
-  console.log(pc.bold("\nMatching Skills:"));
-  results.skills.forEach((s) => console.log(`  - ${pc.yellow(s)}`));
-  outro(pc.cyan('\nUse "npx agents-united add <name>" to install any match.'));
+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 workspace .agents folder and install recommended bundle").option("-b, --bundle <bundle>", "Default bundle to install", { default: "software-engineering" }).action(async (options) => {
+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 .agents directory with bundle "${options.bundle}"...`);
+  s.start(`Initializing workspace with bundle "${options.bundle}"...`);
   try {
-    const result = await installer.install(options.bundle, { scope: "workspace" });
-    s.stop(`Initialized ${result.targetDir}`);
+    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"));
@@ -514,20 +3988,109 @@ cli.command("init", "Initialize workspace .agents folder and install recommended
     process.exit(1);
   }
 });
-cli.command("doctor", "Verify health of installed agents, frontmatter schemas, and hooks").action(async () => {
-  intro(pc.cyan("Agents United - Health Doctor"));
-  const report = await DoctorEngine.runDoctor();
-  console.log(`  Installed Agents: ${report.agentsCount}`);
-  console.log(`  Installed Skills: ${report.skillsCount}`);
-  console.log(`  Installed Workflows: ${report.workflowsCount}
+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 plan = launcher.planActivation({
+      bundleName: bundle,
+      workspace: resolution.workspace,
+      scope: resolution.scope,
+      report: probeReport,
+      prompt,
+      teamName: options.team,
+      allowAddons: options.allowAddons,
+      headless: options.headless
+    });
+    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 18 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("Issues Found:")));
+    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("Warnings:")));
+    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!"));
@@ -539,4 +4102,7 @@ cli.command("doctor", "Verify health of installed agents, frontmatter schemas, a
 cli.help();
 cli.version("1.0.0");
 cli.parse();
+export {
+  detectWorkspaceHosts
+};
 //# sourceMappingURL=cli.js.map