aicm 0.19.1 → 0.20.1

package/README.md

@@ -16,6 +16,8 @@ A CLI tool for managing Agentic configurations across projects.
 - [Features](#features)
   - [Rules](#rules)
   - [Commands](#commands)
+  - [Skills](#skills)
+  - [Agents](#agents)
   - [Hooks](#hooks)
   - [MCP Servers](#mcp-servers)
   - [Assets](#assets)
@@ -23,6 +25,7 @@ A CLI tool for managing Agentic configurations across projects.
 - [Configuration](#configuration)
 - [CLI Commands](#cli-commands)
 - [Node.js API](#nodejs-api)
+- [FAQ](#faq)
 
 ## Why
 
@@ -85,6 +88,8 @@ After installation, open Cursor and ask it to do something. Your AI assistant wi
 │   ├── typescript.mdc
 │   └── react.mdc
 ├── commands/        # Command files (.md) [optional]
+├── skills/          # Agent Skills [optional]
+├── agents/          # Subagents (.md) [optional]
 ├── assets/          # Auxiliary files [optional]
 └── hooks.json       # Hook configuration [optional]
 ```
@@ -139,7 +144,7 @@ The rules are now installed in `.cursor/rules/aicm/` and any MCP servers are con
 ### Notes
 
 - Generated files are always placed in subdirectories for deterministic cleanup and easy gitignore.
-- Users should add `.cursor/*/aicm/` to `.gitignore` to avoid tracking generated files. This single pattern covers all aicm-managed directories (rules, commands, assets, hooks).
+- Users may add `.cursor/*/aicm/`, `.cursor/skills/`, `.cursor/agents/`, `.claude/`, and `.codex/` to `.gitignore` to avoid tracking generated files.
 
 ## Features
 
@@ -193,6 +198,136 @@ Configure your `aicm.json`:
 
 Command files ending in `.md` are installed to `.cursor/commands/aicm/` and appear in Cursor under the `/` command menu.
 
+### Skills
+
+aicm supports [Agent Skills](https://agentskills.io) - a standard format for giving AI agents new capabilities and expertise. Skills are folders containing instructions, scripts, and resources that agents can discover and use.
+
+Create a `skills/` directory where each subdirectory is a skill (containing a `SKILL.md` file):
+
+```
+my-project/
+├── aicm.json
+└── skills/
+    ├── pdf-processing/
+    │   ├── SKILL.md
+    │   ├── scripts/
+    │   │   └── extract.py
+    │   └── references/
+    │       └── REFERENCE.md
+    └── code-review/
+        └── SKILL.md
+```
+
+Each skill must have a `SKILL.md` file with YAML frontmatter:
+
+```markdown
+---
+name: pdf-processing
+description: Extract text and tables from PDF files, fill forms, merge documents.
+---
+
+# PDF Processing Skill
+
+This skill enables working with PDF documents.
+
+## Usage
+
+Run the extraction script:
+scripts/extract.py
+```
+
+Configure your `aicm.json`:
+
+```json
+{
+  "rootDir": "./",
+  "targets": ["cursor"]
+}
+```
+
+Skills are installed to different locations based on the target:
+
+| Target     | Skills Location   |
+| ---------- | ----------------- |
+| **Cursor** | `.cursor/skills/` |
+| **Claude** | `.claude/skills/` |
+| **Codex**  | `.codex/skills/`  |
+
+When installed, each skill directory is copied in its entirety (including `scripts/`, `references/`, `assets/` subdirectories). A `.aicm.json` file is added inside each installed skill to track that it's managed by aicm.
+
+In workspace mode, skills are installed both to each package and merged at the root level, similar to commands.
+
+### Agents
+
+aicm supports [Cursor Subagents](https://cursor.com/docs/context/subagents) and [Claude Code Subagents](https://code.claude.com/docs/en/sub-agents) - specialized AI assistants that can be delegated specific tasks. Agents are markdown files with YAML frontmatter that define custom prompts, descriptions, and model configurations.
+
+Create an `agents/` directory in your project (at the `rootDir` location):
+
+```
+my-project/
+├── aicm.json
+└── agents/
+    ├── code-reviewer.md
+    ├── debugger.md
+    └── specialized/
+        └── security-auditor.md
+```
+
+Each agent file should have YAML frontmatter with at least a `name` and `description`:
+
+```markdown
+---
+name: code-reviewer
+description: Reviews code for quality and best practices. Use after code changes.
+model: inherit
+---
+
+You are a senior code reviewer ensuring high standards of code quality and security.
+
+When invoked:
+
+1. Run git diff to see recent changes
+2. Focus on modified files
+3. Begin review immediately
+
+Review checklist:
+
+- Code is clear and readable
+- Functions and variables are well-named
+- No duplicated code
+- Proper error handling
+```
+
+Configure your `aicm.json`:
+
+```json
+{
+  "rootDir": "./",
+  "targets": ["cursor", "claude"]
+}
+```
+
+Agents are installed to different locations based on the target:
+
+| Target     | Agents Location   |
+| ---------- | ----------------- |
+| **Cursor** | `.cursor/agents/` |
+| **Claude** | `.claude/agents/` |
+
+A `.aicm.json` metadata file is created in the agents directory to track which agents are managed by aicm. This allows the clean command to remove only aicm-managed agents while preserving any manually created agents.
+
+**Supported Configuration Fields:**
+
+Only fields that work in both Cursor and Claude Code are documented:
+
+- `name` - Unique identifier (defaults to filename without extension)
+- `description` - When the agent should be used for task delegation
+- `model` - Model to use (`inherit`, or platform-specific values like `sonnet`, `haiku`, `fast`)
+
+> **Note:** Users may include additional platform-specific fields (e.g., `tools`, `hooks` for Claude Code, or `readonly`, `is_background` for Cursor) - aicm will preserve them, but they only work on the respective platform.
+
+In workspace mode, agents are installed both to each package and merged at the root level, similar to commands and skills.
+
 ### Hooks
 
 aicm provides first-class support for [Cursor Agent Hooks](https://docs.cursor.com/advanced/hooks), allowing you to intercept and extend the agent's behavior. Hooks enable you to run custom scripts before/after shell execution, file edits, MCP calls, and more.
@@ -369,9 +504,11 @@ aicm automatically detects workspaces if your `package.json` contains a `workspa
 ### How It Works
 
 1. **Discover packages**: Automatically find all directories containing `aicm.json` files in your repository.
-2. **Install per package**: Install rules and MCPs for each package individually in their respective directories.
+2. **Install per package**: Install rules, commands, skills, and agents for each package individually in their respective directories.
 3. **Merge MCP servers**: Write a merged `.cursor/mcp.json` at the repository root containing all MCP servers from every package.
 4. **Merge commands**: Write a merged `.cursor/commands/aicm/` at the repository root containing all commands from every package.
+5. **Merge skills**: Write merged skills to the repository root (e.g., `.cursor/skills/`) containing all skills from every package.
+6. **Merge agents**: Write merged agents to the repository root (e.g., `.cursor/agents/`) containing all agents from every package.
 
 For example, in a workspace structure like:
 
@@ -429,7 +566,7 @@ Create an `aicm.json` file in your project root, or an `aicm` key in your projec
 
 ### Configuration Options
 
-- **rootDir**: Directory containing your aicm structure. Must contain one or more of: `rules/`, `commands/`, `assets/`, `hooks/`, or `hooks.json`. If not specified, aicm will only install rules from presets and will not pick up any local directories.
+- **rootDir**: Directory containing your aicm structure. Must contain one or more of: `rules/`, `commands/`, `skills/`, `agents/`, `assets/`, `hooks/`, or `hooks.json`. If not specified, aicm will only install rules from presets and will not pick up any local directories.
 - **targets**: IDEs/Agent targets where rules should be installed. Defaults to `["cursor"]`. Supported targets: `cursor`, `windsurf`, `codex`, `claude`.
 - **presets**: List of preset packages or paths to include.
 - **mcpServers**: MCP server configurations.
@@ -471,11 +608,16 @@ aicm uses a convention-based directory structure:
 ```
 my-project/
 ├── aicm.json
-├── rules/           # Rule files (.mdc) [required for rules]
+├── rules/           # Rule files (.mdc) [optional]
 │   ├── api.mdc
 │   └── testing.mdc
 ├── commands/        # Command files (.md) [optional]
 │   └── generate.md
+├── skills/          # Agent Skills [optional]
+│   └── my-skill/
+│       └── SKILL.md
+├── agents/          # Subagents (.md) [optional]
+│   └── code-reviewer.md
 ├── assets/          # Auxiliary files [optional]
 │   ├── schema.json
 │   └── examples/
@@ -559,6 +701,50 @@ install({
 
 To prevent [prompt-injection](https://en.wikipedia.org/wiki/Prompt_injection), use only packages from trusted sources.
 
+## FAQ
+
+### Can I reference rules from commands or vice versa?
+
+**No, direct references between rules and commands are not supported.** This is because:
+
+- **Commands are hoisted** to the root level in workspace mode (`.cursor/commands/aicm/`)
+- **Rules remain nested** at the package level (`package-a/.cursor/rules/aicm/`)
+- This creates broken relative paths when commands try to reference rules
+
+**❌ Don't do this:**
+
+```markdown
+<!-- commands/validate.md -->
+
+Follow the rules in [api-rule.mdc](../rules/api-rule.mdc) <!-- BROKEN! -->
+```
+
+**✅ Do this instead:**
+
+```markdown
+<!-- Put shared content in assets/coding-standards.md -->
+
+# Coding Standards
+
+- Use TypeScript for all new code
+- Follow ESLint rules
+- Write unit tests for all functions
+```
+
+```markdown
+<!-- rules/api-rule.mdc -->
+
+Follow the coding standards in [coding-standards.md](../assets/coding-standards.md).
+```
+
+```markdown
+<!-- commands/validate.md -->
+
+Validate against our [coding standards](../assets/coding-standards.md).
+```
+
+Use shared assets for content that needs to be referenced by both rules and commands. Assets are properly rewritten and work in all modes.
+
 ## Contributing
 
 Contributions are welcome! Please feel free to open an issue or submit a Pull Request.

package/dist/commands/clean.js

@@ -152,6 +152,110 @@ function cleanHooks(cwd, verbose) {
     }
     return hasChanges;
 }
+/**
+ * Clean aicm-managed skills from a skills directory
+ * Only removes skills that have .aicm.json (presence indicates aicm management)
+ */
+function cleanSkills(cwd, verbose) {
+    let cleanedCount = 0;
+    // Skills directories for each target
+    const skillsDirs = [
+        node_path_1.default.join(cwd, ".cursor", "skills"),
+        node_path_1.default.join(cwd, ".claude", "skills"),
+        node_path_1.default.join(cwd, ".codex", "skills"),
+    ];
+    for (const skillsDir of skillsDirs) {
+        if (!fs_extra_1.default.existsSync(skillsDir)) {
+            continue;
+        }
+        try {
+            const entries = fs_extra_1.default.readdirSync(skillsDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+                const skillPath = node_path_1.default.join(skillsDir, entry.name);
+                const metadataPath = node_path_1.default.join(skillPath, ".aicm.json");
+                // Only clean skills that have .aicm.json (presence indicates aicm management)
+                if (fs_extra_1.default.existsSync(metadataPath)) {
+                    fs_extra_1.default.removeSync(skillPath);
+                    if (verbose) {
+                        console.log(chalk_1.default.gray(`  Removed skill ${skillPath}`));
+                    }
+                    cleanedCount++;
+                }
+            }
+            // Remove the skills directory if it's now empty
+            const remainingEntries = fs_extra_1.default.readdirSync(skillsDir);
+            if (remainingEntries.length === 0) {
+                fs_extra_1.default.removeSync(skillsDir);
+                if (verbose) {
+                    console.log(chalk_1.default.gray(`  Removed empty directory ${skillsDir}`));
+                }
+            }
+        }
+        catch (_a) {
+            console.warn(chalk_1.default.yellow(`Warning: Failed to clean skills in ${skillsDir}`));
+        }
+    }
+    return cleanedCount;
+}
+/**
+ * Clean aicm-managed agents from agents directories
+ * Only removes agents that are tracked in .aicm.json metadata file
+ */
+function cleanAgents(cwd, verbose) {
+    let cleanedCount = 0;
+    // Agents directories for each target
+    const agentsDirs = [
+        node_path_1.default.join(cwd, ".cursor", "agents"),
+        node_path_1.default.join(cwd, ".claude", "agents"),
+    ];
+    for (const agentsDir of agentsDirs) {
+        const metadataPath = node_path_1.default.join(agentsDir, ".aicm.json");
+        if (!fs_extra_1.default.existsSync(metadataPath)) {
+            continue;
+        }
+        try {
+            const metadata = fs_extra_1.default.readJsonSync(metadataPath);
+            // Remove all managed agents (names only)
+            for (const agentName of metadata.managedAgents || []) {
+                // Skip invalid names containing path separators (security check)
+                if (agentName.includes("/") || agentName.includes("\\")) {
+                    console.warn(chalk_1.default.yellow(`Warning: Skipping invalid agent name "${agentName}" (contains path separator)`));
+                    continue;
+                }
+                const fullPath = node_path_1.default.join(agentsDir, agentName + ".md");
+                if (fs_extra_1.default.existsSync(fullPath)) {
+                    fs_extra_1.default.removeSync(fullPath);
+                    if (verbose) {
+                        console.log(chalk_1.default.gray(`  Removed agent ${fullPath}`));
+                    }
+                    cleanedCount++;
+                }
+            }
+            // Remove the metadata file
+            fs_extra_1.default.removeSync(metadataPath);
+            if (verbose) {
+                console.log(chalk_1.default.gray(`  Removed ${metadataPath}`));
+            }
+            // Remove the agents directory if it's now empty
+            if (fs_extra_1.default.existsSync(agentsDir)) {
+                const remainingEntries = fs_extra_1.default.readdirSync(agentsDir);
+                if (remainingEntries.length === 0) {
+                    fs_extra_1.default.removeSync(agentsDir);
+                    if (verbose) {
+                        console.log(chalk_1.default.gray(`  Removed empty directory ${agentsDir}`));
+                    }
+                }
+            }
+        }
+        catch (_a) {
+            console.warn(chalk_1.default.yellow(`Warning: Failed to clean agents in ${agentsDir}`));
+        }
+    }
+    return cleanedCount;
+}
 function cleanEmptyDirectories(cwd, verbose) {
     let cleanedCount = 0;
     const dirsToCheck = [
@@ -159,7 +263,14 @@ function cleanEmptyDirectories(cwd, verbose) {
         node_path_1.default.join(cwd, ".cursor", "commands"),
         node_path_1.default.join(cwd, ".cursor", "assets"),
         node_path_1.default.join(cwd, ".cursor", "hooks"),
+        node_path_1.default.join(cwd, ".cursor", "skills"),
+        node_path_1.default.join(cwd, ".cursor", "agents"),
         node_path_1.default.join(cwd, ".cursor"),
+        node_path_1.default.join(cwd, ".claude", "skills"),
+        node_path_1.default.join(cwd, ".claude", "agents"),
+        node_path_1.default.join(cwd, ".claude"),
+        node_path_1.default.join(cwd, ".codex", "skills"),
+        node_path_1.default.join(cwd, ".codex"),
     ];
     for (const dir of dirsToCheck) {
         if (fs_extra_1.default.existsSync(dir)) {
@@ -211,6 +322,10 @@ async function cleanPackage(options = {}) {
         // Clean hooks
         if (cleanHooks(cwd, verbose))
             cleanedCount++;
+        // Clean skills
+        cleanedCount += cleanSkills(cwd, verbose);
+        // Clean agents
+        cleanedCount += cleanAgents(cwd, verbose);
         // Clean empty directories
         cleanedCount += cleanEmptyDirectories(cwd, verbose);
         return {

package/dist/commands/install-workspaces.js

@@ -41,6 +41,97 @@ function collectWorkspaceCommandTargets(packages) {
     }
     return Array.from(targets);
 }
+/**
+ * Merge skills from multiple workspace packages
+ * Skills are merged flat (not namespaced by preset)
+ * Dedupes preset skills that appear in multiple packages
+ */
+function mergeWorkspaceSkills(packages) {
+    var _a;
+    const skills = [];
+    const seenPresetSkills = new Set();
+    for (const pkg of packages) {
+        // Skills are supported by cursor, claude, and codex targets
+        const hasSkillsTarget = pkg.config.config.targets.includes("cursor") ||
+            pkg.config.config.targets.includes("claude") ||
+            pkg.config.config.targets.includes("codex");
+        if (!hasSkillsTarget) {
+            continue;
+        }
+        for (const skill of (_a = pkg.config.skills) !== null && _a !== void 0 ? _a : []) {
+            if (skill.presetName) {
+                // Dedupe preset skills by preset+name combination
+                const presetKey = `${skill.presetName}::${skill.name}`;
+                if (seenPresetSkills.has(presetKey)) {
+                    continue;
+                }
+                seenPresetSkills.add(presetKey);
+            }
+            skills.push(skill);
+        }
+    }
+    return skills;
+}
+/**
+ * Collect all targets that support skills from workspace packages
+ */
+function collectWorkspaceSkillTargets(packages) {
+    const targets = new Set();
+    for (const pkg of packages) {
+        for (const target of pkg.config.config.targets) {
+            // Skills are supported by cursor, claude, and codex
+            if (target === "cursor" || target === "claude" || target === "codex") {
+                targets.add(target);
+            }
+        }
+    }
+    return Array.from(targets);
+}
+/**
+ * Merge agents from multiple workspace packages
+ * Agents are merged flat (not namespaced by preset)
+ * Dedupes preset agents that appear in multiple packages
+ */
+function mergeWorkspaceAgents(packages) {
+    var _a;
+    const agents = [];
+    const seenPresetAgents = new Set();
+    for (const pkg of packages) {
+        // Agents are supported by cursor and claude targets
+        const hasAgentsTarget = pkg.config.config.targets.includes("cursor") ||
+            pkg.config.config.targets.includes("claude");
+        if (!hasAgentsTarget) {
+            continue;
+        }
+        for (const agent of (_a = pkg.config.agents) !== null && _a !== void 0 ? _a : []) {
+            if (agent.presetName) {
+                // Dedupe preset agents by preset+name combination
+                const presetKey = `${agent.presetName}::${agent.name}`;
+                if (seenPresetAgents.has(presetKey)) {
+                    continue;
+                }
+                seenPresetAgents.add(presetKey);
+            }
+            agents.push(agent);
+        }
+    }
+    return agents;
+}
+/**
+ * Collect all targets that support agents from workspace packages
+ */
+function collectWorkspaceAgentTargets(packages) {
+    const targets = new Set();
+    for (const pkg of packages) {
+        for (const target of pkg.config.config.targets) {
+            // Agents are supported by cursor and claude
+            if (target === "cursor" || target === "claude") {
+                targets.add(target);
+            }
+        }
+    }
+    return Array.from(targets);
+}
 function mergeWorkspaceMcpServers(packages) {
     const merged = {};
     const info = {};
@@ -101,6 +192,8 @@ async function installWorkspacesPackages(packages, options = {}) {
     let totalCommandCount = 0;
     let totalAssetCount = 0;
     let totalHookCount = 0;
+    let totalSkillCount = 0;
+    let totalAgentCount = 0;
     // Install packages sequentially for now (can be parallelized later)
     for (const pkg of packages) {
         const packagePath = pkg.absolutePath;
@@ -114,6 +207,8 @@ async function installWorkspacesPackages(packages, options = {}) {
             totalCommandCount += result.installedCommandCount;
             totalAssetCount += result.installedAssetCount;
             totalHookCount += result.installedHookCount;
+            totalSkillCount += result.installedSkillCount;
+            totalAgentCount += result.installedAgentCount;
             results.push({
                 path: pkg.relativePath,
                 success: result.success,
@@ -122,6 +217,8 @@ async function installWorkspacesPackages(packages, options = {}) {
                 installedCommandCount: result.installedCommandCount,
                 installedAssetCount: result.installedAssetCount,
                 installedHookCount: result.installedHookCount,
+                installedSkillCount: result.installedSkillCount,
+                installedAgentCount: result.installedAgentCount,
             });
         }
         catch (error) {
@@ -133,6 +230,8 @@ async function installWorkspacesPackages(packages, options = {}) {
                 installedCommandCount: 0,
                 installedAssetCount: 0,
                 installedHookCount: 0,
+                installedSkillCount: 0,
+                installedAgentCount: 0,
             });
         }
     }
@@ -144,6 +243,8 @@ async function installWorkspacesPackages(packages, options = {}) {
         totalCommandCount,
         totalAssetCount,
         totalHookCount,
+        totalSkillCount,
+        totalAgentCount,
     };
 }
 /**
@@ -162,11 +263,13 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
             const isRoot = pkg.relativePath === ".";
             if (!isRoot)
                 return true;
-            // For root directories, only keep if it has rules, commands, or presets
+            // For root directories, only keep if it has rules, commands, skills, agents, or presets
             const hasRules = pkg.config.rules && pkg.config.rules.length > 0;
             const hasCommands = pkg.config.commands && pkg.config.commands.length > 0;
+            const hasSkills = pkg.config.skills && pkg.config.skills.length > 0;
+            const hasAgents = pkg.config.agents && pkg.config.agents.length > 0;
             const hasPresets = pkg.config.config.presets && pkg.config.config.presets.length > 0;
-            return hasRules || hasCommands || hasPresets;
+            return hasRules || hasCommands || hasSkills || hasAgents || hasPresets;
         });
         if (packages.length === 0) {
             return {
@@ -176,6 +279,8 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
                 installedCommandCount: 0,
                 installedAssetCount: 0,
                 installedHookCount: 0,
+                installedSkillCount: 0,
+                installedAgentCount: 0,
                 packagesCount: 0,
             };
         }
@@ -206,6 +311,30 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
             (0, install_1.writeAssetsToTargets)(allAssets, workspaceCommandTargets);
             (0, install_1.writeCommandsToTargets)(dedupedWorkspaceCommands, workspaceCommandTargets);
         }
+        // Merge and write skills for workspace
+        const workspaceSkills = mergeWorkspaceSkills(packages);
+        const workspaceSkillTargets = collectWorkspaceSkillTargets(packages);
+        if (workspaceSkills.length > 0) {
+            (0, install_1.warnPresetSkillCollisions)(workspaceSkills);
+        }
+        if (!dryRun &&
+            workspaceSkills.length > 0 &&
+            workspaceSkillTargets.length > 0) {
+            const dedupedWorkspaceSkills = (0, install_1.dedupeSkillsForInstall)(workspaceSkills);
+            (0, install_1.writeSkillsToTargets)(dedupedWorkspaceSkills, workspaceSkillTargets);
+        }
+        // Merge and write agents for workspace
+        const workspaceAgents = mergeWorkspaceAgents(packages);
+        const workspaceAgentTargets = collectWorkspaceAgentTargets(packages);
+        if (workspaceAgents.length > 0) {
+            (0, install_1.warnPresetAgentCollisions)(workspaceAgents);
+        }
+        if (!dryRun &&
+            workspaceAgents.length > 0 &&
+            workspaceAgentTargets.length > 0) {
+            const dedupedWorkspaceAgents = (0, install_1.dedupeAgentsForInstall)(workspaceAgents);
+            (0, install_1.writeAgentsToTargets)(dedupedWorkspaceAgents, workspaceAgentTargets);
+        }
         const { merged: rootMcp, conflicts } = mergeWorkspaceMcpServers(packages);
         const hasCursorTarget = packages.some((p) => p.config.config.targets.includes("cursor"));
         if (!dryRun && hasCursorTarget && Object.keys(rootMcp).length > 0) {
@@ -231,6 +360,12 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
                     if (pkg.installedHookCount > 0) {
                         summaryParts.push(`${pkg.installedHookCount} hook${pkg.installedHookCount === 1 ? "" : "s"}`);
                     }
+                    if (pkg.installedSkillCount > 0) {
+                        summaryParts.push(`${pkg.installedSkillCount} skill${pkg.installedSkillCount === 1 ? "" : "s"}`);
+                    }
+                    if (pkg.installedAgentCount > 0) {
+                        summaryParts.push(`${pkg.installedAgentCount} agent${pkg.installedAgentCount === 1 ? "" : "s"}`);
+                    }
                     console.log(chalk_1.default.green(`✅ ${pkg.path} (${summaryParts.join(", ")})`));
                 }
                 else {
@@ -248,7 +383,13 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
                 const hookSummary = result.totalHookCount > 0
                     ? `, ${result.totalHookCount} hook${result.totalHookCount === 1 ? "" : "s"} total`
                     : "";
-                console.log(chalk_1.default.green(`Successfully installed: ${result.packages.length - failedPackages.length}/${result.packages.length} packages (${result.totalRuleCount} rule${result.totalRuleCount === 1 ? "" : "s"} total${commandSummary}${hookSummary})`));
+                const skillSummary = result.totalSkillCount > 0
+                    ? `, ${result.totalSkillCount} skill${result.totalSkillCount === 1 ? "" : "s"} total`
+                    : "";
+                const agentSummary = result.totalAgentCount > 0
+                    ? `, ${result.totalAgentCount} agent${result.totalAgentCount === 1 ? "" : "s"} total`
+                    : "";
+                console.log(chalk_1.default.green(`Successfully installed: ${result.packages.length - failedPackages.length}/${result.packages.length} packages (${result.totalRuleCount} rule${result.totalRuleCount === 1 ? "" : "s"} total${commandSummary}${hookSummary}${skillSummary}${agentSummary})`));
                 console.log(chalk_1.default.red(`Failed packages: ${failedPackages.map((p) => p.path).join(", ")}`));
             }
             const errorDetails = failedPackages
@@ -261,6 +402,8 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
                 installedCommandCount: result.totalCommandCount,
                 installedAssetCount: result.totalAssetCount,
                 installedHookCount: result.totalHookCount,
+                installedSkillCount: result.totalSkillCount,
+                installedAgentCount: result.totalAgentCount,
                 packagesCount: result.packages.length,
             };
         }
@@ -270,6 +413,8 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
             installedCommandCount: result.totalCommandCount,
             installedAssetCount: result.totalAssetCount,
             installedHookCount: result.totalHookCount,
+            installedSkillCount: result.totalSkillCount,
+            installedAgentCount: result.totalAgentCount,
             packagesCount: result.packages.length,
         };
     });