skiller 0.9.6 → 0.9.8

package/README.md

@@ -4,14 +4,16 @@ Apply the same rules (and skills) to multiple AI coding agents.
 
 ```bash
 npx skiller@latest init
-npx skiller@latest apply
+npx skiller@latest install
 ```
 
 ## Skills
 
-- `.claude/skills/` is the committed source of truth
-- On `apply`, skills are synced to the same project skill directories defined by the sibling `skills` project
-- Claude Code plugins, commands, and agents are also synced as skills to other agents
+- `.agents/rules/*.mdc` is local rule authoring
+- `.agents/skills/` is the canonical runtime skill tree
+- `skills-lock.json` is the upstream source of truth for installed skills
+- `skiller install` and `skiller update` use the local `skills` CLI, then auto-run `apply`
+- `skiller apply` stays local and non-destructive
 - See [docs/skills.md](docs/skills.md)
 
 ## MCP

package/dist/cli/commands.js

@@ -5,6 +5,9 @@ const handlers_1 = require("./handlers");
 const index_1 = require("../agents/index");
 function skillsArgsBuilder(y) {
     return y
+        .parserConfiguration({
+        'unknown-options-as-args': true,
+    })
         .option('project-root', {
         type: 'string',
         description: 'Project root directory',
@@ -123,17 +126,43 @@ async function run() {
             description: 'Enable/disable skills support (experimental, default: enabled)',
         });
     }, handlers_1.applyHandler)
-        .command('add [args..]', 'Run the local skills CLI add command', skillsArgsBuilder, handlers_1.addHandler)
-        .command('remove [args..]', 'Run the local skills CLI remove command', skillsArgsBuilder, handlers_1.removeHandler)
+        .command('add [args..]', 'Run the local skills CLI add command', (y) => skillsArgsBuilder(y)
+        .option('verbose', {
+        type: 'boolean',
+        description: 'Enable verbose logging for the follow-up apply step',
+        default: false,
+    })
+        .alias('verbose', 'v'), handlers_1.addHandler)
+        .command('remove [args..]', 'Run the local skills CLI remove command', (y) => skillsArgsBuilder(y)
+        .option('verbose', {
+        type: 'boolean',
+        description: 'Enable verbose logging for the follow-up apply step',
+        default: false,
+    })
+        .alias('verbose', 'v'), handlers_1.removeHandler)
         .command('list [args..]', 'Run the local skills CLI list command', skillsArgsBuilder, handlers_1.listHandler)
         .command('find [args..]', 'Run the local skills CLI find command', skillsArgsBuilder, handlers_1.findHandler)
         .command('check [args..]', 'Run the local skills CLI check command', skillsArgsBuilder, handlers_1.checkHandler)
-        .command('update [args..]', 'Run the local skills CLI update command', skillsArgsBuilder, handlers_1.updateHandler)
+        .command('install [args..]', 'Run the local skills CLI install command, then skiller apply', (y) => skillsArgsBuilder(y)
+        .option('verbose', {
+        type: 'boolean',
+        description: 'Enable verbose logging for the follow-up apply step',
+        default: false,
+    })
+        .alias('verbose', 'v'), handlers_1.installHandler)
+        .command('update [args..]', 'Run the local skills CLI update command, then skiller apply', (y) => skillsArgsBuilder(y)
+        .option('verbose', {
+        type: 'boolean',
+        description: 'Enable verbose logging for the follow-up apply step',
+        default: false,
+    })
+        .alias('verbose', 'v'), handlers_1.updateHandler)
+        .command('outdated [args..]', 'Run the local skills CLI outdated command', skillsArgsBuilder, handlers_1.outdatedHandler)
         .command('skills <subcommand> [args..]', 'Pass through an arbitrary command to the local skills CLI', (y) => skillsArgsBuilder(y).positional('subcommand', {
         type: 'string',
         description: 'The local skills CLI subcommand to run',
     }), handlers_1.skillsHandler)
-        .command('init', 'Scaffold a .claude directory with default files', (y) => {
+        .command('init', 'Scaffold a .agents directory with default files', (y) => {
         return y
             .option('project-root', {
             type: 'string',

package/dist/cli/handlers.js

@@ -38,11 +38,13 @@ exports.initHandler = initHandler;
 exports.migrateClaudePluginsHandler = migrateClaudePluginsHandler;
 exports.migrateRulesToSkillsHandler = migrateRulesToSkillsHandler;
 exports.addHandler = addHandler;
+exports.installHandler = installHandler;
 exports.removeHandler = removeHandler;
 exports.listHandler = listHandler;
 exports.findHandler = findHandler;
 exports.checkHandler = checkHandler;
 exports.updateHandler = updateHandler;
+exports.outdatedHandler = outdatedHandler;
 exports.skillsHandler = skillsHandler;
 exports.revertHandler = revertHandler;
 const lib_1 = require("../lib");
@@ -55,8 +57,10 @@ const ConfigLoader_1 = require("../core/ConfigLoader");
 const ClaudePluginMigration_1 = require("../core/ClaudePluginMigration");
 const RulesToSkillsMigration_1 = require("../core/RulesToSkillsMigration");
 const agents_1 = require("../agents");
+const agents_2 = require("../agents");
 const skills_cli_1 = require("./skills-cli");
 const project_paths_1 = require("../core/project-paths");
+const SkillOwnership_1 = require("../core/SkillOwnership");
 const readline = __importStar(require("readline/promises"));
 async function executeSkillsWrapper(projectRoot, args) {
     try {
@@ -68,9 +72,85 @@ async function executeSkillsWrapper(projectRoot, args) {
         process.exit(1);
     }
 }
+async function applyAfterSkillsLifecycleStep(projectRoot, verbose) {
+    await applyHandler({
+        'project-root': projectRoot,
+        verbose,
+    });
+}
+function normalizeRequestedSkillNames(args) {
+    if (!args || args.length === 0)
+        return [];
+    const names = new Set();
+    for (const arg of args) {
+        if (!arg || arg.startsWith('-') || arg.includes('/'))
+            continue;
+        const normalized = path.basename(arg, '.mdc').trim().replace(/:/g, '-');
+        if (normalized.length > 0) {
+            names.add(normalized);
+        }
+    }
+    return [...names].sort((a, b) => a.localeCompare(b));
+}
+async function scrubRequestedSkillsLockEntries(projectRoot, args) {
+    const requestedNames = new Set(normalizeRequestedSkillNames(args));
+    if (requestedNames.size === 0)
+        return [];
+    const skillsLockPath = path.join(projectRoot, 'skills-lock.json');
+    const raw = await readJsonObject(skillsLockPath);
+    if (!raw)
+        return [];
+    const skills = raw.skills;
+    if (!skills || typeof skills !== 'object')
+        return [];
+    const nextSkills = {};
+    const removedKeys = [];
+    for (const [key, value] of Object.entries(skills)) {
+        if (requestedNames.has(key.replace(/:/g, '-'))) {
+            removedKeys.push(key);
+            continue;
+        }
+        nextSkills[key] = value;
+    }
+    if (removedKeys.length === 0)
+        return [];
+    raw.skills = nextSkills;
+    await fs.writeFile(skillsLockPath, JSON.stringify(raw, null, 2) + '\n');
+    return removedKeys.sort((a, b) => a.localeCompare(b));
+}
+async function pruneRequestedUnmanagedSkillOutputs(projectRoot, args) {
+    const requestedNames = normalizeRequestedSkillNames(args);
+    if (requestedNames.length === 0)
+        return [];
+    const ownership = await (0, SkillOwnership_1.resolveSkillOwnership)(projectRoot);
+    const removableNames = requestedNames.filter((name) => !ownership.upstreamOwned.has(name) && !ownership.localOwned.has(name));
+    if (removableNames.length === 0)
+        return [];
+    const skillDirs = new Set([(0, SkillOwnership_1.getCanonicalSkillsDir)(projectRoot)]);
+    for (const agent of agents_2.allAgents) {
+        if (!agent.supportsNativeSkills?.() || !agent.getSkillsPath)
+            continue;
+        const skillsPath = agent.getSkillsPath(projectRoot);
+        if (skillsPath) {
+            skillDirs.add(skillsPath);
+        }
+    }
+    for (const skillName of removableNames) {
+        for (const skillsDir of skillDirs) {
+            await fs.rm(path.join(skillsDir, skillName), {
+                force: true,
+                recursive: true,
+            });
+        }
+    }
+    return removableNames;
+}
 function buildClaudePluginMigrationArgs(source) {
     return ['add', source, '--agent', 'universal', '--skill', '*', '-y'];
 }
+const LEGACY_EXTERNAL_RULE_REPLACEMENT_SOURCES = new Set([
+    'ratacat/claude-skills',
+]);
 function resolveRegistryMatchSource(match) {
     if (match.source)
         return match.source;
@@ -168,9 +248,8 @@ async function cleanupLegacyClaudePluginState(projectRoot, pluginIds) {
         if (!changed)
             continue;
         manifest.targets = nextTargets;
-        const localSkills = manifest.localSkills;
-        const hasLocalSkills = Array.isArray(localSkills) && localSkills.length > 0;
-        if (Object.keys(nextTargets).length === 0 && !hasLocalSkills) {
+        delete manifest.localSkills;
+        if (Object.keys(nextTargets).length === 0) {
             await fs.rm(manifestPath, { force: true });
             continue;
         }
@@ -205,6 +284,34 @@ async function cleanupMigratedPluginAuxiliaryRules(projectRoot, sources) {
     }
     return removed;
 }
+async function cleanupLegacyExternalRuleMatches(projectRoot) {
+    const plan = await (0, RulesToSkillsMigration_1.planRulesToSkillsMigration)(projectRoot);
+    const removals = new Map();
+    for (const candidate of plan.candidates) {
+        if (!candidate.matches.some((match) => LEGACY_EXTERNAL_RULE_REPLACEMENT_SOURCES.has(resolveRegistryMatchSource(match)))) {
+            continue;
+        }
+        removals.set(candidate.ruleName, {
+            alreadyInstalled: candidate.alreadyInstalled,
+        });
+    }
+    const removed = [...removals.keys()].sort((a, b) => a.localeCompare(b));
+    for (const ruleName of removed) {
+        const removal = removals.get(ruleName);
+        await (0, RulesToSkillsMigration_1.removeLocalRuleReplacementState)(projectRoot, ruleName, false);
+        if (!removal?.alreadyInstalled) {
+            await fs.rm(path.join(projectRoot, '.agents', 'skills', ruleName), {
+                force: true,
+                recursive: true,
+            });
+        }
+        await fs.rm(path.join(projectRoot, '.claude', 'skills', ruleName), {
+            force: true,
+            recursive: true,
+        });
+    }
+    return removed;
+}
 async function promptLine(message) {
     const rl = readline.createInterface({
         input: process.stdin,
@@ -456,6 +563,10 @@ async function migrateClaudePluginsHandler(argv) {
         if (removedAuxiliaryRules.length > 0) {
             console.log(`[skiller] Removed stale plugin-derived local rules:\n${removedAuxiliaryRules.map((name) => `- ${name}`).join('\n')}`);
         }
+        const removedLegacyExternalRules = await cleanupLegacyExternalRuleMatches(projectRoot);
+        if (removedLegacyExternalRules.length > 0) {
+            console.log(`[skiller] Removed legacy external rule matches:\n${removedLegacyExternalRules.map((name) => `- ${name}`).join('\n')}`);
+        }
         if (plan.unresolved.length > 0) {
             console.log(`[skiller] Skipped unresolved plugins:\n${plan.unresolved.map((entry) => `- ${entry.pluginId}: ${entry.reason}`).join('\n')}`);
         }
@@ -523,12 +634,23 @@ async function addHandler(argv) {
         'add',
         ...(argv.args ?? []),
     ]);
+    await applyAfterSkillsLifecycleStep(argv['project-root'], argv.verbose ?? false);
+}
+async function installHandler(argv) {
+    await executeSkillsWrapper(argv['project-root'], [
+        'install',
+        ...(argv.args ?? []),
+    ]);
+    await applyAfterSkillsLifecycleStep(argv['project-root'], argv.verbose ?? false);
 }
 async function removeHandler(argv) {
     await executeSkillsWrapper(argv['project-root'], [
         'remove',
         ...(argv.args ?? []),
     ]);
+    await scrubRequestedSkillsLockEntries(argv['project-root'], argv.args ?? []);
+    await pruneRequestedUnmanagedSkillOutputs(argv['project-root'], argv.args ?? []);
+    await applyAfterSkillsLifecycleStep(argv['project-root'], argv.verbose ?? false);
 }
 async function listHandler(argv) {
     await executeSkillsWrapper(argv['project-root'], [
@@ -553,6 +675,13 @@ async function updateHandler(argv) {
         'update',
         ...(argv.args ?? []),
     ]);
+    await applyAfterSkillsLifecycleStep(argv['project-root'], argv.verbose ?? false);
+}
+async function outdatedHandler(argv) {
+    await executeSkillsWrapper(argv['project-root'], [
+        'outdated',
+        ...(argv.args ?? []),
+    ]);
 }
 async function skillsHandler(argv) {
     await executeSkillsWrapper(argv['project-root'], [

package/dist/core/RulesToSkillsMigration.js

@@ -134,11 +134,7 @@ async function removeLocalRuleReplacementState(projectRoot, ruleName, dryRun) {
     if (!dryRun) {
         await fs.rm(rulePath, { force: true });
     }
-    const localSkillNames = await (0, SkillsManifest_1.loadLocalSkillNames)(projectRoot);
-    if (!localSkillNames.includes(ruleName)) {
-        return;
-    }
-    await (0, SkillsManifest_1.writeLocalSkillNames)(projectRoot, localSkillNames.filter((name) => name !== ruleName), dryRun);
+    await (0, SkillsManifest_1.scrubLegacyLocalSkillsManifest)(projectRoot, dryRun);
 }
 async function planRulesToSkillsMigration(projectRoot, requestedRuleNames) {
     const availableRuleNames = await listRuleNames(projectRoot);

package/dist/core/SkillOwnership.js

@@ -37,14 +37,11 @@ exports.getCanonicalSkillsDir = getCanonicalSkillsDir;
 exports.getCanonicalRulesDir = getCanonicalRulesDir;
 exports.readUpstreamOwnedSkillNames = readUpstreamOwnedSkillNames;
 exports.resolveSkillOwnership = resolveSkillOwnership;
-exports.adoptSkillerOwnedSkillNames = adoptSkillerOwnedSkillNames;
-exports.syncSkillerOwnedSkillNamesFromRules = syncSkillerOwnedSkillNamesFromRules;
 exports.migrateLegacyProjectState = migrateLegacyProjectState;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const yaml = __importStar(require("js-yaml"));
 const project_paths_1 = require("./project-paths");
-const SkillsManifest_1 = require("./SkillsManifest");
 const FrontmatterParser_1 = require("./FrontmatterParser");
 function normalizeSkillNameForFilesystem(name) {
     return name.replace(/:/g, '-');
@@ -321,10 +318,7 @@ async function readUpstreamOwnedSkillNames(projectRoot) {
 }
 async function resolveSkillOwnership(projectRoot) {
     const upstreamOwned = await readUpstreamOwnedSkillNames(projectRoot);
-    const localOwned = new Set([
-        ...(await (0, SkillsManifest_1.loadLocalSkillNames)(projectRoot)),
-        ...(await readLocalRuleSkillNames(projectRoot)),
-    ]);
+    const localOwned = await readLocalRuleSkillNames(projectRoot);
     const canonicalSkillNames = await readCanonicalSkillNames(projectRoot);
     const allExplicitNames = new Set([...upstreamOwned, ...localOwned]);
     const orphaned = new Set([...canonicalSkillNames]
@@ -346,11 +340,11 @@ async function resolveSkillOwnership(projectRoot) {
             if (upstreamOwned.has(name))
                 owners.push('skills-lock.json');
             if (localOwned.has(name))
-                owners.push('local rules/.agents/.skiller.json');
+                owners.push('.agents/rules');
             return `Skill '${name}' has mixed ownership: ${owners.join(', ')}`;
         }),
         ...[...orphaned].map((name) => {
-            return `Canonical skill '${name}' is unmanaged; leaving it untouched because it is not in skills-lock.json, .agents/rules/${name}.mdc, or .agents/.skiller.json localSkills.`;
+            return `Canonical skill '${name}' is unmanaged; leaving it untouched because it is not in skills-lock.json or .agents/rules/${name}.mdc.`;
         }),
     ];
     return {
@@ -361,38 +355,6 @@ async function resolveSkillOwnership(projectRoot) {
         warnings,
     };
 }
-async function adoptSkillerOwnedSkillNames(projectRoot, skillNames, dryRun) {
-    if (skillNames.length === 0)
-        return;
-    const ownership = await resolveSkillOwnership(projectRoot);
-    const next = new Set(ownership.localOwned);
-    for (const name of skillNames) {
-        if (ownership.upstreamOwned.has(name))
-            continue;
-        next.add(name);
-    }
-    await (0, SkillsManifest_1.writeLocalSkillNames)(projectRoot, [...next], dryRun);
-}
-async function syncSkillerOwnedSkillNamesFromRules(projectRoot, dryRun) {
-    const rulesDir = path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, 'rules');
-    let ruleNames = [];
-    try {
-        const entries = await fs.readdir(rulesDir, { withFileTypes: true });
-        ruleNames = entries
-            .filter((entry) => entry.isFile() && entry.name.endsWith('.mdc'))
-            .map((entry) => path.basename(entry.name, '.mdc'))
-            .sort((a, b) => a.localeCompare(b));
-    }
-    catch {
-        ruleNames = [];
-    }
-    const upstreamOwned = await readUpstreamOwnedSkillNames(projectRoot);
-    const nextLocalSkillNames = ruleNames.filter((name) => {
-        return !upstreamOwned.has(name);
-    });
-    await (0, SkillsManifest_1.writeLocalSkillNames)(projectRoot, nextLocalSkillNames, dryRun);
-    return nextLocalSkillNames;
-}
 async function migrateLegacyProjectState(projectRoot, dryRun) {
     const legacyDir = path.join(projectRoot, project_paths_1.LEGACY_SKILLER_DIR);
     const canonicalDir = path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR);
@@ -407,7 +369,10 @@ async function migrateLegacyProjectState(projectRoot, dryRun) {
     const plannedWrites = new Map();
     const deletePaths = new Set();
     const conflicts = [];
-    await planFileMigration(path.join(legacyDir, '.skiller.json'), path.join(canonicalDir, '.skiller.json'), plannedWrites, deletePaths, conflicts);
+    const legacyManifestPath = path.join(legacyDir, '.skiller.json');
+    if (await pathExists(legacyManifestPath)) {
+        deletePaths.add(legacyManifestPath);
+    }
     const legacyConfigPath = path.join(legacyDir, project_paths_1.SKILLER_CONFIG_FILE);
     if (await pathExists(legacyConfigPath)) {
         await planBufferWrite(path.join(canonicalDir, project_paths_1.SKILLER_CONFIG_FILE), Buffer.from(rewriteLegacyAgentIdsInToml(await fs.readFile(legacyConfigPath, 'utf8'))), legacyConfigPath, plannedWrites, conflicts);
@@ -416,11 +381,16 @@ async function migrateLegacyProjectState(projectRoot, dryRun) {
         }
     }
     await planFileMigration(path.join(legacyDir, project_paths_1.PROJECT_AGENTS_FILE), path.join(canonicalDir, project_paths_1.PROJECT_AGENTS_FILE), plannedWrites, deletePaths, conflicts);
-    await planLegacySkillsMigration(path.join(legacyDir, 'skills'), canonicalSkillsDir, plannedWrites, deletePaths, conflicts);
+    if (!(await pathExists(canonicalSkillsDir))) {
+        await planLegacySkillsMigration(path.join(legacyDir, 'skills'), canonicalSkillsDir, plannedWrites, deletePaths, conflicts);
+    }
     await planLegacyRulesMigration(path.join(legacyDir, 'rules'), canonicalRulesDir, canonicalSkillsDir, plannedWrites, deletePaths, conflicts);
     if (conflicts.length > 0) {
         throw new Error(`Legacy .claude migration conflicts:\n- ${conflicts.join('\n- ')}`);
     }
+    if (plannedWrites.size === 0 && deletePaths.size === 0) {
+        return;
+    }
     if (dryRun)
         return;
     for (const [destinationPath, content] of plannedWrites.entries()) {

package/dist/core/SkillsManifest.js

@@ -37,8 +37,7 @@ exports.SKILLS_MANIFEST_VERSION = exports.LEGACY_CLAUDE_MANIFEST_FILENAME = expo
 exports.isPluginManifestEntry = isPluginManifestEntry;
 exports.isClaudeManifestEntry = isClaudeManifestEntry;
 exports.loadSkillsManifestEntries = loadSkillsManifestEntries;
-exports.loadLocalSkillNames = loadLocalSkillNames;
-exports.writeLocalSkillNames = writeLocalSkillNames;
+exports.scrubLegacyLocalSkillsManifest = scrubLegacyLocalSkillsManifest;
 exports.writeSkillsManifestEntries = writeSkillsManifestEntries;
 exports.listSkillDirectories = listSkillDirectories;
 const fs = __importStar(require("fs/promises"));
@@ -191,16 +190,6 @@ function parseProjectTargets(raw) {
     }
     return out;
 }
-function parseLocalSkills(raw) {
-    if (!raw || typeof raw !== 'object')
-        return [];
-    const obj = raw;
-    if (!Array.isArray(obj.localSkills))
-        return [];
-    return [
-        ...new Set(obj.localSkills.filter((v) => typeof v === 'string')),
-    ].sort((a, b) => a.localeCompare(b));
-}
 async function readProjectManifestRaw(projectRoot) {
     const canonicalManifestPath = path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, exports.SKILLS_MANIFEST_FILENAME);
     const legacyManifestPath = path.join(projectRoot, project_paths_1.LEGACY_SKILLER_DIR, exports.SKILLS_MANIFEST_FILENAME);
@@ -336,25 +325,37 @@ async function loadSkillsManifestEntries(projectRoot, targetSkillsDir) {
     // Legacy migration: prior versions stored manifests in the target skills dir.
     return await loadLegacyTargetSkillsManifestEntries(targetSkillsDir);
 }
-async function loadLocalSkillNames(projectRoot) {
-    const raw = await readProjectManifestRaw(projectRoot);
-    return parseLocalSkills(raw);
-}
-async function writeLocalSkillNames(projectRoot, localSkillNames, dryRun) {
-    const projectSkillerDir = path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR);
-    const projectManifestPath = path.join(projectSkillerDir, exports.SKILLS_MANIFEST_FILENAME);
-    const raw = await readProjectManifestRaw(projectRoot);
-    const existingTargets = parseProjectTargets(raw);
-    const nextLocalSkills = [...new Set(localSkillNames)].sort((a, b) => a.localeCompare(b));
+async function normalizeManifestFile(manifestPath, dryRun) {
+    if (!(await fileExists(manifestPath)))
+        return;
+    let raw;
+    try {
+        raw = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+    }
+    catch {
+        return;
+    }
+    const hasLegacyLocalSkills = !!raw &&
+        typeof raw === 'object' &&
+        Array.isArray(raw.localSkills);
+    if (!hasLegacyLocalSkills)
+        return;
     if (dryRun)
         return;
-    await fs.mkdir(projectSkillerDir, { recursive: true });
+    const targets = parseProjectTargets(raw);
+    if (Object.keys(targets).length === 0) {
+        await fs.rm(manifestPath, { force: true });
+        return;
+    }
     const manifest = {
         version: exports.SKILLS_MANIFEST_VERSION,
-        targets: existingTargets,
-        localSkills: nextLocalSkills,
+        targets,
     };
-    await fs.writeFile(projectManifestPath, JSON.stringify(manifest, null, 2) + '\n');
+    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+}
+async function scrubLegacyLocalSkillsManifest(projectRoot, dryRun) {
+    await normalizeManifestFile(path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, exports.SKILLS_MANIFEST_FILENAME), dryRun);
+    await normalizeManifestFile(path.join(projectRoot, project_paths_1.LEGACY_SKILLER_DIR, exports.SKILLS_MANIFEST_FILENAME), dryRun);
 }
 async function writeSkillsManifestEntries(projectRoot, targetSkillsDir, entries, dryRun) {
     const normalized = normalizeEntries(entries);
@@ -365,7 +366,6 @@ async function writeSkillsManifestEntries(projectRoot, targetSkillsDir, entries,
     let existingTargets = {};
     const raw = await readProjectManifestRaw(projectRoot);
     existingTargets = parseProjectTargets(raw);
-    const existingLocalSkills = parseLocalSkills(raw);
     if (normalized.length === 0) {
         delete existingTargets[preferredTargetKey];
         if (preferredTargetKey !== absoluteTargetKey) {
@@ -383,7 +383,7 @@ async function writeSkillsManifestEntries(projectRoot, targetSkillsDir, entries,
     // Ensure `.claude` exists since the manifest lives there.
     await fs.mkdir(projectClaudeDir, { recursive: true });
     const targetKeys = Object.keys(existingTargets).sort((a, b) => a.localeCompare(b));
-    if (targetKeys.length === 0 && existingLocalSkills.length === 0) {
+    if (targetKeys.length === 0) {
         await Promise.allSettled([fs.unlink(projectManifestPath)]);
     }
     else {
@@ -393,7 +393,6 @@ async function writeSkillsManifestEntries(projectRoot, targetSkillsDir, entries,
         const manifest = {
             version: exports.SKILLS_MANIFEST_VERSION,
             targets: nextTargets,
-            localSkills: existingLocalSkills,
         };
         await fs.writeFile(projectManifestPath, JSON.stringify(manifest, null, 2) + '\n');
     }

package/dist/core/SkillsProcessor.js

@@ -52,6 +52,7 @@ const yaml = __importStar(require("js-yaml"));
 const constants_1 = require("../constants");
 const SkillsUtils_1 = require("./SkillsUtils");
 const FrontmatterParser_1 = require("./FrontmatterParser");
+const SkillsManifest_1 = require("./SkillsManifest");
 const SkillOwnership_1 = require("./SkillOwnership");
 const LEGACY_CODEX_SKILLS_PATH = path.join('.codex', 'skills');
 const UNIVERSAL_AGENTS_SKILLS_PATH = path.join('.agents', 'skills');
@@ -476,6 +477,184 @@ async function writeFileIfChanged(targetPath, content, dryRun) {
     }
     return true;
 }
+async function readNormalizedRuleSourceContent(rulePath) {
+    try {
+        return normalizeRuleSourceContent(await fs.readFile(rulePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function getFrontmatterBlock(content) {
+    const match = /^---\n([\s\S]*?)\n---(?:\n|$)/.exec(content);
+    return match ? match[1] : null;
+}
+function stripQuotedValue(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith("'") && trimmed.endsWith("'")) ||
+        (trimmed.startsWith('"') && trimmed.endsWith('"'))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function extractSkillerSourceRelPathFromFrontmatter(content) {
+    const block = getFrontmatterBlock(content);
+    if (!block)
+        return null;
+    let metadataIndent = null;
+    let skillerIndent = null;
+    for (const line of block.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const indent = line.length - line.trimStart().length;
+        if (metadataIndent !== null &&
+            indent <= metadataIndent &&
+            trimmed !== 'metadata:') {
+            metadataIndent = null;
+            skillerIndent = null;
+        }
+        if (skillerIndent !== null &&
+            indent <= skillerIndent &&
+            trimmed !== 'skiller:') {
+            skillerIndent = null;
+        }
+        if (trimmed === 'metadata:') {
+            metadataIndent = indent;
+            skillerIndent = null;
+            continue;
+        }
+        if (metadataIndent !== null && trimmed === 'skiller:') {
+            skillerIndent = indent;
+            continue;
+        }
+        if (skillerIndent !== null && trimmed.startsWith('source:')) {
+            return stripQuotedValue(trimmed.slice('source:'.length));
+        }
+    }
+    return null;
+}
+async function pruneDuplicateClaudeAliasRules(projectRoot, targetSkillsDirs, verbose, dryRun) {
+    const rulesDir = path.join(projectRoot, '.agents', 'rules');
+    const canonicalSkillsDir = path.join(projectRoot, '.agents', 'skills');
+    let ruleEntries;
+    try {
+        ruleEntries = await fs.readdir(rulesDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const pruned = [];
+    for (const entry of ruleEntries) {
+        if (!entry.isFile() || !entry.name.endsWith('.mdc'))
+            continue;
+        const aliasName = path.basename(entry.name, '.mdc');
+        if (!aliasName.startsWith('claude-'))
+            continue;
+        const baseName = aliasName.slice('claude-'.length);
+        if (!baseName)
+            continue;
+        const aliasRulePath = path.join(rulesDir, `${aliasName}.mdc`);
+        const baseRulePath = path.join(rulesDir, `${baseName}.mdc`);
+        const [aliasRuleContent, baseRuleContent] = await Promise.all([
+            readNormalizedRuleSourceContent(aliasRulePath),
+            readNormalizedRuleSourceContent(baseRulePath),
+        ]);
+        if (!aliasRuleContent || !baseRuleContent)
+            continue;
+        if (aliasRuleContent !== baseRuleContent)
+            continue;
+        const deletePaths = [
+            aliasRulePath,
+            path.join(canonicalSkillsDir, aliasName),
+            path.join(projectRoot, LEGACY_CODEX_SKILLS_PATH, aliasName),
+            ...targetSkillsDirs.map((skillsDir) => path.join(skillsDir, aliasName)),
+        ];
+        if (!dryRun) {
+            await Promise.all(deletePaths.map((deletePath) => fs.rm(deletePath, { recursive: true, force: true })));
+        }
+        pruned.push(aliasName);
+        (0, constants_1.logVerboseInfo)(dryRun
+            ? `DRY RUN: Would prune stale claude alias '${aliasName}' because '${baseName}' already exists with identical local rule content`
+            : `Pruned stale claude alias '${aliasName}' because '${baseName}' already exists with identical local rule content`, verbose, dryRun);
+    }
+    return pruned;
+}
+async function pruneCompiledSkillsWithMissingRuleSources(projectRoot, targetSkillsDirs, verbose, dryRun) {
+    const canonicalSkillsDir = path.join(projectRoot, '.agents', 'skills');
+    let skillEntries;
+    try {
+        skillEntries = await fs.readdir(canonicalSkillsDir, {
+            withFileTypes: true,
+        });
+    }
+    catch {
+        return [];
+    }
+    const pruned = [];
+    for (const entry of skillEntries) {
+        if (!entry.isDirectory())
+            continue;
+        const skillName = entry.name;
+        const skillDir = path.join(canonicalSkillsDir, skillName);
+        const skillMdPath = path.join(skillDir, constants_1.SKILL_MD_FILENAME);
+        let skillMdContent;
+        try {
+            skillMdContent = await fs.readFile(skillMdPath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const sourceRelPath = extractSkillerSourceRelPathFromFrontmatter(skillMdContent);
+        if (!sourceRelPath?.startsWith('.agents/rules/'))
+            continue;
+        const sourcePath = path.resolve(projectRoot, sourceRelPath);
+        if (await pathExists(sourcePath))
+            continue;
+        const deletePaths = [
+            skillDir,
+            path.join(projectRoot, LEGACY_CODEX_SKILLS_PATH, skillName),
+            ...targetSkillsDirs.map((skillsDir) => path.join(skillsDir, skillName)),
+        ];
+        if (!dryRun) {
+            await Promise.all(deletePaths.map((deletePath) => fs.rm(deletePath, { recursive: true, force: true })));
+        }
+        pruned.push(skillName);
+        (0, constants_1.logVerboseInfo)(dryRun
+            ? `DRY RUN: Would prune compiled skill '${skillName}' because its source rule is missing: ${sourceRelPath}`
+            : `Pruned compiled skill '${skillName}' because its source rule is missing: ${sourceRelPath}`, verbose, dryRun);
+    }
+    return pruned;
+}
+async function cleanupLegacyClaudeManagedSkillMirrors(projectRoot, targetSkillsDirs, verbose, dryRun) {
+    const cleaned = [];
+    for (const targetSkillsDir of targetSkillsDirs) {
+        const entries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(projectRoot, targetSkillsDir);
+        if (entries.length === 0)
+            continue;
+        const legacyClaudeEntries = entries.filter(SkillsManifest_1.isClaudeManifestEntry);
+        if (legacyClaudeEntries.length === 0)
+            continue;
+        const nextEntries = entries.filter((entry) => !(0, SkillsManifest_1.isClaudeManifestEntry)(entry));
+        const legacyDestPaths = [
+            ...new Set(legacyClaudeEntries.map((entry) => entry.destRelPath)),
+        ];
+        if (!dryRun) {
+            await Promise.all(legacyDestPaths.map((destRelPath) => fs.rm(path.join(targetSkillsDir, destRelPath), {
+                recursive: true,
+                force: true,
+            })));
+        }
+        await (0, SkillsManifest_1.writeSkillsManifestEntries)(projectRoot, targetSkillsDir, nextEntries, dryRun);
+        cleaned.push(...legacyDestPaths.map((destRelPath) => `${targetSkillsDir}:${destRelPath}`));
+        for (const destRelPath of legacyDestPaths) {
+            (0, constants_1.logVerboseInfo)(dryRun
+                ? `DRY RUN: Would remove legacy claude-managed skill mirror '${destRelPath}' from ${targetSkillsDir}`
+                : `Removed legacy claude-managed skill mirror '${destRelPath}' from ${targetSkillsDir}`, verbose, dryRun);
+        }
+    }
+    return cleaned;
+}
 async function extractLocalRulesFromCanonicalSkills(projectRoot, verbose, dryRun) {
     const warnings = [];
     const extracted = [];
@@ -489,7 +668,6 @@ async function extractLocalRulesFromCanonicalSkills(projectRoot, verbose, dryRun
         return { extracted, warnings };
     }
     const entries = await fs.readdir(skillsDir, { withFileTypes: true });
-    const adoptedNames = [];
     for (const entry of entries) {
         if (!entry.isDirectory())
             continue;
@@ -523,15 +701,11 @@ async function extractLocalRulesFromCanonicalSkills(projectRoot, verbose, dryRun
                     : `Extracted local skill source ${skillName} to ${toProjectRelative(projectRoot, rulePath)}`, verbose, dryRun);
             }
             extracted.push(skillName);
-            adoptedNames.push(skillName);
         }
         catch (err) {
             warnings.push(`Failed to extract local rule source for ${skillName}: ${err.message}`);
         }
     }
-    if (adoptedNames.length > 0) {
-        await (0, SkillOwnership_1.adoptSkillerOwnedSkillNames)(projectRoot, adoptedNames, dryRun);
-    }
     return { extracted, warnings };
 }
 async function compileRulesToSkills(skillerDir, projectRoot, verbose, dryRun) {
@@ -550,7 +724,6 @@ async function compileRulesToSkills(skillerDir, projectRoot, verbose, dryRun) {
     const ruleFiles = entries.filter((entry) => {
         return entry.isFile() && entry.name.endsWith('.mdc');
     });
-    const adoptedNames = [];
     for (const ruleFile of ruleFiles) {
         const skillName = path.basename(ruleFile.name, '.mdc');
         if (ownership.upstreamOwned.has(skillName)) {
@@ -592,10 +765,6 @@ async function compileRulesToSkills(skillerDir, projectRoot, verbose, dryRun) {
                 : `Compiled ${toProjectRelative(projectRoot, sourcePath)} to ${toProjectRelative(projectRoot, skillMdPath)}`, verbose, dryRun);
         }
         compiled.push(skillName);
-        adoptedNames.push(skillName);
-    }
-    if (adoptedNames.length > 0) {
-        await (0, SkillOwnership_1.adoptSkillerOwnedSkillNames)(projectRoot, adoptedNames, dryRun);
     }
     return { compiled, warnings };
 }
@@ -866,31 +1035,34 @@ async function propagateSkills(projectRoot, agents, skillsEnabled, verbose, dryR
         (0, constants_1.logVerboseInfo)('Skills support disabled', verbose, dryRun);
         return;
     }
-    if (skillerDir) {
-        const extractedResult = await extractLocalRulesFromCanonicalSkills(projectRoot, verbose, dryRun);
-        for (const warning of extractedResult.warnings) {
-            (0, constants_1.logWarn)(warning, dryRun);
-        }
-        const compileResult = await compileRulesToSkills(skillerDir, projectRoot, verbose, dryRun);
-        for (const warning of compileResult.warnings) {
-            (0, constants_1.logWarn)(warning, dryRun);
-        }
-        await (0, SkillOwnership_1.syncSkillerOwnedSkillNamesFromRules)(projectRoot, dryRun);
-    }
     // Determine canonical skills directory, with legacy fallback for migration.
     const skillsDir = await resolveProjectSkillsDir(projectRoot, skillerDir);
-    // Compute destinations up-front so legacy codex migration can de-duplicate targets.
+    // Compute destinations up-front so cleanup + legacy codex migration can de-duplicate targets.
     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);
             }
         }
     }
+    if (skillerDir) {
+        await (0, SkillsManifest_1.scrubLegacyLocalSkillsManifest)(projectRoot, dryRun);
+        await pruneCompiledSkillsWithMissingRuleSources(projectRoot, [...destinationPaths], verbose, dryRun);
+        await pruneDuplicateClaudeAliasRules(projectRoot, [...destinationPaths], verbose, dryRun);
+        const compileResult = await compileRulesToSkills(skillerDir, projectRoot, verbose, dryRun);
+        for (const warning of compileResult.warnings) {
+            (0, constants_1.logWarn)(warning, dryRun);
+        }
+    }
     await migrateLegacyCodexSkillsDir(skillsDir, destinationPaths);
+    if (destinationPaths.size > 0) {
+        await cleanupLegacyClaudeManagedSkillMirrors(projectRoot, [...destinationPaths], verbose, dryRun);
+    }
+    if (skillerDir) {
+        await pruneDuplicateClaudeAliasRules(projectRoot, [...destinationPaths], verbose, dryRun);
+    }
     // Check if skills directory exists
     let skillsDirExists = true;
     try {
@@ -936,17 +1108,6 @@ 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 canonical .agents/skills source-of-truth.
-    if (destinationPaths.size > 0) {
-        const { syncClaudeProjectCommandsAndAgentsToSkillsDirs } = await Promise.resolve().then(() => __importStar(require('./ClaudeProjectSync')));
-        await syncClaudeProjectCommandsAndAgentsToSkillsDirs({
-            projectRoot,
-            targetSkillsDirs: [...destinationPaths],
-            verbose,
-            dryRun,
-        });
-    }
 }
 /**
  * Recursively finds all folders containing SKILL.md in a directory.

package/package.json

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