aigent-team 0.1.0 → 0.3.0

package/dist/cli.js

@@ -1,22 +1,27 @@
 #!/usr/bin/env node
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
+  GENERATE_SCOPES,
   PLATFORMS,
+  PLUGIN_BUNDLE_DIRS,
+  TEAM_ROLES,
   assembleReference,
+  assembleSkill,
   assembleSkillIndex,
   configExists,
   loadAgents,
   loadConfig
-} from "./chunk-N3RYHWTR.js";
+} from "./chunk-RH4B2QFX.js";
 
 // bin/cli.ts
 import { Command } from "commander";
+import chalk6 from "chalk";
 
 // src/cli/init.ts
-import { writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve3 } from "path";
+import { writeFileSync } from "fs";
+import { resolve as resolve2 } from "path";
 import inquirer from "inquirer";
-import chalk2 from "chalk";
+import chalk from "chalk";
 
 // src/detectors/platform-detector.ts
 import { execSync } from "child_process";
@@ -64,13 +69,132 @@ function detectPlatforms(cwd = process.cwd()) {
   return results;
 }
 
+// src/cli/init.ts
+async function runInit(cwd = process.cwd()) {
+  console.log(chalk.bold("\n\u{1F916} aigent-team init\n"));
+  if (configExists(cwd)) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: "aigent-team.config.json already exists. Overwrite?",
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      console.log(chalk.yellow("Aborted."));
+      return;
+    }
+  }
+  console.log(chalk.dim("Detecting installed AI tools..."));
+  const detections = detectPlatforms(cwd);
+  const detectedPlatforms = detections.filter((d) => d.detected);
+  if (detectedPlatforms.length > 0) {
+    console.log(chalk.green(`Found: ${detectedPlatforms.map((d) => d.platform).join(", ")}`));
+  } else {
+    console.log(chalk.dim("No AI tools detected. You can still select platforms manually."));
+  }
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Project name:",
+      default: cwd.split("/").pop()
+    },
+    {
+      type: "checkbox",
+      name: "platforms",
+      message: "Target platforms:",
+      choices: PLATFORMS.map((p) => ({
+        name: p,
+        checked: detections.find((d) => d.platform === p)?.detected ?? false
+      })),
+      validate: (input) => input.length > 0 || "Select at least one platform"
+    },
+    {
+      type: "checkbox",
+      name: "teams",
+      message: "Team agents to enable:",
+      choices: [
+        { name: "Lead (Tech Lead / Orchestrator)", value: "lead", checked: true },
+        { name: "BA (Business Analyst)", value: "ba", checked: true },
+        { name: "FE (Frontend)", value: "fe", checked: true },
+        { name: "BE (Backend)", value: "be", checked: true },
+        { name: "QA (Testing)", value: "qa", checked: true },
+        { name: "DevOps (Infrastructure)", value: "devops", checked: true }
+      ],
+      validate: (input) => input.length > 0 || "Select at least one team"
+    }
+  ]);
+  const config = {
+    projectName: answers.projectName,
+    platforms: answers.platforms,
+    teams: answers.teams
+  };
+  const configPath = resolve2(cwd, "aigent-team.config.json");
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  console.log(chalk.green(`
+\u2713 Created ${configPath}`));
+  console.log(chalk.bold.green("\n\u2705 aigent-team initialized successfully!\n"));
+  console.log(chalk.dim("Next steps:"));
+  console.log(chalk.dim("  - Review aigent-team.config.json and adjust if needed"));
+  console.log(chalk.dim("  - Run `aigent-team generate` to generate platform configs"));
+  console.log(chalk.dim("  - Use `aigent-team generate --scope agents,skills` to control what gets generated\n"));
+}
+
 // src/cli/generate.ts
-import { writeFileSync, mkdirSync, existsSync as existsSync2, readFileSync } from "fs";
-import { resolve as resolve2, dirname } from "path";
-import chalk from "chalk";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2, readFileSync } from "fs";
+import { resolve as resolve3, dirname } from "path";
+import inquirer2 from "inquirer";
+import chalk2 from "chalk";
 
 // src/compilers/base.compiler.ts
 var BaseCompiler = class {
+  /**
+   * Compile with scope filtering. Delegates to decomposed methods.
+   * 'all' = hub + agents + skills + references.
+   * 'plugin' is handled externally in generate.ts.
+   */
+  compileWithScope(agents, config, scopes) {
+    const normalized = /* @__PURE__ */ new Set();
+    for (const s of scopes) {
+      if (s === "all") {
+        normalized.add("hub");
+        normalized.add("agents");
+        normalized.add("skills");
+        normalized.add("references");
+      } else {
+        normalized.add(s);
+      }
+    }
+    const outputs = [];
+    if (normalized.has("agents")) {
+      outputs.push(...this.compileHubFile(agents, config));
+      outputs.push(...this.compileAgentIndexes(agents, config));
+    }
+    if (normalized.has("skills")) {
+      outputs.push(...this.compileAllSkills(agents));
+    }
+    if (normalized.has("references")) {
+      outputs.push(...this.compileAllReferences(agents));
+    }
+    return outputs;
+  }
+  /**
+   * Count files per artifact category from compiled outputs.
+   * Subclasses can override to customize category detection.
+   */
+  countArtifacts(outputs, rootDir) {
+    const counts = {};
+    const categories = ["rules", "skills", "agents", "kb", "ai"];
+    for (const cat of categories) {
+      const prefix = `${rootDir}/${cat}/`;
+      const count = outputs.filter((o) => o.filePath.startsWith(prefix)).length;
+      if (count > 0) counts[cat] = count;
+    }
+    return counts;
+  }
+  // ---- Shared helpers ----
   /**
    * Compile reference files for an agent into a given directory.
    * Returns CompiledOutput[] for each reference file.
@@ -83,6 +207,18 @@ var BaseCompiler = class {
       overwriteStrategy: "replace"
     }));
   }
+  /**
+   * Compile skill files for an agent into a given directory.
+   * Returns CompiledOutput[] for each skill file.
+   */
+  compileSkills(agent, baseDir, extension = ".md") {
+    if (!agent.skills?.length) return [];
+    return agent.skills.map((skill) => ({
+      filePath: `${baseDir}/${skill.id}${extension}`,
+      content: assembleSkill(skill) + "\n",
+      overwriteStrategy: "replace"
+    }));
+  }
   formatFrontmatter(data) {
     const lines = ["---"];
     for (const [key, value] of Object.entries(data)) {
@@ -105,6 +241,31 @@ var BaseCompiler = class {
 var ClaudeCodeCompiler = class extends BaseCompiler {
   platform = "claude-code";
   compile(agents, config) {
+    return this.compileWithScope(agents, config, ["all"]);
+  }
+  compileHubFile(agents, _config) {
+    const agentList = agents.map((a) => `- **${a.name}** (\`${a.id}\`): ${a.description.trim().split("\n")[0]}`).join("\n");
+    const claudeMd = [
+      `# CLAUDE.md`,
+      ``,
+      `This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.`,
+      ``,
+      `## Agent Team`,
+      ``,
+      `This project uses aigent-team. The following specialized agents are available:`,
+      ``,
+      agentList,
+      ``,
+      `Use the appropriate agent for your task by invoking it from the .claude/agents/ directory.`,
+      ``
+    ].join("\n");
+    return [{
+      filePath: "CLAUDE.md",
+      content: claudeMd,
+      overwriteStrategy: "skip-if-exists"
+    }];
+  }
+  compileAgentIndexes(agents, _config) {
     const outputs = [];
     for (const agent of agents) {
       const frontmatter = this.formatFrontmatter({
@@ -122,39 +283,101 @@ ${body}
         content,
         overwriteStrategy: "replace"
       });
-      const refs = this.compileReferences(
+    }
+    return outputs;
+  }
+  compileAllSkills(agents) {
+    const outputs = [];
+    for (const agent of agents) {
+      outputs.push(...this.compileSkills(
+        agent,
+        `.claude/agents/${agent.id}-agent/skills`
+      ));
+    }
+    return outputs;
+  }
+  compileAllReferences(agents) {
+    const outputs = [];
+    for (const agent of agents) {
+      outputs.push(...this.compileReferences(
         agent,
         `.claude/agents/${agent.id}-agent/references`
-      );
-      outputs.push(...refs);
+      ));
     }
+    return outputs;
+  }
+  compilePluginBundle(agents, config, rootDir) {
+    const outputs = [];
     const agentList = agents.map((a) => `- **${a.name}** (\`${a.id}\`): ${a.description.trim().split("\n")[0]}`).join("\n");
-    const claudeMd = [
-      `# CLAUDE.md`,
-      ``,
-      `This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.`,
-      ``,
-      `## Agent Team`,
-      ``,
-      `This project uses aigent-team. The following specialized agents are available:`,
-      ``,
-      agentList,
-      ``,
-      `Use the appropriate agent for your task by invoking it from the .claude/agents/ directory.`,
-      ``
-    ].join("\n");
     outputs.push({
-      filePath: "CLAUDE.md",
-      content: claudeMd,
-      overwriteStrategy: "skip-if-exists"
+      filePath: `${rootDir}/rules/CLAUDE.md`,
+      content: [
+        `# CLAUDE.md`,
+        ``,
+        `This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.`,
+        ``,
+        `## Agent Team`,
+        ``,
+        `This project uses aigent-team. The following specialized agents are available:`,
+        ``,
+        agentList,
+        ``,
+        `Use the appropriate agent for your task by invoking it from the agents/ directory.`,
+        ``
+      ].join("\n"),
+      overwriteStrategy: "replace"
     });
+    for (const agent of agents) {
+      const frontmatter = this.formatFrontmatter({
+        name: agent.name,
+        description: agent.description,
+        tools: agent.tools.allowed
+      });
+      const body = assembleSkillIndex(agent);
+      outputs.push({
+        filePath: `${rootDir}/agents/${agent.id}-agent.md`,
+        content: `${frontmatter}
+
+${body}
+`,
+        overwriteStrategy: "replace"
+      });
+    }
+    for (const agent of agents) {
+      if (!agent.skills?.length) continue;
+      for (const skill of agent.skills) {
+        outputs.push({
+          filePath: `${rootDir}/skills/${agent.id}/${skill.id}.md`,
+          content: assembleSkill(skill) + "\n",
+          overwriteStrategy: "replace"
+        });
+      }
+    }
+    for (const agent of agents) {
+      if (!agent.references?.length) continue;
+      for (const ref of agent.references) {
+        outputs.push({
+          filePath: `${rootDir}/kb/${agent.id}/${ref.id}.md`,
+          content: assembleReference(ref) + "\n",
+          overwriteStrategy: "replace"
+        });
+      }
+    }
+    const sharedKnowledge = agents.flatMap((a) => a.sharedKnowledge).filter((v, i, arr) => arr.indexOf(v) === i && v);
+    for (let i = 0; i < sharedKnowledge.length; i++) {
+      outputs.push({
+        filePath: `${rootDir}/kb/shared/knowledge-${i + 1}.md`,
+        content: sharedKnowledge[i] + "\n",
+        overwriteStrategy: "replace"
+      });
+    }
     return outputs;
   }
   validate(outputs) {
     const errors = [];
     const warnings = [];
     for (const output of outputs) {
-      if (output.filePath.includes("/references/")) continue;
+      if (output.filePath.includes("/references/") || output.filePath.includes("/skills/")) continue;
       const lineCount = output.content.split("\n").length;
       if (lineCount > 300) {
         warnings.push(
@@ -166,10 +389,38 @@ ${body}
   }
 };
 
+// src/compilers/cursor-ide-plugin.compiler.ts
+function toKebabCursorPluginId(projectName) {
+  const s = projectName.toLowerCase().replace(/[^a-z0-9.-]+/g, "-").replace(/^-+|-+$/g, "").replace(/\.{2,}/g, ".");
+  if (!s || !/^[a-z0-9]/.test(s)) {
+    return `aigent-team-${s || "pack"}`.replace(/^-+/, "");
+  }
+  return s;
+}
+
 // src/compilers/cursor.compiler.ts
 var CursorCompiler = class extends BaseCompiler {
   platform = "cursor";
   compile(agents, config) {
+    return this.compileWithScope(agents, config, ["all"]);
+  }
+  compileHubFile(agents, _config) {
+    const sharedKnowledge = agents.flatMap((a) => a.sharedKnowledge).filter((v, i, arr) => arr.indexOf(v) === i && v).join("\n\n---\n\n");
+    if (!sharedKnowledge) return [];
+    const frontmatter = this.formatFrontmatter({
+      description: "Shared project conventions and knowledge for all team agents",
+      alwaysApply: true
+    });
+    return [{
+      filePath: ".cursor/rules/shared-conventions.mdc",
+      content: `${frontmatter}
+
+${sharedKnowledge}
+`,
+      overwriteStrategy: "replace"
+    }];
+  }
+  compileAgentIndexes(agents, _config) {
     const outputs = [];
     for (const agent of agents) {
       const globs = agent.globs?.length ? agent.globs.join(", ") : void 0;
@@ -191,24 +442,74 @@ ${body}
         content,
         overwriteStrategy: "replace"
       });
-      if (agent.references?.length) {
-        for (const ref of agent.references) {
-          const refFrontmatter = this.formatFrontmatter({
-            description: `${agent.name} reference: ${ref.title}`,
-            alwaysApply: false,
-            globs: globs || void 0
-          });
-          outputs.push({
-            filePath: `.cursor/rules/${agent.id}-refs/${ref.id}.mdc`,
-            content: `${refFrontmatter}
+    }
+    return outputs;
+  }
+  compileAllSkills(agents) {
+    const outputs = [];
+    for (const agent of agents) {
+      if (!agent.skills?.length) continue;
+      const globs = agent.globs?.length ? agent.globs.join(", ") : void 0;
+      for (const skill of agent.skills) {
+        const skillFrontmatter = this.formatFrontmatter({
+          description: `${agent.name} skill: ${skill.name}`,
+          alwaysApply: false,
+          globs: globs || void 0
+        });
+        outputs.push({
+          filePath: `.cursor/rules/${agent.id}-skills/${skill.id}.mdc`,
+          content: `${skillFrontmatter}
+
+${skill.content}
+`,
+          overwriteStrategy: "replace"
+        });
+      }
+    }
+    return outputs;
+  }
+  compileAllReferences(agents) {
+    const outputs = [];
+    for (const agent of agents) {
+      if (!agent.references?.length) continue;
+      const globs = agent.globs?.length ? agent.globs.join(", ") : void 0;
+      for (const ref of agent.references) {
+        const refFrontmatter = this.formatFrontmatter({
+          description: `${agent.name} reference: ${ref.title}`,
+          alwaysApply: false,
+          globs: globs || void 0
+        });
+        outputs.push({
+          filePath: `.cursor/rules/${agent.id}-refs/${ref.id}.mdc`,
+          content: `${refFrontmatter}
 
 ${ref.content}
 `,
-            overwriteStrategy: "replace"
-          });
-        }
+          overwriteStrategy: "replace"
+        });
       }
     }
+    return outputs;
+  }
+  compilePluginBundle(agents, config, rootDir) {
+    const outputs = [];
+    const pluginId = toKebabCursorPluginId(config.projectName);
+    const firstLine = (text) => text.trim().split("\n")[0] ?? "";
+    outputs.push({
+      filePath: `${rootDir}/.cursor-plugin/plugin.json`,
+      content: JSON.stringify(
+        {
+          name: pluginId,
+          version: "0.1.0",
+          description: `Agent team pack for ${config.projectName} (generated by aigent-team)`,
+          keywords: ["aigent-team", "agents"],
+          author: { name: "aigent-team" }
+        },
+        null,
+        2
+      ) + "\n",
+      overwriteStrategy: "replace"
+    });
     const sharedKnowledge = agents.flatMap((a) => a.sharedKnowledge).filter((v, i, arr) => arr.indexOf(v) === i && v).join("\n\n---\n\n");
     if (sharedKnowledge) {
       const frontmatter = this.formatFrontmatter({
@@ -216,7 +517,7 @@ ${ref.content}
         alwaysApply: true
       });
       outputs.push({
-        filePath: ".cursor/rules/shared-conventions.mdc",
+        filePath: `${rootDir}/rules/shared-conventions.mdc`,
         content: `${frontmatter}
 
 ${sharedKnowledge}
@@ -224,6 +525,62 @@ ${sharedKnowledge}
         overwriteStrategy: "replace"
       });
     }
+    for (const agent of agents) {
+      const globs = agent.globs?.length ? agent.globs.join(", ") : void 0;
+      const frontmatterData = {
+        description: firstLine(agent.description),
+        alwaysApply: !globs
+      };
+      if (globs) frontmatterData.globs = globs;
+      const frontmatter = this.formatFrontmatter(frontmatterData);
+      const body = assembleSkillIndex(agent);
+      outputs.push({
+        filePath: `${rootDir}/agents/${agent.id}-agent.mdc`,
+        content: `${frontmatter}
+
+${body}
+`,
+        overwriteStrategy: "replace"
+      });
+    }
+    for (const agent of agents) {
+      if (!agent.skills?.length) continue;
+      for (const skill of agent.skills) {
+        const skillId = `${agent.id}-${skill.id}`;
+        const descSource = skill.description?.trim() || skill.name?.trim() || skill.trigger?.trim() || `Procedure for ${agent.name}`;
+        const skillFrontmatter = this.formatFrontmatter({
+          name: skillId,
+          description: firstLine(descSource)
+        });
+        outputs.push({
+          filePath: `${rootDir}/skills/${skillId}/SKILL.md`,
+          content: `${skillFrontmatter}
+
+${assembleSkill(skill)}
+`,
+          overwriteStrategy: "replace"
+        });
+      }
+    }
+    for (const agent of agents) {
+      if (!agent.references?.length) continue;
+      const globs = agent.globs?.length ? agent.globs.join(", ") : void 0;
+      for (const ref of agent.references) {
+        const refFrontmatter = this.formatFrontmatter({
+          description: `${agent.name} reference: ${ref.title}`,
+          alwaysApply: false,
+          globs: globs || void 0
+        });
+        outputs.push({
+          filePath: `${rootDir}/kb/${agent.id}-refs/${ref.id}.mdc`,
+          content: `${refFrontmatter}
+
+${assembleReference(ref)}
+`,
+          overwriteStrategy: "replace"
+        });
+      }
+    }
     return outputs;
   }
   validate(outputs) {
@@ -245,7 +602,9 @@ ${sharedKnowledge}
 var CodexCompiler = class extends BaseCompiler {
   platform = "codex";
   compile(agents, config) {
-    const outputs = [];
+    return this.compileWithScope(agents, config, ["all"]);
+  }
+  compileHubFile(agents, _config) {
     const sections = agents.map((agent) => {
       const body = assembleSkillIndex(agent);
       return `## ${agent.name} (${agent.id})
@@ -264,11 +623,14 @@ ${body}`;
 
 ${sharedKnowledge}` : ""
     ].filter(Boolean).join("\n\n");
-    outputs.push({
+    return [{
       filePath: "AGENTS.md",
       content: agentsMd + "\n",
       overwriteStrategy: "replace"
-    });
+    }];
+  }
+  compileAgentIndexes(agents, _config) {
+    const outputs = [];
     for (const agent of agents) {
       const frontmatter = this.formatFrontmatter({
         nickname_candidates: [agent.id, agent.role],
@@ -284,30 +646,107 @@ ${body}
         content,
         overwriteStrategy: "replace"
       });
-      const refs = this.compileReferences(
+    }
+    return outputs;
+  }
+  compileAllSkills(agents) {
+    const outputs = [];
+    for (const agent of agents) {
+      outputs.push(...this.compileSkills(
         agent,
-        `.codex/agents/${agent.id}-agent/references`
-      );
-      outputs.push(...refs);
+        `.codex/agents/${agent.id}-agent/skills`
+      ));
     }
     return outputs;
   }
-  validate(outputs) {
-    const errors = [];
-    const warnings = [];
-    const agentsMd = outputs.find((o) => o.filePath === "AGENTS.md");
-    if (!agentsMd) {
-      errors.push("AGENTS.md is missing from compiled output");
+  compileAllReferences(agents) {
+    const outputs = [];
+    for (const agent of agents) {
+      outputs.push(...this.compileReferences(
+        agent,
+        `.codex/agents/${agent.id}-agent/references`
+      ));
     }
-    return { valid: errors.length === 0, errors, warnings };
+    return outputs;
   }
-};
+  compilePluginBundle(agents, _config, rootDir) {
+    const outputs = [];
+    const sections = agents.map((agent) => {
+      const body = assembleSkillIndex(agent);
+      return `## ${agent.name} (${agent.id})
 
-// src/compilers/antigravity.compiler.ts
-var TOOL_MAP = {
-  Read: "read_file",
-  Write: "str_replace_editor",
-  Edit: "str_replace_editor",
+${body}`;
+    });
+    const sharedKnowledge = agents.flatMap((a) => a.sharedKnowledge).filter((v, i, arr) => arr.indexOf(v) === i && v).join("\n\n");
+    const agentsMd = [
+      `# Project Agents`,
+      ``,
+      `This project uses specialized AI agents for different team roles.`,
+      ``,
+      ...sections,
+      ``,
+      sharedKnowledge ? `## Shared Knowledge
+
+${sharedKnowledge}` : ""
+    ].filter(Boolean).join("\n\n");
+    outputs.push({
+      filePath: `${rootDir}/rules/AGENTS.md`,
+      content: agentsMd + "\n",
+      overwriteStrategy: "replace"
+    });
+    for (const agent of agents) {
+      const frontmatter = this.formatFrontmatter({
+        nickname_candidates: [agent.id, agent.role],
+        model: "inherit"
+      });
+      const body = assembleSkillIndex(agent);
+      outputs.push({
+        filePath: `${rootDir}/agents/${agent.id}-agent.md`,
+        content: `${frontmatter}
+
+${body}
+`,
+        overwriteStrategy: "replace"
+      });
+    }
+    for (const agent of agents) {
+      if (!agent.skills?.length) continue;
+      for (const skill of agent.skills) {
+        outputs.push({
+          filePath: `${rootDir}/skills/${agent.id}/${skill.id}.md`,
+          content: assembleSkill(skill) + "\n",
+          overwriteStrategy: "replace"
+        });
+      }
+    }
+    for (const agent of agents) {
+      if (!agent.references?.length) continue;
+      for (const ref of agent.references) {
+        outputs.push({
+          filePath: `${rootDir}/kb/${agent.id}/${ref.id}.md`,
+          content: assembleReference(ref) + "\n",
+          overwriteStrategy: "replace"
+        });
+      }
+    }
+    return outputs;
+  }
+  validate(outputs) {
+    const errors = [];
+    const warnings = [];
+    const agentsMd = outputs.find((o) => o.filePath === "AGENTS.md");
+    if (!agentsMd) {
+      errors.push("AGENTS.md is missing from compiled output");
+    }
+    return { valid: errors.length === 0, errors, warnings };
+  }
+};
+
+// src/compilers/antigravity.compiler.ts
+var TOOL_MAP = {
+  Read: "read_file",
+  Write: "str_replace_editor",
+  Edit: "str_replace_editor",
   Bash: "bash",
   Grep: "search",
   Glob: "list_dir"
@@ -315,7 +754,9 @@ var TOOL_MAP = {
 var AntigravityCompiler = class extends BaseCompiler {
   platform = "antigravity";
   compile(agents, config) {
-    const outputs = [];
+    return this.compileWithScope(agents, config, ["all"]);
+  }
+  compileHubFile(agents, _config) {
     const agentList = agents.map((a) => `- **${a.name}** (\`${a.id}\`): ${a.description.trim().split("\n")[0]}`).join("\n");
     const geminiMd = [
       `# Antigravity Configuration`,
@@ -328,11 +769,14 @@ var AntigravityCompiler = class extends BaseCompiler {
       `Use the appropriate agent skill for team-specific tasks.`,
       ``
     ].join("\n");
-    outputs.push({
+    return [{
       filePath: "GEMINI.md",
       content: geminiMd,
       overwriteStrategy: "replace"
-    });
+    }];
+  }
+  compileAgentIndexes(agents, _config) {
+    const outputs = [];
     for (const agent of agents) {
       const allowedTools = agent.tools.allowed.map((t) => TOOL_MAP[t] || t.toLowerCase()).filter((v, i, arr) => arr.indexOf(v) === i);
       const frontmatter = this.formatFrontmatter({
@@ -350,11 +794,91 @@ ${body}
         content,
         overwriteStrategy: "replace"
       });
-      const refs = this.compileReferences(
+    }
+    return outputs;
+  }
+  compileAllSkills(agents) {
+    const outputs = [];
+    for (const agent of agents) {
+      outputs.push(...this.compileSkills(
+        agent,
+        `.agents/skills/${agent.id}-agent/skills`
+      ));
+    }
+    return outputs;
+  }
+  compileAllReferences(agents) {
+    const outputs = [];
+    for (const agent of agents) {
+      outputs.push(...this.compileReferences(
         agent,
         `.agents/skills/${agent.id}-agent/references`
-      );
-      outputs.push(...refs);
+      ));
+    }
+    return outputs;
+  }
+  compilePluginBundle(agents, _config, rootDir) {
+    const outputs = [];
+    const agentList = agents.map((a) => `- **${a.name}** (\`${a.id}\`): ${a.description.trim().split("\n")[0]}`).join("\n");
+    outputs.push({
+      filePath: `${rootDir}/rules/GEMINI.md`,
+      content: [
+        `# Antigravity Configuration`,
+        ``,
+        `## Available Agents`,
+        ``,
+        agentList,
+        ``,
+        `Agents are defined in the agents/ directory.`,
+        `Use the appropriate agent for team-specific tasks.`,
+        ``
+      ].join("\n"),
+      overwriteStrategy: "replace"
+    });
+    for (const agent of agents) {
+      const allowedTools = agent.tools.allowed.map((t) => TOOL_MAP[t] || t.toLowerCase()).filter((v, i, arr) => arr.indexOf(v) === i);
+      const frontmatter = this.formatFrontmatter({
+        name: `${agent.id}-agent`,
+        description: agent.description.trim().split("\n")[0],
+        "allowed-tools": allowedTools
+      });
+      const body = assembleSkillIndex(agent);
+      outputs.push({
+        filePath: `${rootDir}/agents/${agent.id}-agent/SKILL.md`,
+        content: `${frontmatter}
+
+${body}
+`,
+        overwriteStrategy: "replace"
+      });
+    }
+    for (const agent of agents) {
+      if (!agent.skills?.length) continue;
+      for (const skill of agent.skills) {
+        outputs.push({
+          filePath: `${rootDir}/skills/${agent.id}/${skill.id}.md`,
+          content: assembleSkill(skill) + "\n",
+          overwriteStrategy: "replace"
+        });
+      }
+    }
+    for (const agent of agents) {
+      if (!agent.references?.length) continue;
+      for (const ref of agent.references) {
+        outputs.push({
+          filePath: `${rootDir}/kb/${agent.id}/${ref.id}.md`,
+          content: assembleReference(ref) + "\n",
+          overwriteStrategy: "replace"
+        });
+      }
+    }
+    const sharedKnowledge = agents.flatMap((a) => a.sharedKnowledge).filter((v, i, arr) => arr.indexOf(v) === i && v);
+    for (let i = 0; i < sharedKnowledge.length; i++) {
+      outputs.push({
+        filePath: `${rootDir}/kb/shared/knowledge-${i + 1}.md`,
+        content: sharedKnowledge[i] + "\n",
+        overwriteStrategy: "replace"
+      });
     }
     return outputs;
   }
@@ -383,13 +907,66 @@ var compilers = {
   codex: () => new CodexCompiler(),
   antigravity: () => new AntigravityCompiler()
 };
+function getCompiler(platform) {
+  return compilers[platform]();
+}
 function getAllCompilers(platforms) {
   return platforms.map((p) => compilers[p]());
 }
 
+// src/compilers/plugin.compiler.ts
+var PluginCompiler = class {
+  compilePlugin(agents, config, pluginDir = ".aigent-team-plugin") {
+    const outputs = [];
+    const bundles = [];
+    for (const platform of config.platforms) {
+      const bundleDir = PLUGIN_BUNDLE_DIRS[platform];
+      const rootDir = `${pluginDir}/${bundleDir}`;
+      const compiler = getCompiler(platform);
+      const bundleOutputs = compiler.compilePluginBundle(agents, config, rootDir);
+      outputs.push(...bundleOutputs);
+      bundles.push({
+        platform,
+        directory: bundleDir,
+        artifacts: compiler.countArtifacts(bundleOutputs, rootDir)
+      });
+    }
+    const agentsMeta = agents.map((a) => ({
+      id: a.id,
+      name: a.name,
+      description: a.description,
+      role: a.role,
+      tools: { allowed: [...a.tools.allowed], ...a.tools.denied ? { denied: [...a.tools.denied] } : {} },
+      ...a.globs?.length ? { globs: [...a.globs] } : {}
+    }));
+    const manifest = {
+      name: config.projectName,
+      version: "0.1.0",
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      generator: "aigent-team",
+      projectName: config.projectName,
+      roles: [...config.teams],
+      platforms: [...config.platforms],
+      agents: agentsMeta,
+      files: {
+        agents: agents.length,
+        skills: agents.reduce((sum, a) => sum + a.skills.length, 0),
+        references: agents.reduce((sum, a) => sum + a.references.length, 0)
+      },
+      bundles
+    };
+    outputs.push({
+      filePath: `${pluginDir}/manifest.json`,
+      content: JSON.stringify(manifest, null, 2) + "\n",
+      overwriteStrategy: "replace"
+    });
+    return outputs;
+  }
+};
+
 // src/cli/generate.ts
 function writeOutput(output, cwd) {
-  const fullPath = resolve2(cwd, output.filePath);
+  const fullPath = resolve3(cwd, output.filePath);
   const dir = dirname(fullPath);
   if (output.overwriteStrategy === "skip-if-exists" && existsSync2(fullPath)) {
     return false;
@@ -397,129 +974,129 @@ function writeOutput(output, cwd) {
   if (output.overwriteStrategy === "merge" && existsSync2(fullPath)) {
     const existing = readFileSync(fullPath, "utf-8");
     if (!existing.includes("## Agent Team")) {
-      writeFileSync(fullPath, existing + "\n" + output.content);
+      writeFileSync2(fullPath, existing + "\n" + output.content);
       return true;
     }
     return false;
   }
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(fullPath, output.content);
+  mkdirSync2(dir, { recursive: true });
+  writeFileSync2(fullPath, output.content);
   return true;
 }
+function writeOutputs(outputs, cwd, label) {
+  let written = 0;
+  for (const output of outputs) {
+    if (writeOutput(output, cwd)) {
+      written++;
+      console.log(chalk2.dim(`  ${output.filePath}`));
+    }
+  }
+  console.log(chalk2.green(`\u2713 ${label}: ${written} file(s) generated`));
+  return written;
+}
+async function promptGenerateOptions(configTeams, configPlatforms) {
+  const { mode } = await inquirer2.prompt([
+    {
+      type: "list",
+      name: "mode",
+      message: "Generate mode:",
+      choices: [
+        { name: "Platform configs (agents, skills, references)", value: "platform" },
+        { name: "Plugin bundle", value: "plugin" }
+      ]
+    }
+  ]);
+  if (mode === "plugin") {
+    return { scopes: ["plugin"] };
+  }
+  const answers = await inquirer2.prompt([
+    {
+      type: "checkbox",
+      name: "scopes",
+      message: "What to generate:",
+      choices: [
+        { name: "Agents", value: "agents", checked: true },
+        { name: "Skills", value: "skills", checked: true },
+        { name: "References", value: "references", checked: true }
+      ]
+    },
+    {
+      type: "checkbox",
+      name: "teams",
+      message: "Team agents:",
+      choices: TEAM_ROLES.map((role) => ({
+        name: role,
+        value: role,
+        checked: configTeams.includes(role)
+      })),
+      validate: (input) => input.length > 0 || "Select at least one team"
+    },
+    {
+      type: "checkbox",
+      name: "platforms",
+      message: "Target platforms:",
+      choices: PLATFORMS.map((p) => ({
+        name: p,
+        value: p,
+        checked: configPlatforms.includes(p)
+      })),
+      validate: (input) => input.length > 0 || "Select at least one platform"
+    }
+  ]);
+  const scopes = answers.scopes.length > 0 ? answers.scopes : ["all"];
+  return {
+    scopes,
+    teams: answers.teams,
+    platforms: answers.platforms
+  };
+}
 async function runGenerate(cwd = process.cwd(), options = {}) {
   const config = await loadConfig(cwd);
-  const agents = loadAgents(config, cwd);
-  const platforms = options.platform ? [options.platform] : config.platforms;
+  const hasFlags = options.platform || options.platforms || options.teams || options.scopes && !(options.scopes.length === 1 && options.scopes[0] === "all");
+  if (!hasFlags && process.stdin.isTTY) {
+    const prompted = await promptGenerateOptions(config.teams, config.platforms);
+    options = { ...options, ...prompted };
+  }
+  const effectiveConfig = options.teams ? { ...config, teams: options.teams } : config;
+  const agents = loadAgents(effectiveConfig, cwd);
+  const scopes = options.scopes ?? ["all"];
+  if (scopes.includes("plugin")) {
+    const pluginDir = effectiveConfig.output?.pluginDir ?? ".aigent-team-plugin";
+    const pluginCompiler = new PluginCompiler();
+    const outputs = pluginCompiler.compilePlugin(agents, effectiveConfig, pluginDir);
+    const written = writeOutputs(outputs, cwd, "plugin");
+    console.log(chalk2.bold(`
+Total: ${written} file(s) generated`));
+    return;
+  }
+  const platforms = options.platform ? [options.platform] : options.platforms ?? effectiveConfig.platforms;
   const compilers2 = getAllCompilers(platforms);
   let totalFiles = 0;
   let totalWarnings = 0;
   for (const compiler of compilers2) {
-    const outputs = compiler.compile(agents, config);
+    const outputs = compiler.compileWithScope(agents, effectiveConfig, scopes);
     const validation = compiler.validate(outputs);
     if (!validation.valid) {
-      console.log(chalk.red(`
+      console.log(chalk2.red(`
 \u2717 ${compiler.platform} validation errors:`));
       for (const error of validation.errors) {
-        console.log(chalk.red(`  - ${error}`));
+        console.log(chalk2.red(`  - ${error}`));
       }
       continue;
     }
     for (const warning of validation.warnings) {
-      console.log(chalk.yellow(`  \u26A0 ${warning}`));
+      console.log(chalk2.yellow(`  \u26A0 ${warning}`));
       totalWarnings++;
     }
-    let written = 0;
-    for (const output of outputs) {
-      if (writeOutput(output, cwd)) {
-        written++;
-        console.log(chalk.dim(`  ${output.filePath}`));
-      }
-    }
-    console.log(chalk.green(`\u2713 ${compiler.platform}: ${written} file(s) generated`));
-    totalFiles += written;
+    totalFiles += writeOutputs(outputs, cwd, compiler.platform);
   }
-  console.log(chalk.bold(`
+  console.log(chalk2.bold(`
 Total: ${totalFiles} file(s) generated`));
   if (totalWarnings > 0) {
-    console.log(chalk.yellow(`${totalWarnings} warning(s)`));
+    console.log(chalk2.yellow(`${totalWarnings} warning(s)`));
   }
 }
 
-// src/cli/init.ts
-async function runInit(cwd = process.cwd()) {
-  console.log(chalk2.bold("\n\u{1F916} aigent-team init\n"));
-  if (configExists(cwd)) {
-    const { overwrite } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "overwrite",
-        message: "aigent-team.config.json already exists. Overwrite?",
-        default: false
-      }
-    ]);
-    if (!overwrite) {
-      console.log(chalk2.yellow("Aborted."));
-      return;
-    }
-  }
-  console.log(chalk2.dim("Detecting installed AI tools..."));
-  const detections = detectPlatforms(cwd);
-  const detectedPlatforms = detections.filter((d) => d.detected);
-  if (detectedPlatforms.length > 0) {
-    console.log(chalk2.green(`Found: ${detectedPlatforms.map((d) => d.platform).join(", ")}`));
-  } else {
-    console.log(chalk2.dim("No AI tools detected. You can still select platforms manually."));
-  }
-  const answers = await inquirer.prompt([
-    {
-      type: "input",
-      name: "projectName",
-      message: "Project name:",
-      default: cwd.split("/").pop()
-    },
-    {
-      type: "checkbox",
-      name: "platforms",
-      message: "Target platforms:",
-      choices: PLATFORMS.map((p) => ({
-        name: p,
-        checked: detections.find((d) => d.platform === p)?.detected ?? false
-      })),
-      validate: (input) => input.length > 0 || "Select at least one platform"
-    },
-    {
-      type: "checkbox",
-      name: "teams",
-      message: "Team agents to enable:",
-      choices: [
-        { name: "Lead (Tech Lead / Orchestrator)", value: "lead", checked: true },
-        { name: "BA (Business Analyst)", value: "ba", checked: true },
-        { name: "FE (Frontend)", value: "fe", checked: true },
-        { name: "BE (Backend)", value: "be", checked: true },
-        { name: "QA (Testing)", value: "qa", checked: true },
-        { name: "DevOps (Infrastructure)", value: "devops", checked: true }
-      ],
-      validate: (input) => input.length > 0 || "Select at least one team"
-    }
-  ]);
-  const config = {
-    projectName: answers.projectName,
-    platforms: answers.platforms,
-    teams: answers.teams
-  };
-  const configPath = resolve3(cwd, "aigent-team.config.json");
-  writeFileSync2(configPath, JSON.stringify(config, null, 2) + "\n");
-  console.log(chalk2.green(`
-\u2713 Created ${configPath}`));
-  console.log(chalk2.dim("\nGenerating platform configs..."));
-  await runGenerate(cwd);
-  console.log(chalk2.bold.green("\n\u2705 aigent-team initialized successfully!\n"));
-  console.log(chalk2.dim("Next steps:"));
-  console.log(chalk2.dim("  - Edit aigent-team.config.json to customize agents"));
-  console.log(chalk2.dim("  - Run `aigent-team generate` after making changes"));
-  console.log(chalk2.dim("  - Add .aigent-team/teams/<role>/ for local overrides\n"));
-}
-
 // src/cli/validate.ts
 import { existsSync as existsSync3 } from "fs";
 import { resolve as resolve4 } from "path";
@@ -559,18 +1136,358 @@ async function runValidate(cwd = process.cwd()) {
   }
 }
 
+// src/cli/install.ts
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync5, readFileSync as readFileSync4, cpSync, rmSync } from "fs";
+import { homedir } from "os";
+import { resolve as resolve6, dirname as dirname2, join } from "path";
+import chalk4 from "chalk";
+
+// src/core/plugin-loader.ts
+import { readFileSync as readFileSync3, existsSync as existsSync4, readdirSync } from "fs";
+import { resolve as resolve5, basename } from "path";
+function loadPlugin(pluginPath) {
+  const absPath = resolve5(pluginPath);
+  const manifestPath = resolve5(absPath, "manifest.json");
+  if (!existsSync4(manifestPath)) {
+    throw new Error(`Plugin manifest not found: ${manifestPath}`);
+  }
+  const manifest = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+  if (!manifest.agents?.length) {
+    throw new Error("Plugin manifest has no agents metadata. Was it generated with aigent-team >= 0.3.0?");
+  }
+  const bundleDir = findBundleDir(absPath, manifest);
+  const agents = [];
+  for (const meta of manifest.agents) {
+    const agentFilePath = resolve5(bundleDir, "agents", `${meta.id}-agent.md`);
+    if (!existsSync4(agentFilePath)) {
+      throw new Error(`Agent file not found: ${agentFilePath}`);
+    }
+    const skillContent = readFileSync3(agentFilePath, "utf-8").trim();
+    const skills = loadSkillFiles(resolve5(bundleDir, "skills", meta.id));
+    const references = loadReferenceFiles(resolve5(bundleDir, "kb", meta.id));
+    const sharedKnowledge = loadSharedKnowledge(resolve5(bundleDir, "kb", "shared"));
+    agents.push({
+      id: meta.id,
+      name: meta.name,
+      description: meta.description,
+      role: meta.role,
+      tools: meta.tools,
+      globs: meta.globs,
+      // The skillContent already contains the assembled index (rules + skill content + catalog).
+      // Set it as skillContent and leave rulesContent/skills empty so assembleSkillIndex()
+      // returns it as-is without double-including rules or catalog.
+      skillContent,
+      rulesContent: "",
+      skills,
+      references,
+      sharedKnowledge,
+      // Unused during install — compilers only need the fields above
+      systemPrompt: "",
+      techStack: { languages: [], frameworks: [], libraries: [], buildTools: [] },
+      conventions: "",
+      reviewChecklist: "",
+      workflows: []
+    });
+  }
+  return { manifest, agents };
+}
+function findBundleDir(absPath, manifest) {
+  const preferred = ["claude-code-plugin", "cursor-ide-plugin", "codex-plugin", "antigravity-plugin"];
+  for (const dir of preferred) {
+    const candidate = resolve5(absPath, dir);
+    if (existsSync4(candidate)) return candidate;
+  }
+  for (const bundle of manifest.bundles ?? []) {
+    const candidate = resolve5(absPath, bundle.directory);
+    if (existsSync4(candidate)) return candidate;
+  }
+  throw new Error(`No platform bundle found in plugin: ${absPath}`);
+}
+function loadSkillFiles(dir) {
+  if (!existsSync4(dir)) return [];
+  return readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => {
+    const id = basename(f, ".md");
+    const content = readFileSync3(resolve5(dir, f), "utf-8").trim();
+    return {
+      id,
+      name: id.replace(/-/g, " "),
+      description: "",
+      trigger: "",
+      content
+    };
+  });
+}
+function loadReferenceFiles(dir) {
+  if (!existsSync4(dir)) return [];
+  return readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => {
+    const id = basename(f, ".md");
+    const content = readFileSync3(resolve5(dir, f), "utf-8").trim();
+    return {
+      id,
+      title: id.replace(/-/g, " "),
+      description: "",
+      whenToRead: "",
+      content
+    };
+  });
+}
+function loadSharedKnowledge(dir) {
+  if (!existsSync4(dir)) return [];
+  return readdirSync(dir).filter((f) => f.endsWith(".md")).sort().map((f) => readFileSync3(resolve5(dir, f), "utf-8").trim()).filter(Boolean);
+}
+
+// src/cli/install.ts
+function readCursorPluginId(cursorIdePluginRoot) {
+  const manifestPath = resolve6(cursorIdePluginRoot, ".cursor-plugin", "plugin.json");
+  if (!existsSync5(manifestPath)) {
+    throw new Error(`Missing ${manifestPath}`);
+  }
+  const raw = JSON.parse(readFileSync4(manifestPath, "utf-8"));
+  if (!raw.name || typeof raw.name !== "string") {
+    throw new Error(`Invalid Cursor plugin manifest: missing "name" in ${manifestPath}`);
+  }
+  return raw.name;
+}
+function installCursorUserPlugin(cursorIdePluginSource, force) {
+  const pluginId = readCursorPluginId(cursorIdePluginSource);
+  const localRoot = join(homedir(), ".cursor", "plugins", "local");
+  const dest = join(localRoot, pluginId);
+  if (existsSync5(dest) && !force) {
+    throw new Error(
+      `Cursor user plugin already exists: ${dest}
+Use --force to replace, or remove that folder first.`
+    );
+  }
+  mkdirSync3(localRoot, { recursive: true });
+  if (existsSync5(dest)) {
+    rmSync(dest, { recursive: true, force: true });
+  }
+  cpSync(cursorIdePluginSource, dest, { recursive: true });
+  return dest;
+}
+function writeInstallOutput(output, cwd, force) {
+  const fullPath = resolve6(cwd, output.filePath);
+  const dir = dirname2(fullPath);
+  if (!force && existsSync5(fullPath)) {
+    return false;
+  }
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync3(fullPath, output.content);
+  return true;
+}
+async function runInstall(pluginPath, cwd = process.cwd(), options = {}) {
+  const absPluginPath = resolve6(cwd, pluginPath);
+  console.log(chalk4.dim(`Loading plugin from ${absPluginPath}...`));
+  const { manifest, agents } = loadPlugin(absPluginPath);
+  console.log(chalk4.bold(`Plugin: ${manifest.name} v${manifest.version}`));
+  console.log(chalk4.dim(`  ${manifest.agents.length} agent(s), ${manifest.files.skills} skill(s), ${manifest.files.references} reference(s)`));
+  let platforms;
+  if (options.platform) {
+    platforms = [options.platform];
+  } else if (configExists(cwd)) {
+    const config2 = await loadConfig(cwd);
+    platforms = config2.platforms;
+  } else {
+    platforms = manifest.platforms;
+  }
+  const config = configExists(cwd) ? await loadConfig(cwd) : {
+    projectName: manifest.projectName,
+    platforms,
+    teams: manifest.roles
+  };
+  const compilers2 = getAllCompilers(platforms);
+  const allWrittenFiles = [];
+  let totalFiles = 0;
+  let skipped = 0;
+  for (const compiler of compilers2) {
+    if (options.cursorUserPlugin && compiler.platform === "cursor") {
+      continue;
+    }
+    const outputs = compiler.compileWithScope(agents, config, ["all"]);
+    const validation = compiler.validate(outputs);
+    if (!validation.valid) {
+      console.log(chalk4.red(`
+\u2717 ${compiler.platform} validation errors:`));
+      for (const error of validation.errors) {
+        console.log(chalk4.red(`  - ${error}`));
+      }
+      continue;
+    }
+    for (const warning of validation.warnings) {
+      console.log(chalk4.yellow(`  \u26A0 ${warning}`));
+    }
+    let written = 0;
+    for (const output of outputs) {
+      if (writeInstallOutput(output, cwd, !!options.force)) {
+        written++;
+        allWrittenFiles.push(output.filePath);
+        console.log(chalk4.dim(`  ${output.filePath}`));
+      } else {
+        skipped++;
+      }
+    }
+    console.log(chalk4.green(`\u2713 ${compiler.platform}: ${written} file(s) installed`));
+    totalFiles += written;
+  }
+  let cursorUserPluginPath;
+  const cursorIdeBundle = resolve6(absPluginPath, "cursor-ide-plugin");
+  const shouldInstallCursorUser = !!options.cursorUserPlugin && (!options.platform || options.platform === "cursor") && platforms.includes("cursor");
+  if (shouldInstallCursorUser) {
+    if (!existsSync5(cursorIdeBundle)) {
+      console.log(
+        chalk4.red(
+          `
+\u2717 cursor-ide-plugin/ not found under ${absPluginPath}.
+  Run: npx aigent-team generate --scope plugin`
+        )
+      );
+    } else {
+      try {
+        cursorUserPluginPath = installCursorUserPlugin(cursorIdeBundle, !!options.force);
+        console.log(chalk4.green(`\u2713 cursor (user plugin): ${cursorUserPluginPath}`));
+      } catch (e) {
+        console.log(chalk4.red(`
+\u2717 Cursor user plugin install failed: ${e.message}`));
+      }
+    }
+  }
+  const recordDir = resolve6(cwd, ".aigent-team", "installed");
+  mkdirSync3(recordDir, { recursive: true });
+  const record = {
+    name: manifest.name,
+    version: manifest.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pluginPath: absPluginPath,
+    files: allWrittenFiles,
+    ...cursorUserPluginPath ? { cursorUserPluginPath } : {}
+  };
+  writeFileSync3(
+    resolve6(recordDir, `${manifest.name}.json`),
+    JSON.stringify(record, null, 2) + "\n"
+  );
+  console.log(chalk4.bold(`
+Total: ${totalFiles} file(s) installed`));
+  if (skipped > 0) {
+    console.log(chalk4.yellow(`${skipped} file(s) skipped (already exist, use --force to overwrite)`));
+  }
+}
+
+// src/cli/uninstall.ts
+import { unlinkSync, existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync2, rmdirSync, rmSync as rmSync2 } from "fs";
+import { resolve as resolve7, dirname as dirname3 } from "path";
+import chalk5 from "chalk";
+async function runUninstall(pluginName, cwd = process.cwd()) {
+  const recordPath = resolve7(cwd, ".aigent-team", "installed", `${pluginName}.json`);
+  if (!existsSync6(recordPath)) {
+    const installedDir = resolve7(cwd, ".aigent-team", "installed");
+    if (existsSync6(installedDir)) {
+      const installed = readdirSync2(installedDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+      if (installed.length > 0) {
+        console.log(chalk5.red(`Plugin "${pluginName}" is not installed.`));
+        console.log(chalk5.dim(`Installed plugins: ${installed.join(", ")}`));
+        return;
+      }
+    }
+    console.log(chalk5.red(`No installed plugins found.`));
+    return;
+  }
+  const record = JSON.parse(readFileSync5(recordPath, "utf-8"));
+  console.log(chalk5.bold(`Uninstalling: ${record.name} v${record.version}`));
+  if (record.cursorUserPluginPath && existsSync6(record.cursorUserPluginPath)) {
+    rmSync2(record.cursorUserPluginPath, { recursive: true, force: true });
+    console.log(chalk5.dim(`  \u2717 ${record.cursorUserPluginPath} (Cursor user plugin)`));
+  }
+  let removed = 0;
+  let missing = 0;
+  for (const filePath of record.files) {
+    const fullPath = resolve7(cwd, filePath);
+    if (existsSync6(fullPath)) {
+      unlinkSync(fullPath);
+      removed++;
+      console.log(chalk5.dim(`  \u2717 ${filePath}`));
+      tryRemoveEmptyDir(dirname3(fullPath));
+    } else {
+      missing++;
+    }
+  }
+  unlinkSync(recordPath);
+  console.log(chalk5.bold(`
+Removed: ${removed} file(s)`));
+  if (missing > 0) {
+    console.log(chalk5.yellow(`${missing} file(s) already missing`));
+  }
+}
+function tryRemoveEmptyDir(dir) {
+  try {
+    const entries = readdirSync2(dir);
+    if (entries.length === 0) {
+      rmdirSync(dir);
+      tryRemoveEmptyDir(dirname3(dir));
+    }
+  } catch {
+  }
+}
+
 // bin/cli.ts
 var program = new Command();
-program.name("aigent-team").description("Cross-platform AI agent team plugin for Claude Code, Cursor, Codex, and Antigravity").version("0.1.0");
+program.name("aigent-team").description("Cross-platform AI agent team plugin for Claude Code, Cursor, Codex, and Antigravity").version("0.2.0");
 program.command("init").description("Initialize aigent-team in your project (interactive)").action(async () => {
   await runInit(process.cwd());
 });
-program.command("generate").description("Generate platform-specific config files from aigent-team config").option("-p, --platform <platform>", "Generate for a specific platform only").action(async (options) => {
+program.command("generate").description("Generate platform-specific config files from aigent-team config").option("-p, --platform <platform>", "Generate for a specific platform only").option("-s, --scope <scopes>", "Output scope(s), comma-separated: all | agents | skills | references | plugin", "all").option("-t, --team <teams>", "Team roles to generate, comma-separated (overrides config)").action(async (options) => {
+  if (options.platform && !PLATFORMS.includes(options.platform)) {
+    console.log(chalk6.red(`Unknown platform: ${options.platform}. Valid: ${PLATFORMS.join(", ")}`));
+    process.exit(1);
+  }
+  const scopes = options.scope.split(",");
+  for (const s of scopes) {
+    if (!GENERATE_SCOPES.includes(s)) {
+      console.log(chalk6.red(`Unknown scope: ${s}. Valid: ${GENERATE_SCOPES.join(", ")}`));
+      process.exit(1);
+    }
+  }
+  if (scopes.includes("plugin") && scopes.length > 1) {
+    console.log(chalk6.red(`Scope 'plugin' is exclusive and cannot be combined with other scopes.`));
+    process.exit(1);
+  }
+  if (scopes.includes("all") && scopes.length > 1) {
+    console.log(chalk6.red(`Scope 'all' is exclusive and cannot be combined with other scopes.`));
+    process.exit(1);
+  }
+  let teams;
+  if (options.team) {
+    teams = options.team.split(",");
+    for (const t of teams) {
+      if (!TEAM_ROLES.includes(t)) {
+        console.log(chalk6.red(`Unknown team role: ${t}. Valid: ${TEAM_ROLES.join(", ")}`));
+        process.exit(1);
+      }
+    }
+  }
   await runGenerate(process.cwd(), {
-    platform: options.platform
+    platform: options.platform,
+    scopes,
+    teams
   });
 });
 program.command("validate").description("Validate generated config files against platform constraints").action(async () => {
   await runValidate(process.cwd());
 });
+program.command("install").description("Install a plugin bundle into the current project").argument("<plugin-path>", "Path to plugin directory (containing manifest.json)").option("-p, --platform <platform>", "Install for a specific platform only").option("-f, --force", "Overwrite existing files").option(
+  "--cursor-user-plugin",
+  "Install Cursor IDE bundle from plugin cursor-ide-plugin/ to ~/.cursor/plugins/local/ (see cursor.com/docs/plugins)"
+).action(async (pluginPath, options) => {
+  if (options.platform && !PLATFORMS.includes(options.platform)) {
+    console.log(chalk6.red(`Unknown platform: ${options.platform}. Valid: ${PLATFORMS.join(", ")}`));
+    process.exit(1);
+  }
+  await runInstall(pluginPath, process.cwd(), {
+    platform: options.platform,
+    force: options.force,
+    cursorUserPlugin: options.cursorUserPlugin
+  });
+});
+program.command("uninstall").description("Uninstall a previously installed plugin").argument("<plugin-name>", "Name of the plugin to uninstall").action(async (pluginName) => {
+  await runUninstall(pluginName, process.cwd());
+});
 program.parse();