skiller 0.7.18 → 0.7.20

package/README.md

@@ -53,27 +53,29 @@ A Claude-centric fork of [ruler](https://github.com/intellectronica/ruler) with
 - Shared paths are deduplicated (Claude/Copilot/Kilo share `.claude/skills`, Goose/Amp share `.agents/skills`)
 - Agent skills directories are auto-added to `.gitignore` (excluding `.claude/skills`)
 - Validates skill structure — warns on missing `SKILL.md`
+- Flattens nested skills into dash-separated names for agent skills dirs (e.g., `workflows/lfg` → `workflows-lfg`)
 
 ## 9. Claude Code Plugins → Skills
 
 - Reads `.claude/settings.json` `enabledPlugins`
 - Reads plugin content from `~/.claude/plugins/marketplaces` (never from `cache/`)
-- Syncs enabled plugin `skills/` into agent skills directories on `skiller apply`
-- Syncs enabled plugin `commands/*.md` as skills (`SKILL.md`) into agent skills directories
+- Syncs enabled plugin `skills/` into agent skills directories on `skiller apply` (recursive, flattened names)
+- Syncs enabled plugin `commands/**/*.md` as skills (`SKILL.md`) into agent skills directories (recursive, flattened names)
 - 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
+- If a name conflicts, local skills win and the plugin item is namespaced as `<pluginName>-<name>` (numeric suffix if multiple enabled plugins share the same name)
+- Tracks plugin-managed items in `.claude/.skiller.json` (per project, grouped by agent skills dir)
 - 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
+- Flattens nested commands into dash-separated names (e.g., `workflows/brainstorm.md` → `workflows-brainstorm`)
 - 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
+- Tracks project-managed items in `.claude/.skiller.json` (per project, grouped by agent skills dir)
 
 ---
 
@@ -605,10 +607,11 @@ Shared paths are deduplicated — agents sharing the same directory only trigger
 If your project enables Claude Code plugins in `.claude/settings.json`, Skiller also syncs plugin content into agent skills directories on `skiller apply`:
 
 - Plugin `skills/` are copied as skills
-- Plugin `commands/*.md` are converted into skills (`SKILL.md`)
+- Plugin `commands/**/*.md` are converted into skills (`SKILL.md`)
+- Plugin `agents/**/*.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.json` in each agent skills directory
+- If a name conflicts, local skills win and the plugin item is namespaced as `<pluginName>-<name>` (numeric suffix if multiple enabled plugins share the same name)
+- Plugin-managed items are tracked via `.claude/.skiller.json` (per project, grouped by agent skills dir)
 
 ### Skills Directory Structure
 

package/dist/core/ClaudePluginSync.js

@@ -126,36 +126,11 @@ function parsePluginId(pluginId) {
         marketplaceId: pluginId.slice(at + 1),
     };
 }
-async function readKnownMarketplaceInstallLocations(claudeDir) {
-    const knownPath = path.join(claudeDir, 'plugins', 'known_marketplaces.json');
-    let raw;
-    try {
-        raw = JSON.parse(await fs.readFile(knownPath, 'utf8'));
-    }
-    catch {
-        return {};
-    }
-    if (!raw || typeof raw !== 'object')
-        return {};
-    const obj = raw;
-    const out = {};
-    for (const [marketplaceId, marketplace] of Object.entries(obj)) {
-        if (!marketplace || typeof marketplace !== 'object')
-            continue;
-        const installLocation = marketplace
-            .installLocation;
-        if (typeof installLocation !== 'string' || installLocation.trim() === '')
-            continue;
-        out[marketplaceId] = installLocation;
-    }
-    return out;
-}
-async function resolvePluginMarketplaceRoot(pluginId, claudeDir, knownMarketplaceInstallLocations) {
+async function resolvePluginMarketplaceRoot(pluginId, claudeDir) {
     const parsed = parsePluginId(pluginId);
     if (!parsed)
         return null;
-    const marketplaceRoot = knownMarketplaceInstallLocations[parsed.marketplaceId] ??
-        path.join(claudeDir, 'plugins', 'marketplaces', parsed.marketplaceId);
+    const marketplaceRoot = path.join(claudeDir, 'plugins', 'marketplaces', parsed.marketplaceId);
     const candidates = [
         path.join(marketplaceRoot, 'plugins', parsed.pluginName),
         path.join(marketplaceRoot, 'external_plugins', parsed.pluginName),
@@ -266,19 +241,31 @@ async function discoverPluginCommandFiles(installPath) {
     const commandsRoot = path.join(installPath, 'commands');
     if (!(await fileExists(commandsRoot)))
         return [];
-    let entries;
-    try {
-        entries = await fs.readdir(commandsRoot, { withFileTypes: true });
-    }
-    catch {
-        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 rel = path.relative(commandsRoot, full).replace(/\\/g, '/');
+            results.push({ rel, file: full });
+        }
     }
-    return entries
-        .filter((e) => e.isFile() && e.name.endsWith('.md'))
-        .map((e) => ({
-        name: path.basename(e.name, '.md'),
-        file: path.join(commandsRoot, e.name),
-    }));
+    await walk(commandsRoot, 0);
+    return results;
 }
 async function discoverPluginAgentFiles(installPath) {
     const agentsRoot = path.join(installPath, 'agents');
@@ -326,13 +313,44 @@ async function discoverPluginAgentFiles(installPath) {
 function generateBaseNameFromRelId(relId) {
     const normalized = relId.replace(/\\/g, '/');
     const segments = normalized.split('/').filter(Boolean);
-    return segments.map(sanitizeId).join('__');
+    return segments.map(sanitizeId).join('-');
+}
+function generateBaseNameFromCommandRelPath(commandRelPath) {
+    const normalized = commandRelPath.replace(/\\/g, '/');
+    const withoutExt = normalized.endsWith('.md')
+        ? normalized.slice(0, -'.md'.length)
+        : normalized;
+    const segments = withoutExt.split('/').filter(Boolean);
+    return segments.map(sanitizeId).join('-');
 }
-function generateBaseNameFromCommand(commandName) {
-    return sanitizeId(commandName);
+function pluginBaseNamespacePrefix(pluginId) {
+    const parsed = parsePluginId(pluginId);
+    if (parsed)
+        return sanitizeId(parsed.pluginName);
+    return sanitizeId(pluginId);
 }
-function generateNamespacedName(pluginId, baseName) {
-    return `${sanitizeId(pluginId)}-${baseName}`;
+function computePluginNamespacePrefixes(pluginIds) {
+    const out = new Map();
+    const pluginIdsByBase = new Map();
+    for (const pluginId of pluginIds) {
+        const base = pluginBaseNamespacePrefix(pluginId);
+        const bucket = pluginIdsByBase.get(base) ?? [];
+        bucket.push(pluginId);
+        pluginIdsByBase.set(base, bucket);
+    }
+    for (const [base, ids] of pluginIdsByBase.entries()) {
+        ids.sort((a, b) => a.localeCompare(b));
+        if (ids.length === 1) {
+            out.set(ids[0], base);
+            continue;
+        }
+        // If multiple enabled plugins share the same plugin name, disambiguate
+        // without including the marketplace in the folder name.
+        ids.forEach((id, idx) => {
+            out.set(id, idx === 0 ? base : `${base}-${idx + 1}`);
+        });
+    }
+    return out;
 }
 async function readLegacyMarkerFile(dir) {
     const markerPath = path.join(dir, LEGACY_MARKER_FILENAME);
@@ -375,8 +393,8 @@ async function removeLegacyMarkerFile(dir, dryRun) {
         // ignore
     }
 }
-async function loadManagedEntries(targetSkillsDir, dryRun) {
-    const allEntries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(targetSkillsDir);
+async function loadManagedEntries(projectRoot, targetSkillsDir, dryRun) {
+    const allEntries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(projectRoot, targetSkillsDir);
     const pluginEntries = [];
     const otherEntries = [];
     for (const entry of allEntries) {
@@ -439,7 +457,14 @@ async function discoverLocalSkillNames(projectRoot) {
         }
         const hasSkillMd = entries.some((e) => e.isFile() && e.name === 'SKILL.md');
         if (hasSkillMd) {
-            names.add(path.basename(current));
+            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) {
@@ -474,7 +499,12 @@ async function discoverLocalCommandNames(projectRoot) {
             }
             if (!entry.isFile() || !entry.name.endsWith('.md'))
                 continue;
-            names.add(sanitizeId(path.basename(entry.name, '.md')));
+            const rel = path.relative(localCommandsDir, full).replace(/\\/g, '/');
+            const withoutExt = rel.endsWith('.md')
+                ? rel.slice(0, -'.md'.length)
+                : rel;
+            const segments = withoutExt.split('/').filter(Boolean);
+            names.add(segments.map(sanitizeId).join('-'));
         }
     }
     await walk(localCommandsDir, 0);
@@ -581,7 +611,6 @@ async function syncClaudePluginsToSkillsDirs(args) {
     }
     const claudeDir = path.join(getUserHomeDir(), '.claude');
     const index = await readInstalledPluginsIndex(claudeDir);
-    const knownMarketplaceInstallLocations = await readKnownMarketplaceInstallLocations(claudeDir);
     const localSkillNames = await discoverLocalSkillNames(projectRoot);
     const localCommandNames = await discoverLocalCommandNames(projectRoot);
     const localAgentNames = await discoverLocalAgentNames(projectRoot);
@@ -593,10 +622,16 @@ async function syncClaudePluginsToSkillsDirs(args) {
     const resolvedSources = [];
     const unresolvedEnabled = new Set();
     for (const pluginId of enabledPlugins) {
-        const pluginRoot = await resolvePluginMarketplaceRoot(pluginId, claudeDir, knownMarketplaceInstallLocations);
+        const pluginRoot = await resolvePluginMarketplaceRoot(pluginId, claudeDir);
         if (!pluginRoot) {
             unresolvedEnabled.add(pluginId);
-            (0, constants_1.logWarn)(`[plugins] Enabled plugin not installed: ${pluginId}`, dryRun);
+            const hasIndexEntry = Boolean(index?.plugins?.[pluginId]?.length);
+            if (hasIndexEntry) {
+                (0, constants_1.logVerboseInfo)(`[plugins] Enabled plugin has no marketplace content, skipping: ${pluginId}`, verbose, dryRun);
+            }
+            else {
+                (0, constants_1.logWarn)(`[plugins] Enabled plugin not installed: ${pluginId}`, dryRun);
+            }
             continue;
         }
         const resolved = index
@@ -626,8 +661,8 @@ async function syncClaudePluginsToSkillsDirs(args) {
         }
         const commandFiles = await discoverPluginCommandFiles(plugin.pluginRoot);
         for (const c of commandFiles) {
-            const baseName = generateBaseNameFromCommand(c.name);
-            const sourceRelPath = `commands/${path.basename(c.file)}`;
+            const baseName = generateBaseNameFromCommandRelPath(c.rel);
+            const sourceRelPath = `commands/${c.rel}`;
             expectedItems.push({
                 itemKey: makeItemKey(plugin.pluginId, 'command', sourceRelPath),
                 pluginId: plugin.pluginId,
@@ -658,6 +693,9 @@ async function syncClaudePluginsToSkillsDirs(args) {
         const bk = `${b.baseName}::${b.pluginId}::${b.kind}::${b.sourceRelPath}`;
         return ak.localeCompare(bk);
     });
+    const pluginNamespacePrefixByPluginId = computePluginNamespacePrefixes([
+        ...new Set(resolvedSources.map((p) => p.pluginId)),
+    ]);
     // Sync into each target skills dir.
     for (const targetSkillsDir of targetSkillsDirs) {
         const targetExists = await fileExists(targetSkillsDir);
@@ -666,7 +704,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
         let managedEntries = [];
         let otherEntries = [];
         if (targetExists) {
-            const loaded = await loadManagedEntries(targetSkillsDir, dryRun);
+            const loaded = await loadManagedEntries(projectRoot, targetSkillsDir, dryRun);
             managedEntries = loaded.pluginEntries;
             otherEntries = loaded.otherEntries;
         }
@@ -702,11 +740,17 @@ 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.
+            const desiredPrefix = pluginNamespacePrefixByPluginId.get(item.pluginId) ??
+                sanitizeId(item.pluginId);
+            // Migration: previous versions used `${pluginId}__${name}`, then
+            // `${pluginId}-${name}`. If we changed the namespace prefix (for example
+            // to omit marketplace), don't preserve the old destination so the item
+            // can be renamed.
             if (prev.startsWith(`${sanitizeId(item.pluginId)}__`))
                 continue;
+            if (prev.startsWith(`${sanitizeId(item.pluginId)}-`) &&
+                desiredPrefix !== sanitizeId(item.pluginId))
+                continue;
             if (taken.has(prev))
                 continue;
             assignedDestByItemKey.set(item.itemKey, prev);
@@ -722,7 +766,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
                 taken.add(base);
                 continue;
             }
-            const namespacedBase = generateNamespacedName(item.pluginId, base);
+            const namespacedBase = `${pluginNamespacePrefixByPluginId.get(item.pluginId) ?? sanitizeId(item.pluginId)}-${base}`;
             let candidate = namespacedBase;
             let i = 2;
             while (taken.has(candidate)) {
@@ -823,6 +867,6 @@ async function syncClaudePluginsToSkillsDirs(args) {
                 destRelPath: item.destRelPath,
             });
         }
-        await (0, SkillsManifest_1.writeSkillsManifestEntries)(targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
+        await (0, SkillsManifest_1.writeSkillsManifestEntries)(projectRoot, targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
     }
 }

package/dist/core/ClaudeProjectSync.js

@@ -85,7 +85,14 @@ async function discoverCommandFiles(projectRoot) {
             }
             if (!entry.isFile() || !entry.name.endsWith('.md'))
                 continue;
-            const name = sanitizeId(path.basename(entry.name, '.md'));
+            const relFromCommands = path
+                .relative(commandsRoot, full)
+                .replace(/\\/g, '/');
+            const withoutExt = relFromCommands.endsWith('.md')
+                ? relFromCommands.slice(0, -'.md'.length)
+                : relFromCommands;
+            const segments = withoutExt.split('/').filter(Boolean);
+            const name = segments.map(sanitizeId).join('-');
             const rel = path.relative(projectRoot, full).replace(/\\/g, '/');
             results.push({ name, file: full, rel });
         }
@@ -164,9 +171,9 @@ async function writeMarkdownAsSkill(srcPath, destDir, generatedName, kindLabel,
         return;
     await fs.writeFile(path.join(destDir, 'SKILL.md'), next, 'utf8');
 }
-async function readPluginManagedDestNames(targetSkillsDir) {
+async function readPluginManagedDestNames(projectRoot, targetSkillsDir) {
     const names = new Set();
-    for (const entry of await (0, SkillsManifest_1.loadSkillsManifestEntries)(targetSkillsDir)) {
+    for (const entry of await (0, SkillsManifest_1.loadSkillsManifestEntries)(projectRoot, targetSkillsDir)) {
         if ((0, SkillsManifest_1.isPluginManifestEntry)(entry)) {
             names.add(entry.destRelPath);
         }
@@ -209,7 +216,14 @@ async function discoverLocalSkillNames(projectRoot) {
         }
         const hasSkillMd = entries.some((e) => e.isFile() && e.name === 'SKILL.md');
         if (hasSkillMd) {
-            names.add(path.basename(current));
+            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) {
@@ -255,7 +269,7 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
         const managedEntries = [];
         const otherEntries = [];
         if (targetExists) {
-            const allEntries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(targetSkillsDir);
+            const allEntries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(projectRoot, targetSkillsDir);
             for (const entry of allEntries) {
                 if ((0, SkillsManifest_1.isClaudeManifestEntry)(entry)) {
                     managedEntries.push(entry);
@@ -271,7 +285,7 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
         }
         const managedDest = new Set(managedEntries.map((e) => e.destRelPath));
         const pluginManagedDest = targetExists
-            ? await readPluginManagedDestNames(targetSkillsDir)
+            ? await readPluginManagedDestNames(projectRoot, targetSkillsDir)
             : new Set();
         const reserved = new Set(localSkillNames);
         if (targetExists) {
@@ -388,6 +402,6 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
                 destRelPath: item.destRelPath,
             });
         }
-        await (0, SkillsManifest_1.writeSkillsManifestEntries)(targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
+        await (0, SkillsManifest_1.writeSkillsManifestEntries)(projectRoot, targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
     }
 }

package/dist/core/SkillsManifest.js

@@ -41,6 +41,8 @@ exports.writeSkillsManifestEntries = writeSkillsManifestEntries;
 exports.listSkillDirectories = listSkillDirectories;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
+// Project-level manifest (stored in `.claude/.skiller.json`) that tracks what
+// Skiller installed into each target agent skills directory for this project.
 exports.SKILLS_MANIFEST_FILENAME = '.skiller.json';
 exports.LEGACY_UNIFIED_SKILLS_MANIFEST_FILENAME = '.skiller-skills.json';
 exports.LEGACY_PLUGIN_MANIFEST_FILENAME = '.skiller-plugins.json';
@@ -137,6 +139,37 @@ function parseUnifiedEntries(raw) {
     }
     return entries;
 }
+function normalizePathForKey(p) {
+    return path.resolve(p).replace(/\\/g, '/');
+}
+function computeTargetKey(projectRoot, targetSkillsDir) {
+    const resolvedProjectRoot = path.resolve(projectRoot);
+    const resolvedTarget = path.resolve(targetSkillsDir);
+    if (resolvedTarget === resolvedProjectRoot)
+        return '.';
+    if (resolvedTarget.startsWith(resolvedProjectRoot + path.sep)) {
+        return path
+            .relative(resolvedProjectRoot, resolvedTarget)
+            .replace(/\\/g, '/');
+    }
+    return normalizePathForKey(resolvedTarget);
+}
+function parseProjectTargets(raw) {
+    if (!raw || typeof raw !== 'object')
+        return {};
+    const obj = raw;
+    if (!obj.targets || typeof obj.targets !== 'object')
+        return {};
+    const targetsObj = obj.targets;
+    const out = {};
+    for (const [targetKey, rawEntries] of Object.entries(targetsObj)) {
+        // Stored as an array of entries per target.
+        if (!Array.isArray(rawEntries))
+            continue;
+        out[targetKey] = normalizeEntries(parseUnifiedEntries({ entries: rawEntries }));
+    }
+    return out;
+}
 function parseLegacyPluginEntries(raw) {
     if (!raw || typeof raw !== 'object')
         return [];
@@ -197,11 +230,11 @@ function parseLegacyClaudeEntries(raw) {
     }
     return entries;
 }
-async function loadSkillsManifestEntries(targetSkillsDir) {
-    const manifestPath = path.join(targetSkillsDir, exports.SKILLS_MANIFEST_FILENAME);
-    if (await fileExists(manifestPath)) {
+async function loadLegacyTargetSkillsManifestEntries(targetSkillsDir) {
+    const legacyManifestPath = path.join(targetSkillsDir, exports.SKILLS_MANIFEST_FILENAME);
+    if (await fileExists(legacyManifestPath)) {
         try {
-            const raw = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+            const raw = JSON.parse(await fs.readFile(legacyManifestPath, 'utf8'));
             return normalizeEntries(parseUnifiedEntries(raw));
         }
         catch {
@@ -243,32 +276,78 @@ async function loadSkillsManifestEntries(targetSkillsDir) {
     }
     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);
+async function loadSkillsManifestEntries(projectRoot, targetSkillsDir) {
+    const projectClaudeDir = path.join(projectRoot, '.claude');
+    const projectManifestPath = path.join(projectClaudeDir, exports.SKILLS_MANIFEST_FILENAME);
+    const preferredTargetKey = computeTargetKey(projectRoot, targetSkillsDir);
+    const absoluteTargetKey = normalizePathForKey(targetSkillsDir);
+    if (await fileExists(projectManifestPath)) {
+        try {
+            const raw = JSON.parse(await fs.readFile(projectManifestPath, 'utf8'));
+            const targets = parseProjectTargets(raw);
+            const entries = targets[preferredTargetKey] ?? targets[absoluteTargetKey] ?? [];
+            return normalizeEntries(entries);
+        }
+        catch {
+            return [];
+        }
+    }
+    // Legacy migration: prior versions stored manifests in the target skills dir.
+    return await loadLegacyTargetSkillsManifestEntries(targetSkillsDir);
+}
+async function writeSkillsManifestEntries(projectRoot, targetSkillsDir, entries, dryRun) {
     const normalized = normalizeEntries(entries);
+    const projectClaudeDir = path.join(projectRoot, '.claude');
+    const projectManifestPath = path.join(projectClaudeDir, exports.SKILLS_MANIFEST_FILENAME);
+    const preferredTargetKey = computeTargetKey(projectRoot, targetSkillsDir);
+    const absoluteTargetKey = normalizePathForKey(targetSkillsDir);
+    let existingTargets = {};
+    if (await fileExists(projectManifestPath)) {
+        try {
+            const raw = JSON.parse(await fs.readFile(projectManifestPath, 'utf8'));
+            existingTargets = parseProjectTargets(raw);
+        }
+        catch {
+            existingTargets = {};
+        }
+    }
     if (normalized.length === 0) {
-        if (dryRun)
-            return;
-        await Promise.allSettled([
-            fs.unlink(manifestPath),
-            fs.unlink(legacyUnifiedPath),
-            fs.unlink(legacyPluginPath),
-            fs.unlink(legacyClaudePath),
-        ]);
-        return;
+        delete existingTargets[preferredTargetKey];
+        if (preferredTargetKey !== absoluteTargetKey) {
+            delete existingTargets[absoluteTargetKey];
+        }
+    }
+    else {
+        existingTargets[preferredTargetKey] = normalized;
+        if (preferredTargetKey !== absoluteTargetKey) {
+            delete existingTargets[absoluteTargetKey];
+        }
     }
-    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.
+    // 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) {
+        await Promise.allSettled([fs.unlink(projectManifestPath)]);
+    }
+    else {
+        const nextTargets = {};
+        for (const key of targetKeys)
+            nextTargets[key] = existingTargets[key];
+        const manifest = {
+            version: exports.SKILLS_MANIFEST_VERSION,
+            targets: nextTargets,
+        };
+        await fs.writeFile(projectManifestPath, JSON.stringify(manifest, null, 2) + '\n');
+    }
+    // Remove legacy per-target manifests so users see a single `.claude/.skiller.json`.
+    const legacyManifestPath = 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);
     await Promise.allSettled([
+        fs.unlink(legacyManifestPath),
         fs.unlink(legacyUnifiedPath),
         fs.unlink(legacyPluginPath),
         fs.unlink(legacyClaudePath),

package/dist/core/SkillsProcessor.js

@@ -462,6 +462,32 @@ async function discoverSkills(projectRoot, skillerDir) {
 async function copySkillsToAgent(sourceSkillsDir, targetSkillsDir, projectRoot, verbose, dryRun) {
     const warnings = [];
     let copied = 0;
+    function sanitizeId(value) {
+        return value.replace(/[^A-Za-z0-9._-]+/g, '_');
+    }
+    function flattenRelativeSkillPath(relativeSkillPath) {
+        const normalized = relativeSkillPath.replace(/\\/g, '/');
+        const segments = normalized.split('/').filter(Boolean);
+        return segments.map(sanitizeId).join('-');
+    }
+    async function rewriteSkillMdName(skillMdPath, name) {
+        let content;
+        try {
+            content = await fs.readFile(skillMdPath, 'utf8');
+        }
+        catch {
+            return;
+        }
+        const { rawFrontmatter, body } = (0, FrontmatterParser_1.parseFrontmatter)(content);
+        const fm = rawFrontmatter
+            ? { ...rawFrontmatter }
+            : {};
+        fm.name = name;
+        const next = `---\n${yaml
+            .dump(fm, { lineWidth: -1, noRefs: true })
+            .trim()}\n---\n\n${body}\n`;
+        await fs.writeFile(skillMdPath, next, 'utf8');
+    }
     try {
         await fs.access(sourceSkillsDir);
     }
@@ -471,8 +497,15 @@ async function copySkillsToAgent(sourceSkillsDir, targetSkillsDir, projectRoot,
     }
     // Use walkSkillsTree to discover skills
     const skillsTree = await (0, SkillsUtils_1.walkSkillsTree)(sourceSkillsDir);
+    // Deterministic order so name collision suffixing is stable.
+    const sortedSkills = [...skillsTree.skills].sort((a, b) => {
+        const ar = path.relative(sourceSkillsDir, a.path).replace(/\\/g, '/');
+        const br = path.relative(sourceSkillsDir, b.path).replace(/\\/g, '/');
+        return ar.localeCompare(br);
+    });
+    const taken = new Set();
     // Validate and copy each skill
-    for (const skill of skillsTree.skills) {
+    for (const skill of sortedSkills) {
         // skill.path is absolute, use it directly
         const skillPath = skill.path;
         const skillMdPath = path.join(skillPath, constants_1.SKILL_MD_FILENAME);
@@ -484,11 +517,23 @@ async function copySkillsToAgent(sourceSkillsDir, targetSkillsDir, projectRoot,
             warnings.push(`Skill '${skill.name}' missing required SKILL.md file, skipping`);
             continue;
         }
-        // Copy skill directory to target using relative path
+        // Flatten nested skills into root-level skill folders for other agents:
+        // `category/foo` -> `category-foo`
         const relativeSkillPath = path.relative(sourceSkillsDir, skill.path);
-        const targetSkillPath = path.join(targetSkillsDir, relativeSkillPath);
+        const baseDestName = flattenRelativeSkillPath(relativeSkillPath);
+        let destName = baseDestName;
+        let i = 2;
+        while (taken.has(destName)) {
+            destName = `${baseDestName}-${i++}`;
+        }
+        taken.add(destName);
+        const targetSkillPath = path.join(targetSkillsDir, destName);
         if (!dryRun) {
             await copySkillDirectoryForNonClaudeAgents(skillPath, targetSkillPath, projectRoot, skillPath);
+            const sourceLeafName = path.basename(skillPath);
+            if (destName !== sourceLeafName) {
+                await rewriteSkillMdName(path.join(targetSkillPath, constants_1.SKILL_MD_FILENAME), destName);
+            }
         }
         (0, constants_1.logVerboseInfo)(dryRun
             ? `DRY RUN: Would copy skill '${skill.name}' to ${targetSkillsDir}`

package/package.json

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