skiller 0.7.10 → 0.7.12

package/README.md

@@ -46,6 +46,14 @@ A Claude-centric fork of [ruler](https://github.com/intellectronica/ruler) with
 
 - `[backup].enabled = false` disables `.bak` files
 
+## 8. Multi-Agent Skills Propagation
+
+- `.claude/skills/` is the source of truth — skills are automatically copied to agent-specific directories on `skiller apply`
+- Supported agent paths: `.codex/skills`, `.cursor/skills`, `.opencode/skill`, `.roo/skills`, `.gemini/skills`, `.agents/skills`
+- Shared paths are deduplicated (Claude/Copilot/Kilo share `.claude/skills`, Goose/Amp share `.agents/skills`)
+- Agent skills directories are auto-added to `.gitignore` (excluding `.claude/skills`)
+- Validates skill structure — warns on missing `SKILL.md`
+
 ---
 
 # Skiller: Centralise Your AI Coding Assistant Instructions
@@ -79,35 +87,35 @@ Skiller solves this by providing a **single source of truth** for all your AI ag
 
 ## Supported AI Agents
 
-| Agent            | Rules File(s)                                      | MCP Configuration / Notes                        |
-| ---------------- | -------------------------------------------------- | ------------------------------------------------ |
-| AGENTS.md        | `AGENTS.md`                                        | (pseudo-agent ensuring root `AGENTS.md` exists)  |
-| GitHub Copilot   | `AGENTS.md`                                        | `.vscode/mcp.json`                               |
-| Claude Code      | `CLAUDE.md` (@filename references)                 | `.mcp.json`                                      |
-| OpenAI Codex CLI | `AGENTS.md`                                        | `.codex/config.toml`                             |
-| Jules            | `AGENTS.md`                                        | -                                                |
-| Cursor           | `AGENTS.md`                                        | `.cursor/mcp.json`                               |
-| Windsurf         | `AGENTS.md`                                        | `.windsurf/mcp_config.json`                      |
-| Cline            | `.clinerules`                                      | -                                                |
-| Crush            | `CRUSH.md`                                         | `.crush.json`                                    |
-| Amp              | `AGENTS.md`                                        | -                                                |
-| Amazon Q CLI     | `.amazonq/rules/skiller_q_rules.md`                | `.amazonq/mcp.json`                              |
-| Aider            | `AGENTS.md`, `.aider.conf.yml`                     | `.mcp.json`                                      |
-| Firebase Studio  | `.idx/airules.md`                                  | `.idx/mcp.json`                                  |
-| Open Hands       | `.openhands/microagents/repo.md`                   | `config.toml`                                    |
-| Gemini CLI       | `AGENTS.md`                                        | `.gemini/settings.json`                          |
-| Junie            | `.junie/guidelines.md`                             | -                                                |
-| AugmentCode      | `.augment/rules/skiller_augment_instructions.md`   | -                                                |
-| Kilo Code        | `.kilocode/rules/skiller_kilocode_instructions.md` | `.kilocode/mcp.json`                             |
-| OpenCode         | `AGENTS.md`                                        | `opencode.json`                                  |
-| Goose            | `.goosehints`                                      | -                                                |
-| Qwen Code        | `AGENTS.md`                                        | `.qwen/settings.json`                            |
-| RooCode          | `AGENTS.md`                                        | `.roo/mcp.json`                                  |
-| Zed              | `AGENTS.md`                                        | `.zed/settings.json` (project root, never $HOME) |
-| Trae AI          | `.trae/rules/project_rules.md`                     | -                                                |
-| Warp             | `WARP.md`                                          | -                                                |
-| Kiro             | `.kiro/steering/skiller_kiro_instructions.md`      | -                                                |
-| Firebender       | `firebender.json`                                  | `firebender.json` (rules and MCP in same file)   |
+| Agent            | Rules File(s)                                      | MCP Configuration / Notes                        | Skills Location    |
+| ---------------- | -------------------------------------------------- | ------------------------------------------------ | ------------------ |
+| AGENTS.md        | `AGENTS.md`                                        | (pseudo-agent ensuring root `AGENTS.md` exists)  | -                  |
+| GitHub Copilot   | `AGENTS.md`                                        | `.vscode/mcp.json`                               | `.claude/skills/`  |
+| Claude Code      | `CLAUDE.md` (@filename references)                 | `.mcp.json`                                      | `.claude/skills/`  |
+| OpenAI Codex CLI | `AGENTS.md`                                        | `.codex/config.toml`                             | `.codex/skills/`   |
+| Jules            | `AGENTS.md`                                        | -                                                | -                  |
+| Cursor           | `AGENTS.md`                                        | `.cursor/mcp.json`                               | `.cursor/skills/`  |
+| Windsurf         | `AGENTS.md`                                        | `.windsurf/mcp_config.json`                      | -                  |
+| Cline            | `.clinerules`                                      | -                                                | -                  |
+| Crush            | `CRUSH.md`                                         | `.crush.json`                                    | -                  |
+| Amp              | `AGENTS.md`                                        | -                                                | `.agents/skills/`  |
+| Amazon Q CLI     | `.amazonq/rules/skiller_q_rules.md`                | `.amazonq/mcp.json`                              | -                  |
+| Aider            | `AGENTS.md`, `.aider.conf.yml`                     | `.mcp.json`                                      | -                  |
+| Firebase Studio  | `.idx/airules.md`                                  | `.idx/mcp.json`                                  | -                  |
+| Open Hands       | `.openhands/microagents/repo.md`                   | `config.toml`                                    | -                  |
+| Gemini CLI       | `AGENTS.md`                                        | `.gemini/settings.json`                          | `.gemini/skills/`  |
+| Junie            | `.junie/guidelines.md`                             | -                                                | -                  |
+| AugmentCode      | `.augment/rules/skiller_augment_instructions.md`   | -                                                | -                  |
+| Kilo Code        | `.kilocode/rules/skiller_kilocode_instructions.md` | `.kilocode/mcp.json`                             | `.claude/skills/`  |
+| OpenCode         | `AGENTS.md`                                        | `opencode.json`                                  | `.opencode/skill/` |
+| Goose            | `.goosehints`                                      | -                                                | `.agents/skills/`  |
+| Qwen Code        | `AGENTS.md`                                        | `.qwen/settings.json`                            | -                  |
+| RooCode          | `AGENTS.md`                                        | `.roo/mcp.json`                                  | `.roo/skills/`     |
+| Zed              | `AGENTS.md`                                        | `.zed/settings.json` (project root, never $HOME) | -                  |
+| Trae AI          | `.trae/rules/project_rules.md`                     | -                                                | -                  |
+| Warp             | `WARP.md`                                          | -                                                | -                  |
+| Kiro             | `.kiro/steering/skiller_kiro_instructions.md`      | -                                                | -                  |
+| Firebender       | `firebender.json`                                  | `firebender.json` (rules and MCP in same file)   | -                  |
 
 ## Getting Started
 
@@ -555,11 +563,21 @@ export CODEX_HOME="$(pwd)/.codex"
 
 ## Skills Support
 
-Skiller can manage and propagate Claude Code-compatible skills to supported AI agents. Skills are stored in `.claude/skills/` as the **committed source of truth** and are automatically discovered by Claude Code.
+Skiller can manage and propagate skills to supported AI agents. Skills are stored in `.claude/skills/` as the **committed source of truth** and automatically copied to agent-specific directories on `skiller apply`.
 
 ### How It Works
 
-Skills are specialized knowledge packages that extend AI agent capabilities with domain-specific expertise, workflows, or tool integrations. Skiller discovers skills in your `.claude/skills/` directory and keeps them in sync.
+Skills are specialized knowledge packages that extend AI agent capabilities. Skiller discovers skills in your `.claude/skills/` directory, keeps them in sync via bidirectional `.mdc`/`SKILL.md` sync, and propagates them to all agents with native skills support:
+
+- **Claude Code, GitHub Copilot, Kilo Code**: `.claude/skills/` (shared, source of truth)
+- **OpenAI Codex CLI**: `.codex/skills/`
+- **Cursor**: `.cursor/skills/`
+- **OpenCode**: `.opencode/skill/`
+- **Goose, Amp**: `.agents/skills/` (shared)
+- **Roo Code**: `.roo/skills/`
+- **Gemini CLI**: `.gemini/skills/`
+
+Shared paths are deduplicated — agents sharing the same directory only trigger one copy operation.
 
 ### Skills Directory Structure
 
@@ -586,11 +604,11 @@ Each skill can be defined in two ways:
 
 Skiller provides bidirectional sync between `.mdc` files and `SKILL.md` folders:
 
-| Scenario | Sync Direction |
-|----------|---------------|
-| `.mdc` exists, no `SKILL.md` | → Generate `SKILL.md` with `@reference` to .mdc |
-| `SKILL.md` body is `@reference` | .mdc is source of truth (frontmatter in SKILL.md) |
-| `SKILL.md` has full content | → Generate .mdc from body, update SKILL.md to `@reference` |
+| Scenario                        | Sync Direction                                             |
+| ------------------------------- | ---------------------------------------------------------- |
+| `.mdc` exists, no `SKILL.md`    | → Generate `SKILL.md` with `@reference` to .mdc            |
+| `SKILL.md` body is `@reference` | .mdc is source of truth (frontmatter in SKILL.md)          |
+| `SKILL.md` has full content     | → Generate .mdc from body, update SKILL.md to `@reference` |
 
 The `@reference` body pattern indicates that the `.mdc` file contains the skill content:
 
@@ -656,6 +674,12 @@ Skiller validates discovered skills and issues warnings for:
 
 Warnings don't prevent propagation but help identify potential issues.
 
+### `.gitignore` Integration
+
+When skills propagation is enabled, agent skills directories are automatically added to `.gitignore` (excluding `.claude/skills/` which is the committed source of truth):
+
+- `.codex/skills/`, `.cursor/skills/`, `.opencode/skill/`, `.agents/skills/`, `.roo/skills/`, `.gemini/skills/`
+
 ### Dry-Run Mode
 
 Test skills propagation without making changes:
@@ -664,23 +688,12 @@ Test skills propagation without making changes:
 skiller apply --dry-run
 ```
 
-This shows which skills would be synced and validated.
+This shows which skills would be synced, validated, and copied to each agent directory.
 
 ### Example Workflow
 
 ```bash
-# Option 1: Create a skill using .mdc file
-cat > .claude/skills/my-skill.mdc << 'EOF'
----
-description: My custom skill
----
-
-# My Custom Skill
-
-This skill provides specialized knowledge for...
-EOF
-
-# Option 2: Create a skill folder directly
+# 1. Create a skill folder
 mkdir -p .claude/skills/my-skill
 cat > .claude/skills/my-skill/SKILL.md << 'EOF'
 ---
@@ -693,10 +706,17 @@ description: My custom skill
 This skill provides specialized knowledge for...
 EOF
 
-# Apply to sync skills (runs bidirectional sync)
+# 2. Apply to sync and propagate skills
 skiller apply
 
-# Skills are now available to Claude Code via .claude/skills/
+# 3. Skills are now available to all compatible agents:
+#    - Claude Code, Copilot, Kilo Code: .claude/skills/my-skill/
+#    - Codex CLI: .codex/skills/my-skill/
+#    - Cursor: .cursor/skills/my-skill/
+#    - OpenCode: .opencode/skill/my-skill/
+#    - Goose, Amp: .agents/skills/my-skill/
+#    - Roo Code: .roo/skills/my-skill/
+#    - Gemini CLI: .gemini/skills/my-skill/
 ```
 
 ## `.gitignore` Integration

package/dist/agents/AmpAgent.js

@@ -1,6 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AmpAgent = void 0;
+const path = __importStar(require("path"));
 const AgentsMdAgent_1 = require("./AgentsMdAgent");
 class AmpAgent extends AgentsMdAgent_1.AgentsMdAgent {
     getIdentifier() {
@@ -9,5 +43,11 @@ class AmpAgent extends AgentsMdAgent_1.AgentsMdAgent {
     getName() {
         return 'Amp';
     }
+    supportsNativeSkills() {
+        return true;
+    }
+    getSkillsPath(projectRoot) {
+        return path.join(projectRoot, '.agents/skills');
+    }
 }
 exports.AmpAgent = AmpAgent;

package/dist/agents/CodexCliAgent.js

@@ -139,5 +139,11 @@ class CodexCliAgent {
     supportsMcpRemote() {
         return false; // Codex CLI only supports STDIO based on PR description
     }
+    supportsNativeSkills() {
+        return true;
+    }
+    getSkillsPath(projectRoot) {
+        return path.join(projectRoot, '.codex/skills');
+    }
 }
 exports.CodexCliAgent = CodexCliAgent;

package/dist/agents/CopilotAgent.js

@@ -1,6 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CopilotAgent = void 0;
+const path = __importStar(require("path"));
 const AgentsMdAgent_1 = require("./AgentsMdAgent");
 /**
  * GitHub Copilot agent adapter.
@@ -39,5 +73,11 @@ class CopilotAgent {
     supportsMcpRemote() {
         return true;
     }
+    supportsNativeSkills() {
+        return true;
+    }
+    getSkillsPath(projectRoot) {
+        return path.join(projectRoot, '.claude/skills');
+    }
 }
 exports.CopilotAgent = CopilotAgent;

package/dist/agents/CursorAgent.js

@@ -89,5 +89,8 @@ class CursorAgent extends AgentsMdAgent_1.AgentsMdAgent {
         // Cursor has native support for rules via .cursor/rules/
         return true;
     }
+    getSkillsPath(projectRoot) {
+        return path.join(projectRoot, '.cursor/skills');
+    }
 }
 exports.CursorAgent = CursorAgent;

package/dist/agents/GeminiCliAgent.js

@@ -95,5 +95,11 @@ class GeminiCliAgent extends AgentsMdAgent_1.AgentsMdAgent {
     supportsMcpRemote() {
         return true;
     }
+    supportsNativeSkills() {
+        return true;
+    }
+    getSkillsPath(projectRoot) {
+        return path.join(projectRoot, '.gemini/skills');
+    }
 }
 exports.GeminiCliAgent = GeminiCliAgent;

package/dist/agents/GooseAgent.js

@@ -54,5 +54,11 @@ class GooseAgent extends AbstractAgent_1.AbstractAgent {
         // Goose doesn't support MCP configuration via local config files
         return '';
     }
+    supportsNativeSkills() {
+        return true;
+    }
+    getSkillsPath(projectRoot) {
+        return path.join(projectRoot, '.agents/skills');
+    }
 }
 exports.GooseAgent = GooseAgent;

package/dist/agents/KiloCodeAgent.js

@@ -59,5 +59,11 @@ class KiloCodeAgent extends AbstractAgent_1.AbstractAgent {
     supportsMcpRemote() {
         return true;
     }
+    supportsNativeSkills() {
+        return true;
+    }
+    getSkillsPath(projectRoot) {
+        return path.join(projectRoot, '.claude/skills');
+    }
 }
 exports.KiloCodeAgent = KiloCodeAgent;

package/dist/agents/OpenCodeAgent.js

@@ -95,5 +95,11 @@ class OpenCodeAgent {
     supportsMcpRemote() {
         return true;
     }
+    supportsNativeSkills() {
+        return true;
+    }
+    getSkillsPath(projectRoot) {
+        return path.join(projectRoot, '.opencode/skill');
+    }
 }
 exports.OpenCodeAgent = OpenCodeAgent;

package/dist/agents/RooCodeAgent.js

@@ -135,5 +135,11 @@ class RooCodeAgent {
     getMcpServerKey() {
         return 'mcpServers';
     }
+    supportsNativeSkills() {
+        return true;
+    }
+    getSkillsPath(projectRoot) {
+        return path.join(projectRoot, '.roo/skills');
+    }
 }
 exports.RooCodeAgent = RooCodeAgent;

package/dist/cli/commands.js

@@ -1,18 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.run = run;
-const yargs_1 = __importDefault(require("yargs"));
-const helpers_1 = require("yargs/helpers");
 const handlers_1 = require("./handlers");
 const index_1 = require("../agents/index");
 /**
  * Sets up and parses CLI commands.
  */
-function run() {
-    (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+async function run() {
+    const dynamicImport = new Function('modulePath', 'return import(modulePath);');
+    const [{ default: yargs }, { hideBin }] = await Promise.all([
+        dynamicImport('yargs'),
+        dynamicImport('yargs/helpers'),
+    ]);
+    yargs(hideBin(process.argv))
         .scriptName('skiller')
         .usage('$0 <command> [options]')
         .command('apply', 'Apply skiller configurations to supported AI agents', (y) => {

package/dist/cli/index.js

@@ -2,4 +2,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const commands_1 = require("./commands");
-(0, commands_1.run)();
+(0, commands_1.run)().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/core/SkillsProcessor.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isReferenceBody = isReferenceBody;
 exports.syncMdcToSkillMd = syncMdcToSkillMd;
 exports.discoverSkills = discoverSkills;
+exports.copySkillsToAgent = copySkillsToAgent;
 exports.getSkillsGitignorePaths = getSkillsGitignorePaths;
 exports.propagateSkills = propagateSkills;
 exports.migrateRulesToSkills = migrateRulesToSkills;
@@ -48,6 +49,92 @@ const yaml = __importStar(require("js-yaml"));
 const constants_1 = require("../constants");
 const SkillsUtils_1 = require("./SkillsUtils");
 const FrontmatterParser_1 = require("./FrontmatterParser");
+/**
+ * For non-Claude agents, compile a wrapper SKILL.md (body is a single @reference)
+ * into a standalone SKILL.md with the referenced file's body inlined.
+ *
+ * We intentionally keep this conservative: only expand when the body is *just*
+ * an @reference line, to avoid accidentally treating email addresses or
+ * "@mentions" inside real content as file references.
+ */
+async function compileSkillMdForNonClaudeAgents(skillMdContent, projectRoot, skillFolderPath) {
+    const { frontmatter, rawFrontmatter, body } = (0, FrontmatterParser_1.parseFrontmatter)(skillMdContent);
+    const refCheck = isReferenceBody(body);
+    if (!refCheck.isReference || !refCheck.referencePath) {
+        return skillMdContent;
+    }
+    const referencePath = refCheck.referencePath;
+    const absoluteRefPath = referencePath.startsWith('./') || referencePath.startsWith('../')
+        ? path.resolve(skillFolderPath, referencePath)
+        : path.resolve(projectRoot, referencePath);
+    // Security: only inline references within the project root.
+    const normalizedProjectRoot = path.resolve(projectRoot);
+    const normalizedAbsoluteRefPath = path.resolve(absoluteRefPath);
+    if (!normalizedAbsoluteRefPath.startsWith(normalizedProjectRoot + path.sep)) {
+        return skillMdContent;
+    }
+    let referencedContent;
+    try {
+        referencedContent = await fs.readFile(normalizedAbsoluteRefPath, 'utf8');
+    }
+    catch {
+        return skillMdContent;
+    }
+    const { body: referencedBody } = (0, FrontmatterParser_1.parseFrontmatter)(referencedContent);
+    const fmData = rawFrontmatter && Object.keys(rawFrontmatter).length > 0
+        ? rawFrontmatter
+        : frontmatter && Object.keys(frontmatter).length > 0
+            ? frontmatter
+            : null;
+    if (fmData) {
+        return `---
+${yaml.dump(fmData, { lineWidth: -1, noRefs: true }).trim()}
+---
+
+${referencedBody}
+`;
+    }
+    return `${referencedBody}\n`;
+}
+/**
+ * Copies a single skill directory to an agent skill directory:
+ * - SKILL.md is compiled (inlines @reference wrapper content)
+ * - .mdc files are excluded (Claude-only sources)
+ * - all other files are copied as-is
+ */
+async function copySkillDirectoryForNonClaudeAgents(src, dest, projectRoot, skillFolderPath, depth = 0) {
+    // Security: Prevent DoS via deeply nested directories
+    if (depth >= constants_1.MAX_RECURSION_DEPTH) {
+        return;
+    }
+    const stat = await fs.stat(src);
+    if (stat.isDirectory()) {
+        await fs.mkdir(dest, { recursive: true });
+        const entries = await fs.readdir(src, { withFileTypes: true });
+        for (const entry of entries) {
+            // Exclude all .mdc files from agent skills directories.
+            if (entry.isFile() && entry.name.endsWith('.mdc')) {
+                continue;
+            }
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            await copySkillDirectoryForNonClaudeAgents(srcPath, destPath, projectRoot, skillFolderPath, depth + 1);
+        }
+        return;
+    }
+    // Files
+    if (path.basename(src) === constants_1.SKILL_MD_FILENAME) {
+        const content = await fs.readFile(src, 'utf8');
+        const compiled = await compileSkillMdForNonClaudeAgents(content, projectRoot, skillFolderPath);
+        await fs.writeFile(dest, compiled, 'utf8');
+        return;
+    }
+    // Extra guard: skip .mdc even if reached via recursion.
+    if (src.endsWith('.mdc')) {
+        return;
+    }
+    await fs.copyFile(src, dest);
+}
 /**
  * Check if SKILL.md body is just a reference (single non-empty line starting with @).
  * This replaces the previous synced: true frontmatter detection.
@@ -237,21 +324,25 @@ ${yaml.dump(skillFrontmatter || { name: skillName }, { lineWidth: -1, noRefs: tr
                         else {
                             referencedPath = path.resolve(skillFolderPath, refCheck.referencePath);
                         }
-                        // One-time migration: for old @.claude/rules/ references, look at the
-                        // already-migrated skills location. After migration, SKILL.md will have
-                        // @.claude/skills/ references, so this code path won't be hit again.
-                        let actualPath = referencedPath;
+                        // One-time migration: for old @.claude/rules/ references, prefer the
+                        // original rules path if it exists, then fall back to migrated skills.
+                        const candidatePaths = [referencedPath];
                         if (refCheck.referencePath?.includes('/rules/')) {
                             const refFileName = path.basename(refCheck.referencePath);
                             const refBaseName = path.basename(refFileName, '.mdc');
-                            actualPath = path.join(skillsDir, refBaseName, refFileName);
+                            candidatePaths.push(path.join(skillsDir, refBaseName, refFileName));
                         }
                         let referencedContent = null;
-                        try {
-                            referencedContent = await fs.readFile(actualPath, 'utf8');
-                        }
-                        catch {
-                            // File not found
+                        let actualPath = referencedPath;
+                        for (const candidatePath of candidatePaths) {
+                            try {
+                                referencedContent = await fs.readFile(candidatePath, 'utf8');
+                                actualPath = candidatePath;
+                                break;
+                            }
+                            catch {
+                                // Try next candidate
+                            }
                         }
                         if (referencedContent === null) {
                             warnings.push(`Cannot migrate ${skillName}: referenced file not found at ${actualPath}`);
@@ -364,24 +455,76 @@ async function discoverSkills(projectRoot, skillerDir) {
     // Walk the skills tree
     return await (0, SkillsUtils_1.walkSkillsTree)(skillsPath);
 }
+/**
+ * Copies skills from source directory to target agent's skills directory.
+ * Validates skill structure and returns copy count and warnings.
+ */
+async function copySkillsToAgent(sourceSkillsDir, targetSkillsDir, projectRoot, verbose, dryRun) {
+    const warnings = [];
+    let copied = 0;
+    try {
+        await fs.access(sourceSkillsDir);
+    }
+    catch {
+        // Source directory doesn't exist
+        return { copied: 0, warnings: [] };
+    }
+    // Use walkSkillsTree to discover skills
+    const skillsTree = await (0, SkillsUtils_1.walkSkillsTree)(sourceSkillsDir);
+    // Validate and copy each skill
+    for (const skill of skillsTree.skills) {
+        // skill.path is absolute, use it directly
+        const skillPath = skill.path;
+        const skillMdPath = path.join(skillPath, constants_1.SKILL_MD_FILENAME);
+        // Validate: skill must have SKILL.md
+        try {
+            await fs.access(skillMdPath);
+        }
+        catch {
+            warnings.push(`Skill '${skill.name}' missing required SKILL.md file, skipping`);
+            continue;
+        }
+        // Copy skill directory to target using relative path
+        const relativeSkillPath = path.relative(sourceSkillsDir, skill.path);
+        const targetSkillPath = path.join(targetSkillsDir, relativeSkillPath);
+        if (!dryRun) {
+            await copySkillDirectoryForNonClaudeAgents(skillPath, targetSkillPath, projectRoot, skillPath);
+        }
+        (0, constants_1.logVerboseInfo)(dryRun
+            ? `DRY RUN: Would copy skill '${skill.name}' to ${targetSkillsDir}`
+            : `Copied skill '${skill.name}' to ${targetSkillsDir}`, verbose, dryRun);
+        copied++;
+    }
+    return { copied, warnings };
+}
 /**
  * Gets the paths that skills will generate, for gitignore purposes.
- * In the new architecture, .claude/skills is the source of truth and should NOT be gitignored.
- * This function now returns an empty array as skills are committed.
+ * Collects paths from all agents with native skills support, excluding the source (.claude/skills).
  */
-async function getSkillsGitignorePaths(
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-_projectRoot) {
-    // In the new architecture, .claude/skills is the source of truth and committed.
-    // No skills-related paths need to be gitignored.
-    return [];
+function getSkillsGitignorePaths(projectRoot, agents) {
+    const paths = [];
+    const sourceSkillsPath = path.join(projectRoot, constants_1.CLAUDE_SKILLS_PATH);
+    for (const agent of agents) {
+        if (agent.supportsNativeSkills?.() && agent.getSkillsPath) {
+            const skillsPath = agent.getSkillsPath(projectRoot);
+            if (skillsPath && skillsPath !== sourceSkillsPath) {
+                // Convert to relative path for gitignore
+                const relativePath = path.relative(projectRoot, skillsPath);
+                // Deduplicate paths
+                if (!paths.includes(relativePath)) {
+                    paths.push(relativePath);
+                }
+            }
+        }
+    }
+    return paths;
 }
 /**
  * Propagates skills for agents that need them.
  * In the new architecture, skills are committed to .claude/skills and discovered by agents natively.
  * This function now only discovers and validates skills.
  */
-async function propagateSkills(projectRoot, _agents, skillsEnabled, verbose, dryRun, skillerDir) {
+async function propagateSkills(projectRoot, agents, skillsEnabled, verbose, dryRun, skillerDir) {
     if (!skillsEnabled) {
         (0, constants_1.logVerboseInfo)('Skills support disabled', verbose, dryRun);
         return;
@@ -422,6 +565,27 @@ async function propagateSkills(projectRoot, _agents, skillsEnabled, verbose, dry
         return;
     }
     (0, constants_1.logVerboseInfo)(`Discovered ${skills.length} skill(s)`, verbose, dryRun);
+    // Copy skills to all agents with native skills support
+    const destinationPaths = new Set();
+    for (const agent of agents) {
+        if (agent.supportsNativeSkills?.() && agent.getSkillsPath) {
+            const targetPath = agent.getSkillsPath(projectRoot);
+            if (targetPath && targetPath !== skillsDir) {
+                // Deduplicate shared paths
+                destinationPaths.add(targetPath);
+            }
+        }
+    }
+    // Copy skills to each unique destination
+    for (const targetPath of destinationPaths) {
+        const result = await copySkillsToAgent(skillsDir, targetPath, projectRoot, verbose, dryRun);
+        if (result.copied > 0) {
+            (0, constants_1.logVerboseInfo)(`Copied ${result.copied} skill(s) to ${targetPath}`, verbose, dryRun);
+        }
+        for (const warning of result.warnings) {
+            (0, constants_1.logWarn)(warning, dryRun);
+        }
+    }
 }
 /**
  * Recursively finds all folders containing SKILL.md in a directory.

package/dist/lib.js

@@ -147,7 +147,7 @@ async function applyAllAgentConfigs(projectRoot, includedAgents, configPath, cli
     if (skillsEnabledForGitignore) {
         // Skills enabled by default or explicitly
         const { getSkillsGitignorePaths } = await Promise.resolve().then(() => __importStar(require('./core/SkillsProcessor')));
-        const skillsPaths = await getSkillsGitignorePaths(projectRoot);
+        const skillsPaths = getSkillsGitignorePaths(projectRoot, selectedAgents);
         allGeneratedPaths = [...generatedPaths, ...skillsPaths];
     }
     await (0, apply_engine_1.updateGitignore)(projectRoot, allGeneratedPaths, loadedConfig, cliGitignoreEnabled, dryRun);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "skiller",
-	"version": "0.7.10",
+	"version": "0.7.12",
 	"description": "Skiller — apply the same rules to all coding agents",
 	"main": "dist/lib.js",
 	"publishConfig": {