skiller 0.8.2 → 0.9.0

package/dist/core/ClaudePluginSync.js

@@ -485,40 +485,7 @@ async function loadManagedEntries(projectRoot, targetSkillsDir, dryRun) {
     return { pluginEntries, otherEntries };
 }
 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) {
-            const rel = path.relative(localSkillsDir, current).replace(/\\/g, '/');
-            const segments = rel.split('/').filter(Boolean);
-            if (segments.length > 0) {
-                names.add(segments.map(sanitizeId).join('-'));
-            }
-            else {
-                names.add(sanitizeId(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;
+    return new Set(await (0, SkillsManifest_1.loadLocalSkillNames)(projectRoot));
 }
 async function discoverLocalCommandNames(projectRoot) {
     const localCommandsDir = path.join(projectRoot, '.claude', 'commands');

package/dist/core/ClaudeProjectSync.js

@@ -40,7 +40,7 @@ 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';
+const project_paths_1 = require("./project-paths");
 function sanitizeId(value) {
     return value.replace(/[^A-Za-z0-9._-]+/g, '_');
 }
@@ -171,42 +171,21 @@ async function writeMarkdownAsSkill(srcPath, destDir, generatedName, kindLabel,
         return;
     await fs.writeFile(path.join(destDir, 'SKILL.md'), next, 'utf8');
 }
-async function readPluginManagedDestNames(projectRoot, targetSkillsDir) {
-    const names = new Set();
-    for (const entry of await (0, SkillsManifest_1.loadSkillsManifestEntries)(projectRoot, 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(await (0, SkillsManifest_1.loadLocalSkillNames)(projectRoot));
+}
+async function discoverCanonicalSkillNames(projectRoot) {
+    const skillsRoot = path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, 'skills');
+    if (!(await fileExists(skillsRoot)))
         return new Set();
     const names = new Set();
-    async function walk(current, depth) {
+    async function walk(current, rel, depth) {
         if (depth >= constants_1.MAX_RECURSION_DEPTH)
             return;
+        if (rel && (await fileExists(path.join(current, 'SKILL.md')))) {
+            names.add(rel.split('/').filter(Boolean).map(sanitizeId).join('-'));
+            return;
+        }
         let entries;
         try {
             entries = await fs.readdir(current, { withFileTypes: true });
@@ -214,30 +193,20 @@ async function discoverLocalSkillNames(projectRoot) {
         catch {
             return;
         }
-        const hasSkillMd = entries.some((e) => e.isFile() && e.name === 'SKILL.md');
-        if (hasSkillMd) {
-            const rel = path.relative(localSkillsDir, current).replace(/\\/g, '/');
-            const segments = rel.split('/').filter(Boolean);
-            if (segments.length > 0) {
-                names.add(segments.map(sanitizeId).join('-'));
-            }
-            else {
-                names.add(sanitizeId(path.basename(current)));
-            }
-            return;
-        }
         for (const entry of entries) {
             if (!entry.isDirectory())
                 continue;
-            await walk(path.join(current, entry.name), depth + 1);
+            const nextRel = rel ? `${rel}/${entry.name}` : entry.name;
+            await walk(path.join(current, entry.name), nextRel, depth + 1);
         }
     }
-    await walk(localSkillsDir, 0);
+    await walk(skillsRoot, '', 0);
     return names;
 }
 async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
     const { projectRoot, targetSkillsDirs, verbose, dryRun } = args;
     const localSkillNames = await discoverLocalSkillNames(projectRoot);
+    const canonicalSkillNames = await discoverCanonicalSkillNames(projectRoot);
     const commands = await discoverCommandFiles(projectRoot);
     const agents = await discoverAgentFiles(projectRoot);
     const expectedItems = [];
@@ -284,9 +253,23 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
             prevDestByItemKey.set(makeItemKey(entry.sourceKind, entry.sourceRelPath), entry.destRelPath);
         }
         const managedDest = new Set(managedEntries.map((e) => e.destRelPath));
-        const pluginManagedDest = targetExists
-            ? await readPluginManagedDestNames(projectRoot, targetSkillsDir)
-            : new Set();
+        const reservedCanonicalNames = new Set([
+            ...canonicalSkillNames,
+            ...localSkillNames,
+        ]);
+        const canonicalSkillsDir = path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, 'skills');
+        if (path.resolve(targetSkillsDir) === path.resolve(canonicalSkillsDir)) {
+            for (const entry of managedEntries) {
+                reservedCanonicalNames.delete(entry.destRelPath);
+            }
+        }
+        const activeItems = sortedItems.filter((item) => {
+            if (!reservedCanonicalNames.has(item.baseName)) {
+                return true;
+            }
+            (0, constants_1.logVerboseInfo)(`Skipping claude ${item.sourceKind} '${item.baseName}' because canonical skills already own that name`, verbose, dryRun);
+            return false;
+        });
         const reserved = new Set(localSkillNames);
         if (targetExists) {
             let dirents = [];
@@ -299,9 +282,7 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
             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)) {
+                if (!managedDest.has(d.name)) {
                     reserved.add(d.name);
                 }
             }
@@ -309,7 +290,7 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
         const taken = new Set(reserved);
         const assignedDestByItemKey = new Map();
         // Preserve previous destinations when they are still available.
-        for (const item of sortedItems) {
+        for (const item of activeItems) {
             const prev = prevDestByItemKey.get(item.itemKey);
             if (!prev)
                 continue;
@@ -324,7 +305,7 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
             taken.add(prev);
         }
         // Assign baseName, otherwise namespace with "claude-".
-        for (const item of sortedItems) {
+        for (const item of activeItems) {
             if (assignedDestByItemKey.has(item.itemKey))
                 continue;
             const base = item.baseName;
@@ -342,7 +323,7 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
             assignedDestByItemKey.set(item.itemKey, candidate);
             taken.add(candidate);
         }
-        const assignedItems = sortedItems.map((item) => ({
+        const assignedItems = activeItems.map((item) => ({
             ...item,
             destRelPath: assignedDestByItemKey.get(item.itemKey),
         }));
@@ -358,9 +339,7 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
             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) {
+                if (!managedDest.has(destRelPath)) {
                     (0, constants_1.logWarn)(`[claude] Destination exists but is not skiller-managed, skipping: ${destDir}`, dryRun);
                     continue;
                 }

package/dist/core/ConfigLoader.js

@@ -40,6 +40,7 @@ const os = __importStar(require("os"));
 const toml_1 = require("@iarna/toml");
 const zod_1 = require("zod");
 const constants_1 = require("../constants");
+const project_paths_1 = require("./project-paths");
 const mcpConfigSchema = zod_1.z
     .object({
     enabled: zod_1.z.boolean().optional(),
@@ -121,8 +122,7 @@ async function loadConfig(options) {
         configFile = path.resolve(configPath);
     }
     else {
-        // Try local .claude/skiller.toml first
-        const localConfigFile = path.join(projectRoot, '.claude', 'skiller.toml');
+        const localConfigFile = path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, project_paths_1.SKILLER_CONFIG_FILE);
         try {
             await fs_1.promises.access(localConfigFile);
             configFile = localConfigFile;
@@ -236,10 +236,10 @@ async function loadConfig(options) {
     }
     // Deprecation warnings for removed config options
     if ('generate_from_rules' in rawSkillsSection) {
-        console.warn(`[skiller] Warning: skills.generate_from_rules is deprecated and has no effect. Skills are now edited directly in .claude/skills/`);
+        console.warn(`[skiller] Warning: skills.generate_from_rules is deprecated and has no effect. Local rule sources in .agents/rules/ compile automatically into .agents/skills/.`);
     }
     if ('prune' in rawSkillsSection) {
-        console.warn(`[skiller] Warning: skills.prune is deprecated and has no effect. Skills in .claude/skills/ are never auto-deleted.`);
+        console.warn(`[skiller] Warning: skills.prune is deprecated and has no effect. Skills in .agents/skills/ are never auto-deleted.`);
     }
     const rawRulesSection = raw.rules && typeof raw.rules === 'object' && !Array.isArray(raw.rules)
         ? raw.rules

package/dist/core/FileSystemUtils.js

@@ -48,6 +48,7 @@ const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const FrontmatterParser_1 = require("./FrontmatterParser");
 const constants_1 = require("../constants");
+const project_paths_1 = require("./project-paths");
 /**
  * Gets the XDG config directory path, falling back to ~/.config if XDG_CONFIG_HOME is not set.
  */
@@ -55,31 +56,30 @@ function getXdgConfigDir() {
     return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
 }
 /**
- * Searches upwards from startPath to find a .claude directory with skiller.toml.
+ * Searches upwards from startPath to find a .agents directory with skiller.toml.
  * If not found locally and checkGlobal is true, checks for global config at XDG_CONFIG_HOME/skiller.
  * Returns the path to the found directory, or null if not found.
  */
 async function findSkillerDir(startPath, checkGlobal = true) {
-    // Search upwards from startPath for local .claude directory with skiller.toml
+    // Search upwards from startPath for local .agents directory with skiller.toml
     let current = startPath;
     while (current) {
-        const claudeCandidate = path.join(current, '.claude');
+        const skillerCandidate = path.join(current, project_paths_1.CANONICAL_SKILLER_DIR);
         try {
-            const stat = await fs_1.promises.stat(claudeCandidate);
+            const stat = await fs_1.promises.stat(skillerCandidate);
             if (stat.isDirectory()) {
-                // Check if this .claude directory has skiller.toml
-                const tomlPath = path.join(claudeCandidate, 'skiller.toml');
+                const tomlPath = path.join(skillerCandidate, project_paths_1.SKILLER_CONFIG_FILE);
                 try {
                     await fs_1.promises.stat(tomlPath);
-                    return claudeCandidate;
+                    return skillerCandidate;
                 }
                 catch {
-                    // .claude exists but no skiller.toml, continue searching
+                    // .agents exists but no skiller.toml, continue searching
                 }
             }
         }
         catch {
-            // ignore errors when checking for .claude directory
+            // ignore errors when checking for .agents directory
         }
         const parent = path.dirname(current);
         if (parent === current) {
@@ -87,7 +87,7 @@ async function findSkillerDir(startPath, checkGlobal = true) {
         }
         current = parent;
     }
-    // If no local .claude found and checkGlobal is true, check global config directory
+    // If no local .agents found and checkGlobal is true, check global config directory
     if (checkGlobal) {
         const globalConfigDir = path.join(getXdgConfigDir(), 'skiller');
         try {
@@ -96,8 +96,8 @@ async function findSkillerDir(startPath, checkGlobal = true) {
                 return globalConfigDir;
             }
         }
-        catch (err) {
-            console.error(`[skiller] Error checking global config directory ${globalConfigDir}:`, err);
+        catch {
+            // ignore if global config doesn't exist
         }
     }
     return null;
@@ -259,8 +259,8 @@ async function readMarkdownFiles(skillerDir, options) {
     // 2. If AGENTS.md absent but legacy instructions.md present, use it (no longer emits a warning; legacy accepted silently).
     // 3. Include any remaining .md files (excluding whichever of the above was used if present) in
     //    sorted order AFTER the preferred primary file so that new concatenation priority starts with AGENTS.md.
-    const topLevelAgents = path.join(skillerDir, 'AGENTS.md');
-    const topLevelLegacy = path.join(skillerDir, 'instructions.md');
+    const topLevelAgents = path.join(skillerDir, project_paths_1.PROJECT_AGENTS_FILE);
+    const topLevelLegacy = path.join(skillerDir, project_paths_1.LEGACY_INSTRUCTIONS_FILE);
     // Separate primary candidates from others
     let primaryFile = null;
     const others = [];
@@ -284,35 +284,7 @@ async function readMarkdownFiles(skillerDir, options) {
     }
     // Sort the remaining others for stable deterministic concatenation order.
     others.sort((a, b) => a.path.localeCompare(b.path));
-    let ordered = primaryFile ? [primaryFile, ...others] : others;
-    // NEW: Prepend repository root AGENTS.md (outside .claude) if it exists and is not identical path.
-    try {
-        const repoRoot = path.dirname(skillerDir); // .claude parent
-        const rootAgentsPath = path.join(repoRoot, 'AGENTS.md');
-        if (path.resolve(rootAgentsPath) !== path.resolve(topLevelAgents)) {
-            const stat = await fs_1.promises.stat(rootAgentsPath);
-            if (stat.isFile()) {
-                const content = await fs_1.promises.readFile(rootAgentsPath, 'utf8');
-                // Check if this is a generated file and we have other .claude files
-                const isGenerated = content.startsWith('<!-- Generated by Skiller -->');
-                const hasSkillerFiles = others.length > 0 || primaryFile !== null;
-                // Additional check: if AGENTS.md contains skiller source comments and we have skiller files,
-                // it's likely a corrupted generated file that should be skipped
-                const containsSkillerSources = content.includes('<!-- Source: .claude/') ||
-                    content.includes('<!-- Source: claude/');
-                const isProbablyGenerated = isGenerated || (containsSkillerSources && hasSkillerFiles);
-                // Skip generated AGENTS.md if we have other files in .claude
-                if (!isProbablyGenerated || !hasSkillerFiles) {
-                    // Prepend so it has highest precedence
-                    ordered = [{ path: rootAgentsPath, content }, ...ordered];
-                }
-            }
-        }
-    }
-    catch {
-        // ignore if root AGENTS.md not present
-    }
-    return ordered;
+    return primaryFile ? [primaryFile, ...others] : others;
 }
 /**
  * Writes content to filePath, creating parent directories if necessary.
@@ -359,7 +331,7 @@ async function findGlobalSkillerDir() {
 // Alias for backward compatibility
 exports.findGlobalRulerDir = findGlobalSkillerDir;
 /**
- * Searches the entire directory tree from startPath to find all .claude directories with skiller.toml.
+ * Searches the entire directory tree from startPath to find all .agents directories with skiller.toml.
  * Returns an array of directory paths from most specific to least specific.
  */
 async function findAllSkillerDirs(startPath) {
@@ -375,15 +347,14 @@ async function findAllSkillerDirs(startPath) {
             for (const entry of entries) {
                 const fullPath = path.join(dir, entry.name);
                 if (entry.isDirectory()) {
-                    if (entry.name === '.claude') {
-                        // Check if .claude has skiller.toml
-                        const tomlPath = path.join(fullPath, 'skiller.toml');
+                    if (entry.name === project_paths_1.CANONICAL_SKILLER_DIR) {
+                        const tomlPath = path.join(fullPath, project_paths_1.SKILLER_CONFIG_FILE);
                         try {
                             await fs_1.promises.stat(tomlPath);
                             skillerDirs.push(fullPath);
                         }
                         catch {
-                            // .claude exists but no skiller.toml
+                            // .agents exists but no skiller.toml
                         }
                     }
                     else {

package/dist/core/FrontmatterParser.js

@@ -79,7 +79,8 @@ function parseFrontmatter(content) {
         try {
             // Fix common issue: globs as comma-separated unquoted strings
             // Pattern: globs: *.tsx,**/path -> globs: ["*.tsx", "**/path"]
-            const fixedYaml = yamlContent.replace(/^(\s*globs\s*:\s*)([^\n[{]+)$/gm, (match, prefix, value) => {
+            const fixedYaml = yamlContent
+                .replace(/^(\s*globs\s*:\s*)([^\n[{]+)$/gm, (match, prefix, value) => {
                 // Check if value looks like comma-separated patterns (contains * or commas)
                 if (value.includes('*') || value.includes(',')) {
                     // Split by comma and quote each part
@@ -92,6 +93,15 @@ function parseFrontmatter(content) {
                     return `${prefix}[${patterns}]`;
                 }
                 return match;
+            })
+                .replace(/^(\s*[\w.-]+\s*:\s*)([^\n"'[{>|].*:\s.*)$/gm, (match, prefix, value) => {
+                const trimmed = value.trim();
+                if (trimmed.length === 0 ||
+                    /^(true|false|null)$/i.test(trimmed) ||
+                    /^-?\d+(\.\d+)?$/.test(trimmed)) {
+                    return match;
+                }
+                return `${prefix}${JSON.stringify(trimmed)}`;
             });
             // Try parsing again with fixed YAML
             if (fixedYaml !== yamlContent) {

package/dist/core/LegacyClaudePluginState.js

@@ -0,0 +1,123 @@
+"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.assertNoLegacyClaudePluginState = assertNoLegacyClaudePluginState;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const project_paths_1 = require("./project-paths");
+const SkillsManifest_1 = require("./SkillsManifest");
+async function readEnabledPluginIds(projectRoot) {
+    const settingsPath = path.join(projectRoot, project_paths_1.LEGACY_SKILLER_DIR, 'settings.json');
+    try {
+        const raw = JSON.parse(await fs.readFile(settingsPath, 'utf8'));
+        if (!raw || typeof raw !== 'object')
+            return [];
+        const enabledPlugins = raw.enabledPlugins;
+        if (!enabledPlugins || typeof enabledPlugins !== 'object')
+            return [];
+        return Object.entries(enabledPlugins)
+            .filter(([, enabled]) => enabled === true)
+            .map(([pluginId]) => pluginId)
+            .sort((a, b) => a.localeCompare(b));
+    }
+    catch {
+        return [];
+    }
+}
+function readPluginIdsFromManifestRaw(raw) {
+    if (!raw || typeof raw !== 'object')
+        return [];
+    const targets = raw.targets;
+    if (!targets || typeof targets !== 'object')
+        return [];
+    const pluginIds = new Set();
+    for (const rawEntries of Object.values(targets)) {
+        if (!Array.isArray(rawEntries))
+            continue;
+        for (const entry of rawEntries) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const sourceType = entry.sourceType;
+            const pluginId = entry.pluginId;
+            if (sourceType !== 'plugin' || typeof pluginId !== 'string')
+                continue;
+            pluginIds.add(pluginId);
+        }
+    }
+    return [...pluginIds].sort((a, b) => a.localeCompare(b));
+}
+async function readPluginManifestLocations(projectRoot) {
+    const manifestPaths = [
+        path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, SkillsManifest_1.SKILLS_MANIFEST_FILENAME),
+        path.join(projectRoot, project_paths_1.LEGACY_SKILLER_DIR, SkillsManifest_1.SKILLS_MANIFEST_FILENAME),
+    ];
+    const locations = [];
+    for (const manifestPath of manifestPaths) {
+        try {
+            const raw = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+            const pluginIds = readPluginIdsFromManifestRaw(raw);
+            if (pluginIds.length === 0)
+                continue;
+            locations.push({
+                manifestPath,
+                pluginIds,
+            });
+        }
+        catch {
+            // Ignore missing or invalid manifests here. Validation lives elsewhere.
+        }
+    }
+    return locations;
+}
+async function assertNoLegacyClaudePluginState(projectRoot) {
+    const enabledPluginIds = await readEnabledPluginIds(projectRoot);
+    const manifestLocations = await readPluginManifestLocations(projectRoot);
+    if (enabledPluginIds.length === 0 && manifestLocations.length === 0) {
+        return;
+    }
+    const lines = [
+        'Claude plugin sync is no longer supported.',
+        '',
+        'Found legacy Claude plugin state:',
+    ];
+    if (enabledPluginIds.length > 0) {
+        lines.push(`- enabled plugins in .claude/settings.json: ${enabledPluginIds.join(', ')}`);
+    }
+    for (const location of manifestLocations) {
+        lines.push(`- plugin manifest entries in ${path.relative(projectRoot, location.manifestPath)}: ${location.pluginIds.join(', ')}`);
+    }
+    lines.push('', 'Migrate manually:', '1. Run `skiller migrate claude-plugins` to preview the repo installs, then rerun it with `--execute`', '2. Remove the plugin from .claude/settings.json', '3. Rerun `skiller apply`');
+    throw new Error(lines.join('\n'));
+}