skiller 0.7.15 → 0.7.17

package/README.md

@@ -59,11 +59,21 @@ A Claude-centric fork of [ruler](https://github.com/intellectronica/ruler) with
 - Reads `.claude/settings.json` `enabledPlugins`
 - Syncs enabled plugin `skills/` into agent skills directories on `skiller apply`
 - Syncs enabled plugin `commands/*.md` as skills (`SKILL.md`) into agent skills directories
-- Uses the skill/command name by default (matches existing Codex skill names)
-- If a name conflicts, local skills win and the plugin skill is namespaced as `<pluginId>__<name>`
-- Tracks plugin-managed skills in a single `.skiller-plugins.json` file per agent skills directory
+- Syncs enabled plugin `agents/**/*.md` as skills (`SKILL.md`) into agent skills directories
+- Uses the skill/command/agent name by default (matches existing Codex skill names)
+- If a name conflicts, local skills win and the plugin skill is namespaced as `<pluginId>-<name>`
+- Tracks plugin-managed skills in a single `.skiller.json` file per agent skills directory
 - Removes stale plugin skills when plugins are disabled
 
+## 10. Claude Commands/Agents → Skills
+
+- Syncs `.claude/commands/**/*.md` as skills (`SKILL.md`) into agent skills directories
+- Syncs `.claude/agents/**/*.md` as skills (`SKILL.md`) into agent skills directories
+- Uses the command/agent name by default
+- If a name conflicts, existing local/manual skills win and the project item is namespaced as `claude-<name>`
+- Project items win over plugin skills/commands/agents on name conflicts
+- Tracks project-managed items in a single `.skiller.json` file per agent skills directory
+
 ---
 
 # Skiller: Centralise Your AI Coding Assistant Instructions
@@ -596,8 +606,8 @@ If your project enables Claude Code plugins in `.claude/settings.json`, Skiller
 - Plugin `skills/` are copied as skills
 - Plugin `commands/*.md` are converted into skills (`SKILL.md`)
 - Plugin skills use their original skill/command name by default
-- If a name conflicts, local skills win and the plugin skill is namespaced as `<pluginId>__<name>`
-- Plugin-managed skills are tracked via `.skiller-plugins.json` in each agent skills directory
+- If a name conflicts, local skills win and the plugin skill is namespaced as `<pluginId>-<name>`
+- Plugin-managed skills are tracked via `.skiller.json` in each agent skills directory
 
 ### Skills Directory Structure
 

package/dist/core/ClaudePluginSync.js

@@ -38,6 +38,7 @@ exports.readInstalledPluginsIndex = readInstalledPluginsIndex;
 exports.resolvePluginInstall = resolvePluginInstall;
 exports.discoverPluginSkillDirs = discoverPluginSkillDirs;
 exports.discoverPluginCommandFiles = discoverPluginCommandFiles;
+exports.discoverPluginAgentFiles = discoverPluginAgentFiles;
 exports.syncClaudePluginsToSkillsDirs = syncClaudePluginsToSkillsDirs;
 const fs = __importStar(require("fs/promises"));
 const os = __importStar(require("os"));
@@ -46,9 +47,8 @@ const yaml = __importStar(require("js-yaml"));
 const constants_1 = require("../constants");
 const FrontmatterParser_1 = require("./FrontmatterParser");
 const SkillsUtils_1 = require("./SkillsUtils");
+const SkillsManifest_1 = require("./SkillsManifest");
 const LEGACY_MARKER_FILENAME = '.skiller-plugin.json';
-const MANIFEST_FILENAME = '.skiller-plugins.json';
-const MANIFEST_VERSION = 1;
 function getUserHomeDir() {
     // Prefer env vars so tests (and users) can override deterministically.
     return process.env.HOME || process.env.USERPROFILE || os.homedir();
@@ -219,6 +219,49 @@ async function discoverPluginCommandFiles(installPath) {
         file: path.join(commandsRoot, e.name),
     }));
 }
+async function discoverPluginAgentFiles(installPath) {
+    const agentsRoot = path.join(installPath, 'agents');
+    if (!(await fileExists(agentsRoot)))
+        return [];
+    const results = [];
+    async function walk(current, depth) {
+        if (depth >= constants_1.MAX_RECURSION_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            let content;
+            try {
+                content = await fs.readFile(full, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const parsed = (0, FrontmatterParser_1.parseFrontmatter)(content);
+            const fmName = parsed.rawFrontmatter && typeof parsed.rawFrontmatter.name === 'string'
+                ? parsed.rawFrontmatter.name
+                : parsed.frontmatter?.name;
+            if (typeof fmName !== 'string' || fmName.trim() === '')
+                continue;
+            const rel = path.relative(agentsRoot, full).replace(/\\/g, '/');
+            results.push({ name: fmName.trim(), file: full, rel });
+        }
+    }
+    await walk(agentsRoot, 0);
+    return results;
+}
 function generateBaseNameFromRelId(relId) {
     const normalized = relId.replace(/\\/g, '/');
     const segments = normalized.split('/').filter(Boolean);
@@ -228,76 +271,7 @@ function generateBaseNameFromCommand(commandName) {
     return sanitizeId(commandName);
 }
 function generateNamespacedName(pluginId, baseName) {
-    return `${sanitizeId(pluginId)}__${baseName}`;
-}
-async function readManifestFile(targetSkillsDir) {
-    const manifestPath = path.join(targetSkillsDir, MANIFEST_FILENAME);
-    try {
-        const raw = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
-        if (!raw || typeof raw !== 'object')
-            return null;
-        const obj = raw;
-        if (typeof obj.version !== 'number')
-            return null;
-        if (!Array.isArray(obj.entries))
-            return null;
-        const entries = [];
-        for (const entry of obj.entries) {
-            if (!entry || typeof entry !== 'object')
-                continue;
-            const e = entry;
-            if (typeof e.pluginId !== 'string')
-                continue;
-            const sourceKind = e.sourceKind;
-            if (sourceKind !== 'skill' && sourceKind !== 'command')
-                continue;
-            if (typeof e.sourceRelPath !== 'string')
-                continue;
-            if (typeof e.destRelPath !== 'string')
-                continue;
-            const pluginVersion = typeof e.pluginVersion === 'string' ? e.pluginVersion : undefined;
-            entries.push({
-                pluginId: e.pluginId,
-                pluginVersion,
-                sourceKind,
-                sourceRelPath: e.sourceRelPath,
-                destRelPath: e.destRelPath,
-            });
-        }
-        return {
-            version: obj.version,
-            entries,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-async function writeManifestFile(targetSkillsDir, entries, dryRun) {
-    const manifestPath = path.join(targetSkillsDir, MANIFEST_FILENAME);
-    if (entries.length === 0) {
-        if (dryRun)
-            return;
-        try {
-            await fs.unlink(manifestPath);
-        }
-        catch {
-            // ignore
-        }
-        return;
-    }
-    const manifest = {
-        version: MANIFEST_VERSION,
-        entries: [...entries].sort((a, b) => {
-            // Stable ordering for diffs.
-            const ak = `${a.destRelPath}::${a.pluginId}::${a.sourceKind}::${a.sourceRelPath}`;
-            const bk = `${b.destRelPath}::${b.pluginId}::${b.sourceKind}::${b.sourceRelPath}`;
-            return ak.localeCompare(bk);
-        }),
-    };
-    if (dryRun)
-        return;
-    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+    return `${sanitizeId(pluginId)}-${baseName}`;
 }
 async function readLegacyMarkerFile(dir) {
     const markerPath = path.join(dir, LEGACY_MARKER_FILENAME);
@@ -310,7 +284,9 @@ async function readLegacyMarkerFile(dir) {
             return null;
         if (typeof obj.generatedName !== 'string')
             return null;
-        if (obj.sourceKind !== 'skill' && obj.sourceKind !== 'command')
+        if (obj.sourceKind !== 'skill' &&
+            obj.sourceKind !== 'command' &&
+            obj.sourceKind !== 'agent')
             return null;
         if (typeof obj.sourceRelPath !== 'string')
             return null;
@@ -339,10 +315,17 @@ async function removeLegacyMarkerFile(dir, dryRun) {
     }
 }
 async function loadManagedEntries(targetSkillsDir, dryRun) {
-    const manifest = await readManifestFile(targetSkillsDir);
-    const entries = manifest?.entries
-        ? [...manifest.entries]
-        : [];
+    const allEntries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(targetSkillsDir);
+    const pluginEntries = [];
+    const otherEntries = [];
+    for (const entry of allEntries) {
+        if ((0, SkillsManifest_1.isPluginManifestEntry)(entry)) {
+            pluginEntries.push(entry);
+        }
+        else {
+            otherEntries.push(entry);
+        }
+    }
     // Migration: absorb legacy per-skill markers and remove them so they don't
     // show up in every skill folder.
     let dirents;
@@ -350,7 +333,7 @@ async function loadManagedEntries(targetSkillsDir, dryRun) {
         dirents = await fs.readdir(targetSkillsDir, { withFileTypes: true });
     }
     catch {
-        return entries;
+        return { pluginEntries, otherEntries };
     }
     for (const dirent of dirents) {
         if (!dirent.isDirectory())
@@ -360,22 +343,23 @@ async function loadManagedEntries(targetSkillsDir, dryRun) {
         if (!legacy)
             continue;
         const managed = {
+            sourceType: 'plugin',
             pluginId: legacy.pluginId,
             pluginVersion: legacy.pluginVersion,
             sourceKind: legacy.sourceKind,
             sourceRelPath: legacy.sourceRelPath,
             destRelPath: dirent.name,
         };
-        const already = entries.some((e) => e.destRelPath === managed.destRelPath &&
+        const already = pluginEntries.some((e) => e.destRelPath === managed.destRelPath &&
             e.pluginId === managed.pluginId &&
             e.sourceKind === managed.sourceKind &&
             e.sourceRelPath === managed.sourceRelPath);
         if (!already) {
-            entries.push(managed);
+            pluginEntries.push(managed);
         }
         await removeLegacyMarkerFile(folder, dryRun);
     }
-    return entries;
+    return { pluginEntries, otherEntries };
 }
 async function discoverLocalSkillNames(projectRoot) {
     const localSkillsDir = path.join(projectRoot, '.claude', 'skills');
@@ -406,6 +390,77 @@ async function discoverLocalSkillNames(projectRoot) {
     await walk(localSkillsDir, 0);
     return names;
 }
+async function discoverLocalCommandNames(projectRoot) {
+    const localCommandsDir = path.join(projectRoot, '.claude', 'commands');
+    if (!(await fileExists(localCommandsDir)))
+        return new Set();
+    const names = new Set();
+    async function walk(current, depth) {
+        if (depth >= constants_1.MAX_RECURSION_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            names.add(sanitizeId(path.basename(entry.name, '.md')));
+        }
+    }
+    await walk(localCommandsDir, 0);
+    return names;
+}
+async function discoverLocalAgentNames(projectRoot) {
+    const localAgentsDir = path.join(projectRoot, '.claude', 'agents');
+    if (!(await fileExists(localAgentsDir)))
+        return new Set();
+    const names = new Set();
+    async function walk(current, depth) {
+        if (depth >= constants_1.MAX_RECURSION_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            let content;
+            try {
+                content = await fs.readFile(full, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const parsed = (0, FrontmatterParser_1.parseFrontmatter)(content);
+            const fmName = parsed.rawFrontmatter && typeof parsed.rawFrontmatter.name === 'string'
+                ? parsed.rawFrontmatter.name
+                : parsed.frontmatter?.name;
+            if (typeof fmName !== 'string' || fmName.trim() === '')
+                continue;
+            names.add(sanitizeId(fmName.trim()));
+        }
+    }
+    await walk(localAgentsDir, 0);
+    return names;
+}
 async function ensureDir(dir, dryRun) {
     if (dryRun)
         return;
@@ -439,15 +494,15 @@ async function rewriteSkillMdName(skillMdPath, name, pluginId, dryRun) {
         return;
     await fs.writeFile(skillMdPath, next, 'utf8');
 }
-async function writeCommandAsSkill(srcCommandPath, destDir, generatedName, pluginId, dryRun) {
-    const content = await fs.readFile(srcCommandPath, 'utf8');
+async function writeMarkdownAsSkill(srcMarkdownPath, destDir, generatedName, pluginId, kindLabel, dryRun) {
+    const content = await fs.readFile(srcMarkdownPath, 'utf8');
     const { rawFrontmatter, body } = (0, FrontmatterParser_1.parseFrontmatter)(content);
     const fm = rawFrontmatter
         ? { ...rawFrontmatter }
         : {};
     fm.name = generatedName;
     if (typeof fm.description !== 'string' || fm.description.trim() === '') {
-        fm.description = `Command from ${pluginId}: ${path.basename(srcCommandPath, '.md')}`;
+        fm.description = `${kindLabel} from ${pluginId}: ${path.basename(srcMarkdownPath, '.md')}`;
     }
     const next = `---\n${yaml
         .dump(fm, { lineWidth: -1, noRefs: true })
@@ -466,6 +521,13 @@ async function syncClaudePluginsToSkillsDirs(args) {
     const claudeDir = path.join(getUserHomeDir(), '.claude');
     const index = await readInstalledPluginsIndex(claudeDir);
     const localSkillNames = await discoverLocalSkillNames(projectRoot);
+    const localCommandNames = await discoverLocalCommandNames(projectRoot);
+    const localAgentNames = await discoverLocalAgentNames(projectRoot);
+    const localReservedNames = new Set([
+        ...localSkillNames,
+        ...localCommandNames,
+        ...localAgentNames,
+    ]);
     // If we can't read the installed plugins index, we can't install/update
     // anything, but we can still clean up managed folders for plugins that
     // are no longer enabled.
@@ -473,10 +535,10 @@ async function syncClaudePluginsToSkillsDirs(args) {
         for (const targetSkillsDir of targetSkillsDirs) {
             if (!(await fileExists(targetSkillsDir)))
                 continue;
-            const managedEntries = await loadManagedEntries(targetSkillsDir, dryRun);
+            const { pluginEntries: managedEntries, otherEntries } = await loadManagedEntries(targetSkillsDir, dryRun);
             const nextEntries = [];
             // Build reserved set (local skills always win).
-            const reserved = new Set(localSkillNames);
+            const reserved = new Set(localReservedNames);
             // Also reserve any existing non-managed directories.
             const managedDest = new Set(managedEntries.map((e) => e.destRelPath));
             let dirents = [];
@@ -508,7 +570,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
                 }
                 nextEntries.push(entry);
             }
-            await writeManifestFile(targetSkillsDir, nextEntries, dryRun);
+            await (0, SkillsManifest_1.writeSkillsManifestEntries)(targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
         }
         return;
     }
@@ -553,6 +615,20 @@ async function syncClaudePluginsToSkillsDirs(args) {
                 baseName,
             });
         }
+        const agentFiles = await discoverPluginAgentFiles(plugin.installPath);
+        for (const a of agentFiles) {
+            const baseName = sanitizeId(a.name);
+            const sourceRelPath = `agents/${a.rel}`;
+            expectedItems.push({
+                itemKey: makeItemKey(plugin.pluginId, 'agent', sourceRelPath),
+                pluginId: plugin.pluginId,
+                pluginVersion: plugin.version,
+                kind: 'agent',
+                sourcePath: a.file,
+                sourceRelPath,
+                baseName,
+            });
+        }
     }
     const sortedItems = [...expectedItems].sort((a, b) => {
         const ak = `${a.baseName}::${a.pluginId}::${a.kind}::${a.sourceRelPath}`;
@@ -564,9 +640,13 @@ async function syncClaudePluginsToSkillsDirs(args) {
         const targetExists = await fileExists(targetSkillsDir);
         if (!targetExists && sortedItems.length === 0)
             continue;
-        const managedEntries = targetExists
-            ? await loadManagedEntries(targetSkillsDir, dryRun)
-            : [];
+        let managedEntries = [];
+        let otherEntries = [];
+        if (targetExists) {
+            const loaded = await loadManagedEntries(targetSkillsDir, dryRun);
+            managedEntries = loaded.pluginEntries;
+            otherEntries = loaded.otherEntries;
+        }
         // Map previous destinations by itemKey for stability.
         const prevDestByItemKey = new Map();
         for (const entry of managedEntries) {
@@ -574,7 +654,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
         }
         const managedDest = new Set(managedEntries.map((e) => e.destRelPath));
         // Reserve: local skills always win. Also reserve any existing non-managed folders.
-        const reserved = new Set(localSkillNames);
+        const reserved = new Set(localReservedNames);
         if (targetExists) {
             let dirents = [];
             try {
@@ -599,6 +679,11 @@ async function syncClaudePluginsToSkillsDirs(args) {
             const prev = prevDestByItemKey.get(item.itemKey);
             if (!prev)
                 continue;
+            // Migration: previous versions used `${pluginId}__${name}`.
+            // Don't preserve legacy namespaced destinations so we can rename to the
+            // new `${pluginId}-${name}` format.
+            if (prev.startsWith(`${sanitizeId(item.pluginId)}__`))
+                continue;
             if (taken.has(prev))
                 continue;
             assignedDestByItemKey.set(item.itemKey, prev);
@@ -618,7 +703,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
             let candidate = namespacedBase;
             let i = 2;
             while (taken.has(candidate)) {
-                candidate = `${namespacedBase}__${i++}`;
+                candidate = `${namespacedBase}-${i++}`;
             }
             assignedDestByItemKey.set(item.itemKey, candidate);
             taken.add(candidate);
@@ -658,12 +743,13 @@ async function syncClaudePluginsToSkillsDirs(args) {
                 await removeLegacyMarkerFile(destDir, dryRun);
             }
             else {
+                const kindLabel = item.kind === 'command' ? 'command' : 'agent';
                 (0, constants_1.logVerboseInfo)(dryRun
-                    ? `DRY RUN: Would install plugin command '${destRelPath}' as skill to ${targetSkillsDir}`
-                    : `Installing plugin command '${destRelPath}' as skill to ${targetSkillsDir}`, verbose, dryRun);
+                    ? `DRY RUN: Would install plugin ${kindLabel} '${destRelPath}' as skill to ${targetSkillsDir}`
+                    : `Installing plugin ${kindLabel} '${destRelPath}' as skill to ${targetSkillsDir}`, verbose, dryRun);
                 await ensureDir(destDir, dryRun);
                 if (!dryRun) {
-                    await writeCommandAsSkill(item.sourcePath, destDir, destRelPath, item.pluginId, dryRun);
+                    await writeMarkdownAsSkill(item.sourcePath, destDir, destRelPath, item.pluginId, item.kind === 'command' ? 'Command' : 'Agent', dryRun);
                 }
                 await removeLegacyMarkerFile(destDir, dryRun);
             }
@@ -706,6 +792,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
         // Add expected entries for installed items
         for (const item of assignedItems) {
             nextEntries.push({
+                sourceType: 'plugin',
                 pluginId: item.pluginId,
                 pluginVersion: item.pluginVersion,
                 sourceKind: item.kind,
@@ -713,6 +800,6 @@ async function syncClaudePluginsToSkillsDirs(args) {
                 destRelPath: item.destRelPath,
             });
         }
-        await writeManifestFile(targetSkillsDir, nextEntries, dryRun);
+        await (0, SkillsManifest_1.writeSkillsManifestEntries)(targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
     }
 }

package/dist/core/ClaudeProjectSync.js

@@ -0,0 +1,393 @@
+"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.syncClaudeProjectCommandsAndAgentsToSkillsDirs = syncClaudeProjectCommandsAndAgentsToSkillsDirs;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const constants_1 = require("../constants");
+const FrontmatterParser_1 = require("./FrontmatterParser");
+const SkillsManifest_1 = require("./SkillsManifest");
+const LEGACY_PLUGIN_MARKER_FILENAME = '.skiller-plugin.json';
+function sanitizeId(value) {
+    return value.replace(/[^A-Za-z0-9._-]+/g, '_');
+}
+async function fileExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function makeItemKey(sourceKind, sourceRelPath) {
+    return `${sourceKind}::${sourceRelPath}`;
+}
+function getCommandsRoot(projectRoot) {
+    return path.join(projectRoot, '.claude', 'commands');
+}
+function getAgentsRoot(projectRoot) {
+    return path.join(projectRoot, '.claude', 'agents');
+}
+async function discoverCommandFiles(projectRoot) {
+    const commandsRoot = getCommandsRoot(projectRoot);
+    if (!(await fileExists(commandsRoot)))
+        return [];
+    const results = [];
+    async function walk(current, depth) {
+        if (depth >= constants_1.MAX_RECURSION_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            const name = sanitizeId(path.basename(entry.name, '.md'));
+            const rel = path.relative(projectRoot, full).replace(/\\/g, '/');
+            results.push({ name, file: full, rel });
+        }
+    }
+    await walk(commandsRoot, 0);
+    return results;
+}
+async function discoverAgentFiles(projectRoot) {
+    const agentsRoot = getAgentsRoot(projectRoot);
+    if (!(await fileExists(agentsRoot)))
+        return [];
+    const results = [];
+    async function walk(current, depth) {
+        if (depth >= constants_1.MAX_RECURSION_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            let content;
+            try {
+                content = await fs.readFile(full, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const parsed = (0, FrontmatterParser_1.parseFrontmatter)(content);
+            const fmName = parsed.rawFrontmatter && typeof parsed.rawFrontmatter.name === 'string'
+                ? parsed.rawFrontmatter.name
+                : parsed.frontmatter?.name;
+            if (typeof fmName !== 'string' || fmName.trim() === '')
+                continue;
+            const name = sanitizeId(fmName.trim());
+            const rel = path.relative(projectRoot, full).replace(/\\/g, '/');
+            results.push({ name, file: full, rel });
+        }
+    }
+    await walk(agentsRoot, 0);
+    return results;
+}
+async function ensureDir(dir, dryRun) {
+    if (dryRun)
+        return;
+    await fs.mkdir(dir, { recursive: true });
+}
+async function removeDir(dir, dryRun) {
+    if (dryRun)
+        return;
+    await fs.rm(dir, { recursive: true, force: true });
+}
+async function writeMarkdownAsSkill(srcPath, destDir, generatedName, kindLabel, dryRun) {
+    const content = await fs.readFile(srcPath, 'utf8');
+    const { rawFrontmatter, body } = (0, FrontmatterParser_1.parseFrontmatter)(content);
+    const fm = rawFrontmatter
+        ? { ...rawFrontmatter }
+        : {};
+    fm.name = generatedName;
+    if (typeof fm.description !== 'string' || fm.description.trim() === '') {
+        fm.description = `${kindLabel}: ${path.basename(srcPath, '.md')}`;
+    }
+    const next = `---\n${yaml
+        .dump(fm, { lineWidth: -1, noRefs: true })
+        .trim()}\n---\n\n${body}\n`;
+    if (dryRun)
+        return;
+    await fs.writeFile(path.join(destDir, 'SKILL.md'), next, 'utf8');
+}
+async function readPluginManagedDestNames(targetSkillsDir) {
+    const names = new Set();
+    for (const entry of await (0, SkillsManifest_1.loadSkillsManifestEntries)(targetSkillsDir)) {
+        if ((0, SkillsManifest_1.isPluginManifestEntry)(entry)) {
+            names.add(entry.destRelPath);
+        }
+    }
+    // Legacy: prior versions wrote per-skill plugin marker files. Treat any
+    // folder containing one as plugin-managed so project items can take over.
+    try {
+        const dirents = await fs.readdir(targetSkillsDir, { withFileTypes: true });
+        for (const d of dirents) {
+            if (!d.isDirectory())
+                continue;
+            try {
+                await fs.access(path.join(targetSkillsDir, d.name, LEGACY_PLUGIN_MARKER_FILENAME));
+                names.add(d.name);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return names;
+}
+async function discoverLocalSkillNames(projectRoot) {
+    const localSkillsDir = path.join(projectRoot, '.claude', 'skills');
+    if (!(await fileExists(localSkillsDir)))
+        return new Set();
+    const names = new Set();
+    async function walk(current, depth) {
+        if (depth >= constants_1.MAX_RECURSION_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        const hasSkillMd = entries.some((e) => e.isFile() && e.name === 'SKILL.md');
+        if (hasSkillMd) {
+            names.add(path.basename(current));
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            await walk(path.join(current, entry.name), depth + 1);
+        }
+    }
+    await walk(localSkillsDir, 0);
+    return names;
+}
+async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
+    const { projectRoot, targetSkillsDirs, verbose, dryRun } = args;
+    const localSkillNames = await discoverLocalSkillNames(projectRoot);
+    const commands = await discoverCommandFiles(projectRoot);
+    const agents = await discoverAgentFiles(projectRoot);
+    const expectedItems = [];
+    for (const cmd of commands) {
+        expectedItems.push({
+            itemKey: makeItemKey('command', cmd.rel),
+            sourceKind: 'command',
+            sourcePath: cmd.file,
+            sourceRelPath: cmd.rel,
+            baseName: cmd.name,
+        });
+    }
+    for (const agent of agents) {
+        expectedItems.push({
+            itemKey: makeItemKey('agent', agent.rel),
+            sourceKind: 'agent',
+            sourcePath: agent.file,
+            sourceRelPath: agent.rel,
+            baseName: agent.name,
+        });
+    }
+    const sortedItems = [...expectedItems].sort((a, b) => {
+        const ak = `${a.baseName}::${a.sourceKind}::${a.sourceRelPath}`;
+        const bk = `${b.baseName}::${b.sourceKind}::${b.sourceRelPath}`;
+        return ak.localeCompare(bk);
+    });
+    for (const targetSkillsDir of targetSkillsDirs) {
+        const targetExists = await fileExists(targetSkillsDir);
+        const managedEntries = [];
+        const otherEntries = [];
+        if (targetExists) {
+            const allEntries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(targetSkillsDir);
+            for (const entry of allEntries) {
+                if ((0, SkillsManifest_1.isClaudeManifestEntry)(entry)) {
+                    managedEntries.push(entry);
+                }
+                else {
+                    otherEntries.push(entry);
+                }
+            }
+        }
+        const prevDestByItemKey = new Map();
+        for (const entry of managedEntries) {
+            prevDestByItemKey.set(makeItemKey(entry.sourceKind, entry.sourceRelPath), entry.destRelPath);
+        }
+        const managedDest = new Set(managedEntries.map((e) => e.destRelPath));
+        const pluginManagedDest = targetExists
+            ? await readPluginManagedDestNames(targetSkillsDir)
+            : new Set();
+        const reserved = new Set(localSkillNames);
+        if (targetExists) {
+            let dirents = [];
+            try {
+                dirents = await fs.readdir(targetSkillsDir, { withFileTypes: true });
+            }
+            catch {
+                dirents = [];
+            }
+            for (const d of dirents) {
+                if (!d.isDirectory())
+                    continue;
+                // Reserve any existing folder we do not manage, except plugin-managed
+                // folders (project should be able to take those over).
+                if (!managedDest.has(d.name) && !pluginManagedDest.has(d.name)) {
+                    reserved.add(d.name);
+                }
+            }
+        }
+        const taken = new Set(reserved);
+        const assignedDestByItemKey = new Map();
+        // Preserve previous destinations when they are still available.
+        for (const item of sortedItems) {
+            const prev = prevDestByItemKey.get(item.itemKey);
+            if (!prev)
+                continue;
+            // Migration: previous versions used `claude__<name>`.
+            // Don't preserve legacy namespaced destinations so we can rename to the
+            // new `claude-<name>` format.
+            if (prev.startsWith('claude__'))
+                continue;
+            if (taken.has(prev))
+                continue;
+            assignedDestByItemKey.set(item.itemKey, prev);
+            taken.add(prev);
+        }
+        // Assign baseName, otherwise namespace with "claude-".
+        for (const item of sortedItems) {
+            if (assignedDestByItemKey.has(item.itemKey))
+                continue;
+            const base = item.baseName;
+            if (!taken.has(base)) {
+                assignedDestByItemKey.set(item.itemKey, base);
+                taken.add(base);
+                continue;
+            }
+            const namespacedBase = `claude-${base}`;
+            let candidate = namespacedBase;
+            let i = 2;
+            while (taken.has(candidate)) {
+                candidate = `${namespacedBase}-${i++}`;
+            }
+            assignedDestByItemKey.set(item.itemKey, candidate);
+            taken.add(candidate);
+        }
+        const assignedItems = sortedItems.map((item) => ({
+            ...item,
+            destRelPath: assignedDestByItemKey.get(item.itemKey),
+        }));
+        if (assignedItems.length > 0) {
+            await ensureDir(targetSkillsDir, dryRun);
+        }
+        else if (!targetExists && managedEntries.length === 0) {
+            // Nothing to do.
+            continue;
+        }
+        // Install/update expected items
+        for (const item of assignedItems) {
+            const destRelPath = item.destRelPath;
+            const destDir = path.join(targetSkillsDir, destRelPath);
+            if (await fileExists(destDir)) {
+                const isManagedByProject = managedDest.has(destRelPath);
+                const isManagedByPlugin = pluginManagedDest.has(destRelPath);
+                if (!isManagedByProject && !isManagedByPlugin) {
+                    (0, constants_1.logWarn)(`[claude] Destination exists but is not skiller-managed, skipping: ${destDir}`, dryRun);
+                    continue;
+                }
+                (0, constants_1.logVerboseInfo)(dryRun
+                    ? `DRY RUN: Would update claude ${item.sourceKind} '${destRelPath}' in ${targetSkillsDir}`
+                    : `Updating claude ${item.sourceKind} '${destRelPath}' in ${targetSkillsDir}`, verbose, dryRun);
+                await removeDir(destDir, dryRun);
+            }
+            (0, constants_1.logVerboseInfo)(dryRun
+                ? `DRY RUN: Would install claude ${item.sourceKind} '${destRelPath}' to ${targetSkillsDir}`
+                : `Installing claude ${item.sourceKind} '${destRelPath}' to ${targetSkillsDir}`, verbose, dryRun);
+            await ensureDir(destDir, dryRun);
+            if (!dryRun) {
+                await writeMarkdownAsSkill(item.sourcePath, destDir, destRelPath, item.sourceKind === 'command' ? 'Command' : 'Agent', dryRun);
+            }
+        }
+        // Cleanup stale managed folders
+        const expectedDest = new Set(assignedItems.map((i) => i.destRelPath));
+        const nextEntries = [];
+        for (const entry of managedEntries) {
+            if (expectedDest.has(entry.destRelPath)) {
+                // Still expected; re-add below.
+                continue;
+            }
+            if (reserved.has(entry.destRelPath)) {
+                // User/local took over the folder name; stop managing it but don't delete.
+                continue;
+            }
+            (0, constants_1.logVerboseInfo)(dryRun
+                ? `DRY RUN: Would remove stale claude skill '${entry.destRelPath}' from ${targetSkillsDir}`
+                : `Removing stale claude skill '${entry.destRelPath}' from ${targetSkillsDir}`, verbose, dryRun);
+            await removeDir(path.join(targetSkillsDir, entry.destRelPath), dryRun);
+        }
+        for (const item of assignedItems) {
+            nextEntries.push({
+                sourceType: 'claude',
+                sourceKind: item.sourceKind,
+                sourceRelPath: item.sourceRelPath,
+                destRelPath: item.destRelPath,
+            });
+        }
+        await (0, SkillsManifest_1.writeSkillsManifestEntries)(targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
+    }
+}

package/dist/core/SkillsManifest.js

@@ -0,0 +1,285 @@
+"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.SKILLS_MANIFEST_VERSION = exports.LEGACY_CLAUDE_MANIFEST_FILENAME = exports.LEGACY_PLUGIN_MANIFEST_FILENAME = exports.LEGACY_UNIFIED_SKILLS_MANIFEST_FILENAME = exports.SKILLS_MANIFEST_FILENAME = void 0;
+exports.isPluginManifestEntry = isPluginManifestEntry;
+exports.isClaudeManifestEntry = isClaudeManifestEntry;
+exports.loadSkillsManifestEntries = loadSkillsManifestEntries;
+exports.writeSkillsManifestEntries = writeSkillsManifestEntries;
+exports.listSkillDirectories = listSkillDirectories;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+exports.SKILLS_MANIFEST_FILENAME = '.skiller.json';
+exports.LEGACY_UNIFIED_SKILLS_MANIFEST_FILENAME = '.skiller-skills.json';
+exports.LEGACY_PLUGIN_MANIFEST_FILENAME = '.skiller-plugins.json';
+exports.LEGACY_CLAUDE_MANIFEST_FILENAME = '.skiller-claude.json';
+exports.SKILLS_MANIFEST_VERSION = 1;
+async function fileExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isPluginManifestEntry(entry) {
+    return entry.sourceType === 'plugin';
+}
+function isClaudeManifestEntry(entry) {
+    return entry.sourceType === 'claude';
+}
+function normalizeEntries(entries) {
+    // Dedupe by a stable identity that doesn't depend on JSON key order.
+    const seen = new Set();
+    const out = [];
+    for (const e of entries) {
+        const key = e.sourceType === 'plugin'
+            ? `plugin::${e.destRelPath}::${e.pluginId}::${e.sourceKind}::${e.sourceRelPath}`
+            : `claude::${e.destRelPath}::${e.sourceKind}::${e.sourceRelPath}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(e);
+    }
+    out.sort((a, b) => {
+        const ak = a.sourceType === 'plugin'
+            ? `plugin::${a.destRelPath}::${a.pluginId}::${a.sourceKind}::${a.sourceRelPath}`
+            : `claude::${a.destRelPath}::${a.sourceKind}::${a.sourceRelPath}`;
+        const bk = b.sourceType === 'plugin'
+            ? `plugin::${b.destRelPath}::${b.pluginId}::${b.sourceKind}::${b.sourceRelPath}`
+            : `claude::${b.destRelPath}::${b.sourceKind}::${b.sourceRelPath}`;
+        return ak.localeCompare(bk);
+    });
+    return out;
+}
+function parseUnifiedEntries(raw) {
+    if (!raw || typeof raw !== 'object')
+        return [];
+    const obj = raw;
+    if (!Array.isArray(obj.entries))
+        return [];
+    const entries = [];
+    for (const entry of obj.entries) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const e = entry;
+        const sourceType = e.sourceType;
+        const sourceKind = e.sourceKind;
+        if (sourceType === 'plugin') {
+            if (typeof e.pluginId !== 'string')
+                continue;
+            if (sourceKind !== 'skill' &&
+                sourceKind !== 'command' &&
+                sourceKind !== 'agent')
+                continue;
+            if (typeof e.sourceRelPath !== 'string')
+                continue;
+            if (typeof e.destRelPath !== 'string')
+                continue;
+            entries.push({
+                sourceType: 'plugin',
+                pluginId: e.pluginId,
+                pluginVersion: typeof e.pluginVersion === 'string' ? e.pluginVersion : undefined,
+                sourceKind,
+                sourceRelPath: e.sourceRelPath,
+                destRelPath: e.destRelPath,
+            });
+            continue;
+        }
+        if (sourceType === 'claude') {
+            if (sourceKind !== 'command' && sourceKind !== 'agent')
+                continue;
+            if (typeof e.sourceRelPath !== 'string')
+                continue;
+            if (typeof e.destRelPath !== 'string')
+                continue;
+            entries.push({
+                sourceType: 'claude',
+                sourceKind,
+                sourceRelPath: e.sourceRelPath,
+                destRelPath: e.destRelPath,
+            });
+            continue;
+        }
+    }
+    return entries;
+}
+function parseLegacyPluginEntries(raw) {
+    if (!raw || typeof raw !== 'object')
+        return [];
+    const obj = raw;
+    if (!Array.isArray(obj.entries))
+        return [];
+    const entries = [];
+    for (const entry of obj.entries) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const e = entry;
+        if (typeof e.pluginId !== 'string')
+            continue;
+        const sourceKind = e.sourceKind;
+        if (sourceKind !== 'skill' &&
+            sourceKind !== 'command' &&
+            sourceKind !== 'agent')
+            continue;
+        if (typeof e.sourceRelPath !== 'string')
+            continue;
+        if (typeof e.destRelPath !== 'string')
+            continue;
+        entries.push({
+            sourceType: 'plugin',
+            pluginId: e.pluginId,
+            pluginVersion: typeof e.pluginVersion === 'string' ? e.pluginVersion : undefined,
+            sourceKind,
+            sourceRelPath: e.sourceRelPath,
+            destRelPath: e.destRelPath,
+        });
+    }
+    return entries;
+}
+function parseLegacyClaudeEntries(raw) {
+    if (!raw || typeof raw !== 'object')
+        return [];
+    const obj = raw;
+    if (!Array.isArray(obj.entries))
+        return [];
+    const entries = [];
+    for (const entry of obj.entries) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const e = entry;
+        const sourceKind = e.sourceKind;
+        if (sourceKind !== 'command' && sourceKind !== 'agent')
+            continue;
+        if (typeof e.sourceRelPath !== 'string')
+            continue;
+        if (typeof e.destRelPath !== 'string')
+            continue;
+        entries.push({
+            sourceType: 'claude',
+            sourceKind,
+            sourceRelPath: e.sourceRelPath,
+            destRelPath: e.destRelPath,
+        });
+    }
+    return entries;
+}
+async function loadSkillsManifestEntries(targetSkillsDir) {
+    const manifestPath = path.join(targetSkillsDir, exports.SKILLS_MANIFEST_FILENAME);
+    if (await fileExists(manifestPath)) {
+        try {
+            const raw = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+            return normalizeEntries(parseUnifiedEntries(raw));
+        }
+        catch {
+            return [];
+        }
+    }
+    // Migration: previous versions used a different unified filename.
+    const legacyUnifiedPath = path.join(targetSkillsDir, exports.LEGACY_UNIFIED_SKILLS_MANIFEST_FILENAME);
+    if (await fileExists(legacyUnifiedPath)) {
+        try {
+            const raw = JSON.parse(await fs.readFile(legacyUnifiedPath, 'utf8'));
+            return normalizeEntries(parseUnifiedEntries(raw));
+        }
+        catch {
+            return [];
+        }
+    }
+    // No unified manifest yet: merge legacy manifests if present.
+    const merged = [];
+    const legacyPluginPath = path.join(targetSkillsDir, exports.LEGACY_PLUGIN_MANIFEST_FILENAME);
+    if (await fileExists(legacyPluginPath)) {
+        try {
+            const raw = JSON.parse(await fs.readFile(legacyPluginPath, 'utf8'));
+            merged.push(...parseLegacyPluginEntries(raw));
+        }
+        catch {
+            // ignore
+        }
+    }
+    const legacyClaudePath = path.join(targetSkillsDir, exports.LEGACY_CLAUDE_MANIFEST_FILENAME);
+    if (await fileExists(legacyClaudePath)) {
+        try {
+            const raw = JSON.parse(await fs.readFile(legacyClaudePath, 'utf8'));
+            merged.push(...parseLegacyClaudeEntries(raw));
+        }
+        catch {
+            // ignore
+        }
+    }
+    return normalizeEntries(merged);
+}
+async function writeSkillsManifestEntries(targetSkillsDir, entries, dryRun) {
+    const manifestPath = path.join(targetSkillsDir, exports.SKILLS_MANIFEST_FILENAME);
+    const legacyUnifiedPath = path.join(targetSkillsDir, exports.LEGACY_UNIFIED_SKILLS_MANIFEST_FILENAME);
+    const legacyPluginPath = path.join(targetSkillsDir, exports.LEGACY_PLUGIN_MANIFEST_FILENAME);
+    const legacyClaudePath = path.join(targetSkillsDir, exports.LEGACY_CLAUDE_MANIFEST_FILENAME);
+    const normalized = normalizeEntries(entries);
+    if (normalized.length === 0) {
+        if (dryRun)
+            return;
+        await Promise.allSettled([
+            fs.unlink(manifestPath),
+            fs.unlink(legacyUnifiedPath),
+            fs.unlink(legacyPluginPath),
+            fs.unlink(legacyClaudePath),
+        ]);
+        return;
+    }
+    const manifest = {
+        version: exports.SKILLS_MANIFEST_VERSION,
+        entries: normalized,
+    };
+    if (dryRun)
+        return;
+    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+    // Clean up legacy manifests once unified is written.
+    await Promise.allSettled([
+        fs.unlink(legacyUnifiedPath),
+        fs.unlink(legacyPluginPath),
+        fs.unlink(legacyClaudePath),
+    ]);
+}
+async function listSkillDirectories(targetSkillsDir) {
+    try {
+        const dirents = await fs.readdir(targetSkillsDir, { withFileTypes: true });
+        return dirents.filter((d) => d.isDirectory());
+    }
+    catch {
+        return [];
+    }
+}

package/dist/core/SkillsProcessor.js

@@ -589,6 +589,17 @@ async function propagateSkills(projectRoot, agents, skillsEnabled, verbose, dryR
             }
         }
     }
+    // Sync project Claude commands + agents as skills into agent skills dirs.
+    // This intentionally does NOT write into the committed .claude/skills source-of-truth.
+    if (destinationPaths.size > 0) {
+        const { syncClaudeProjectCommandsAndAgentsToSkillsDirs } = await Promise.resolve().then(() => __importStar(require('./ClaudeProjectSync')));
+        await syncClaudeProjectCommandsAndAgentsToSkillsDirs({
+            projectRoot,
+            targetSkillsDirs: [...destinationPaths],
+            verbose,
+            dryRun,
+        });
+    }
     // Sync Claude plugins (skills + commands converted to skills) into agent skills dirs.
     // This intentionally does NOT write into the committed .claude/skills source-of-truth.
     if (destinationPaths.size > 0) {

package/package.json

@@ -1,79 +1,79 @@
 {
-	"name": "skiller",
-	"version": "0.7.15",
-	"description": "Skiller — apply the same rules to all coding agents",
-	"main": "dist/lib.js",
-	"publishConfig": {
-		"access": "public"
-	},
-	"scripts": {
-		"postinstall": "[ -n \"$CI\" ] || npx skiller@latest apply",
-		"lint": "eslint \"src/**/*.{ts,tsx}\"",
-		"lint:fix": "eslint \"src/**/*.{ts,tsx}\" --fix",
-		"format": "prettier --write \"src/**/*.{ts,tsx,json,md}\"",
-		"test": "jest",
-		"test:watch": "jest --watch",
-		"test:coverage": "jest --coverage",
-		"test:integration": "jest tests/e2e/skiller.integration.test.ts --verbose",
-		"build": "tsc",
-		"release": "pnpm build && pnpm changeset publish"
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/udecode/skiller.git"
-	},
-	"keywords": [
-		"ai",
-		"developer-tools",
-		"copilot",
-		"codex",
-		"claude",
-		"cursor",
-		"aider",
-		"config",
-		"rules",
-		"automation"
-	],
-	"author": "Eleanor Berger",
-	"license": "MIT",
-	"bugs": {
-		"url": "https://github.com/udecode/skiller/issues"
-	},
-	"engines": {
-		"node": ">=18"
-	},
-	"files": [
-		"dist",
-		"README.md",
-		"LICENSE"
-	],
-	"bin": {
-		"skiller": "dist/cli/index.js"
-	},
-	"devDependencies": {
-		"@changesets/changelog-github": "^0.5.2",
-		"@changesets/cli": "2.29.8",
-		"@eslint/js": "^9.39.1",
-		"@types/iarna__toml": "^2.0.5",
-		"@types/jest": "^29.5.14",
-		"@types/js-yaml": "^4.0.9",
-		"@types/node": "^24.9.2",
-		"@types/yargs": "^17.0.34",
-		"@typescript-eslint/eslint-plugin": "^8.46.2",
-		"@typescript-eslint/parser": "^8.46.2",
-		"eslint": "^9.38.0",
-		"eslint-config-prettier": "^10.1.8",
-		"eslint-plugin-prettier": "^5.5.4",
-		"jest": "^29.7.0",
-		"prettier": "^3.6.2",
-		"ts-jest": "^29.4.5",
-		"typescript": "^5.9.3",
-		"typescript-eslint": "^8.46.2"
-	},
-	"dependencies": {
-		"@iarna/toml": "^2.2.5",
-		"js-yaml": "^4.1.0",
-		"yargs": "^18.0.0",
-		"zod": "^4.1.12"
-	}
+  "name": "skiller",
+  "version": "0.7.17",
+  "description": "Skiller — apply the same rules to all coding agents",
+  "main": "dist/lib.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "postinstall": "[ -n \"$CI\" ] || npx skiller@latest apply",
+    "lint": "eslint \"src/**/*.{ts,tsx}\"",
+    "lint:fix": "eslint \"src/**/*.{ts,tsx}\" --fix",
+    "format": "prettier --write \"src/**/*.{ts,tsx,json,md}\"",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:integration": "jest tests/e2e/skiller.integration.test.ts --verbose",
+    "build": "tsc",
+    "release": "pnpm build && pnpm changeset publish"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/udecode/skiller.git"
+  },
+  "keywords": [
+    "ai",
+    "developer-tools",
+    "copilot",
+    "codex",
+    "claude",
+    "cursor",
+    "aider",
+    "config",
+    "rules",
+    "automation"
+  ],
+  "author": "Eleanor Berger",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/udecode/skiller/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "skiller": "dist/cli/index.js"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.5.2",
+    "@changesets/cli": "2.29.8",
+    "@eslint/js": "^9.39.1",
+    "@types/iarna__toml": "^2.0.5",
+    "@types/jest": "^29.5.14",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^24.9.2",
+    "@types/yargs": "^17.0.34",
+    "@typescript-eslint/eslint-plugin": "^8.46.2",
+    "@typescript-eslint/parser": "^8.46.2",
+    "eslint": "^9.38.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "jest": "^29.7.0",
+    "prettier": "^3.6.2",
+    "ts-jest": "^29.4.5",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.2"
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "js-yaml": "^4.1.0",
+    "yargs": "^18.0.0",
+    "zod": "^4.1.12"
+  }
 }