skiller 0.9.9 → 0.9.11

package/dist/cli/commands.js

@@ -126,14 +126,14 @@ async function run() {
             description: 'Enable/disable skills support (experimental, default: enabled)',
         });
     }, handlers_1.applyHandler)
-        .command('add [args..]', 'Run the local skills CLI add command', (y) => skillsArgsBuilder(y)
+        .command('add [args..]', 'Run the local skills CLI add command and install compatible agent sources into .agents/skills', (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)
+        .command('remove [args..]', 'Run the local skills CLI remove command, prune compatible agent installs, then skiller apply', (y) => skillsArgsBuilder(y)
         .option('verbose', {
         type: 'boolean',
         description: 'Enable verbose logging for the follow-up apply step',
@@ -143,21 +143,21 @@ async function run() {
         .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('install [args..]', 'Restore lock-backed skills with the local skills CLI experimental_install command, then skiller apply', (y) => skillsArgsBuilder(y)
+        .command('install [args..]', 'Restore lock-backed skills plus skiller-managed agent installs from lockfiles, 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)
+        .command('update [args..]', 'Update local skills CLI installs plus skiller-managed agent installs, 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('outdated [args..]', 'Run the local skills CLI outdated command and report outdated skiller-managed agent installs', 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',

package/dist/cli/handlers.js

@@ -61,6 +61,7 @@ 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 AgentSourceCompatibility_1 = require("../core/AgentSourceCompatibility");
 const readline = __importStar(require("readline/promises"));
 async function executeSkillsWrapper(projectRoot, args) {
     try {
@@ -78,6 +79,46 @@ async function applyAfterSkillsLifecycleStep(projectRoot, verbose) {
         verbose,
     });
 }
+async function pruneSkillOutputs(projectRoot, skillNames) {
+    const normalizedNames = [...new Set(skillNames.filter(Boolean))];
+    if (normalizedNames.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 normalizedNames) {
+        for (const skillsDir of skillDirs) {
+            await fs.rm(path.join(skillsDir, skillName), {
+                force: true,
+                recursive: true,
+            });
+        }
+    }
+}
+async function pruneStaleLockBackedSkills(projectRoot) {
+    const [nativePrune, agentPrune] = await Promise.all([
+        (0, AgentSourceCompatibility_1.pruneMissingNativeSkillsFromLock)(projectRoot),
+        (0, AgentSourceCompatibility_1.pruneMissingAgentSkillsFromLock)(projectRoot),
+    ]);
+    if (nativePrune.prunedOutputNames.length > 0) {
+        await pruneSkillOutputs(projectRoot, nativePrune.prunedOutputNames);
+        console.log(`[skiller] Pruned ${nativePrune.prunedKeys.length} stale upstream skill(s): ${nativePrune.prunedKeys.join(', ')}`);
+    }
+    if (agentPrune.prunedOutputNames.length > 0) {
+        await pruneSkillOutputs(projectRoot, agentPrune.prunedOutputNames);
+        console.log(`[skiller] Pruned ${agentPrune.prunedKeys.length} stale agent-derived skill(s): ${agentPrune.prunedKeys.join(', ')}`);
+    }
+    const warnings = [...nativePrune.warnings, ...agentPrune.warnings];
+    if (warnings.length > 0) {
+        console.log(warnings.map((warning) => `[skiller] ${warning}`).join('\n'));
+    }
+}
 function normalizeRequestedSkillNames(args) {
     if (!args || args.length === 0)
         return [];
@@ -630,27 +671,89 @@ async function migrateRulesToSkillsHandler(argv) {
     }
 }
 async function addHandler(argv) {
-    await executeSkillsWrapper(argv['project-root'], [
-        'add',
-        ...(argv.args ?? []),
-    ]);
-    await applyAfterSkillsLifecycleStep(argv['project-root'], argv.verbose ?? false);
+    const projectRoot = argv['project-root'];
+    const args = argv.args ?? [];
+    if ((0, AgentSourceCompatibility_1.hasGlobalFlag)(args)) {
+        throw new Error('Agent-compatible installs are project-scoped only. Drop --global and retry.');
+    }
+    const source = (0, AgentSourceCompatibility_1.extractAddSource)(args);
+    let inspection;
+    let installedAgentSkills = false;
+    try {
+        if (source) {
+            inspection = await (0, AgentSourceCompatibility_1.inspectCompatibleSource)(source, args);
+        }
+        if (inspection && (0, AgentSourceCompatibility_1.hasListFlag)(args)) {
+            if (inspection.nativeSkillNames.length > 0) {
+                await executeSkillsWrapper(projectRoot, [
+                    'add',
+                    ...(0, AgentSourceCompatibility_1.buildAdjustedSkillsAddArgs)(args, inspection.nativeSkillNames),
+                ]);
+            }
+            if (inspection.agentSkills.length > 0) {
+                console.log('[skiller] Compatible agent-derived skills:');
+                for (const agentSkill of inspection.agentSkills) {
+                    console.log(`- ${agentSkill.installName}`);
+                }
+            }
+            return;
+        }
+        if (inspection && inspection.nativeSkillNames.length > 0) {
+            await executeSkillsWrapper(projectRoot, [
+                'add',
+                ...(0, AgentSourceCompatibility_1.buildAdjustedSkillsAddArgs)(args, inspection.nativeSkillNames),
+            ]);
+        }
+        else if (!inspection || inspection.agentSkills.length === 0) {
+            await executeSkillsWrapper(projectRoot, ['add', ...args]);
+        }
+        if (inspection && inspection.agentSkills.length > 0) {
+            const installed = await (0, AgentSourceCompatibility_1.installAgentSkillsFromInspection)(projectRoot, inspection);
+            installedAgentSkills = true;
+            console.log(`[skiller] Installed ${installed.length} agent-derived skill(s): ${installed.join(', ')}`);
+        }
+    }
+    finally {
+        if (inspection && !installedAgentSkills) {
+            await inspection.workspace.cleanup();
+        }
+    }
+    await applyAfterSkillsLifecycleStep(projectRoot, argv.verbose ?? false);
 }
 async function installHandler(argv) {
+    await pruneStaleLockBackedSkills(argv['project-root']);
     await executeSkillsWrapper(argv['project-root'], [
         'experimental_install',
         ...(argv.args ?? []),
     ]);
+    const restored = await (0, AgentSourceCompatibility_1.restoreAgentSkillsFromLock)(argv['project-root']);
+    if (restored.restored.length > 0) {
+        console.log(`[skiller] Restored ${restored.restored.length} agent-derived skill(s): ${restored.restored.join(', ')}`);
+    }
+    if (restored.warnings.length > 0) {
+        console.log(restored.warnings.map((warning) => `[skiller] ${warning}`).join('\n'));
+    }
     await applyAfterSkillsLifecycleStep(argv['project-root'], argv.verbose ?? false);
 }
 async function removeHandler(argv) {
-    await executeSkillsWrapper(argv['project-root'], [
-        'remove',
-        ...(argv.args ?? []),
-    ]);
+    const projectRoot = argv['project-root'];
+    const args = argv.args ?? [];
+    const requestedNames = normalizeRequestedSkillNames(args);
+    const ownership = await (0, SkillOwnership_1.resolveSkillOwnership)(projectRoot);
+    const shouldRunSkillsRemove = requestedNames.length === 0 ||
+        args.some((arg) => arg === '--all' ||
+            arg === '--agent' ||
+            arg === '-a' ||
+            arg === '--skill' ||
+            arg === '-s') ||
+        requestedNames.some((name) => ownership.upstreamOwned.has(name));
+    if (shouldRunSkillsRemove) {
+        await executeSkillsWrapper(projectRoot, ['remove', ...args]);
+    }
     await scrubRequestedSkillsLockEntries(argv['project-root'], argv.args ?? []);
-    await pruneRequestedUnmanagedSkillOutputs(argv['project-root'], argv.args ?? []);
-    await applyAfterSkillsLifecycleStep(argv['project-root'], argv.verbose ?? false);
+    await pruneRequestedUnmanagedSkillOutputs(projectRoot, args);
+    await (0, AgentSourceCompatibility_1.removeAgentManagedSkills)(projectRoot, requestedNames);
+    await applyAfterSkillsLifecycleStep(projectRoot, argv.verbose ?? false);
 }
 async function listHandler(argv) {
     await executeSkillsWrapper(argv['project-root'], [
@@ -671,10 +774,18 @@ async function checkHandler(argv) {
     ]);
 }
 async function updateHandler(argv) {
+    await pruneStaleLockBackedSkills(argv['project-root']);
     await executeSkillsWrapper(argv['project-root'], [
         'update',
         ...(argv.args ?? []),
     ]);
+    const updated = await (0, AgentSourceCompatibility_1.updateAgentSkillsFromLock)(argv['project-root']);
+    if (updated.updated.length > 0) {
+        console.log(`[skiller] Updated ${updated.updated.length} agent-derived skill(s): ${updated.updated.join(', ')}`);
+    }
+    if (updated.warnings.length > 0) {
+        console.log(updated.warnings.map((warning) => `[skiller] ${warning}`).join('\n'));
+    }
     await applyAfterSkillsLifecycleStep(argv['project-root'], argv.verbose ?? false);
 }
 async function outdatedHandler(argv) {
@@ -682,6 +793,13 @@ async function outdatedHandler(argv) {
         'outdated',
         ...(argv.args ?? []),
     ]);
+    const outdated = await (0, AgentSourceCompatibility_1.getOutdatedAgentSkills)(argv['project-root']);
+    if (outdated.outdated.length > 0) {
+        console.log(`[skiller] Agent-derived updates available:\n${outdated.outdated.map((name) => `- ${name}`).join('\n')}`);
+    }
+    if (outdated.warnings.length > 0) {
+        console.log(outdated.warnings.map((warning) => `[skiller] ${warning}`).join('\n'));
+    }
 }
 async function skillsHandler(argv) {
     await executeSkillsWrapper(argv['project-root'], [

package/dist/core/AgentSourceCompatibility.js

@@ -0,0 +1,824 @@
+"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.parseCompatibleSource = parseCompatibleSource;
+exports.hasListFlag = hasListFlag;
+exports.hasGlobalFlag = hasGlobalFlag;
+exports.extractAddSource = extractAddSource;
+exports.buildAdjustedSkillsAddArgs = buildAdjustedSkillsAddArgs;
+exports.inspectCompatibleSource = inspectCompatibleSource;
+exports.installAgentSkillsFromInspection = installAgentSkillsFromInspection;
+exports.restoreAgentSkillsFromLock = restoreAgentSkillsFromLock;
+exports.getOutdatedAgentSkills = getOutdatedAgentSkills;
+exports.updateAgentSkillsFromLock = updateAgentSkillsFromLock;
+exports.removeAgentManagedSkills = removeAgentManagedSkills;
+exports.pruneMissingNativeSkillsFromLock = pruneMissingNativeSkillsFromLock;
+exports.pruneMissingAgentSkillsFromLock = pruneMissingAgentSkillsFromLock;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const yaml = __importStar(require("js-yaml"));
+const child_process_1 = require("child_process");
+const FrontmatterParser_1 = require("./FrontmatterParser");
+const SkillerLock_1 = require("./SkillerLock");
+const CANONICAL_SKILLS_DIR = path.join('.agents', 'skills');
+const LEGACY_CLAUDE_SKILLS_DIR = path.join('.claude', 'skills');
+const SKIP_DIRS = new Set([
+    '.git',
+    '.next',
+    'build',
+    'coverage',
+    'dist',
+    'fixtures',
+    'node_modules',
+    'test',
+    'tests',
+    'tmp',
+    'tmp-fixtures',
+]);
+const NATIVE_SKILLS_LOCK_VERSION = 1;
+function hashContent(content) {
+    return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
+}
+function normalizeSkillNameForFilesystem(name) {
+    return name.trim().replace(/:/g, '-');
+}
+function createEmptyNativeSkillsLock() {
+    return {
+        version: NATIVE_SKILLS_LOCK_VERSION,
+        skills: {},
+    };
+}
+async function readNativeSkillsLock(projectRoot) {
+    try {
+        const raw = JSON.parse(await fs.readFile(path.join(projectRoot, 'skills-lock.json'), 'utf8'));
+        if (raw.version !== NATIVE_SKILLS_LOCK_VERSION ||
+            !raw.skills ||
+            typeof raw.skills !== 'object') {
+            return createEmptyNativeSkillsLock();
+        }
+        return raw;
+    }
+    catch {
+        return createEmptyNativeSkillsLock();
+    }
+}
+async function writeNativeSkillsLock(projectRoot, lock) {
+    const sortedSkills = {};
+    for (const key of Object.keys(lock.skills).sort((a, b) => a.localeCompare(b))) {
+        sortedSkills[key] = lock.skills[key];
+    }
+    await fs.writeFile(path.join(projectRoot, 'skills-lock.json'), JSON.stringify({
+        version: NATIVE_SKILLS_LOCK_VERSION,
+        skills: sortedSkills,
+    }, null, 2) + '\n', 'utf8');
+}
+function isLocalPath(input) {
+    return (path.isAbsolute(input) ||
+        input.startsWith('./') ||
+        input.startsWith('../') ||
+        input === '.' ||
+        input === '..' ||
+        /^[a-zA-Z]:[/\\]/.test(input));
+}
+function sanitizeSubpath(subpath) {
+    const normalized = subpath.replace(/\\/g, '/');
+    for (const segment of normalized.split('/')) {
+        if (segment === '..') {
+            throw new Error(`Unsafe subpath '${subpath}'`);
+        }
+    }
+    return normalized;
+}
+function inferLocalSourceRootFromFile(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const agentMarker = '/agents/';
+    const skillsMarker = '/skills/';
+    if (normalized.includes(agentMarker)) {
+        return filePath.slice(0, normalized.indexOf(agentMarker));
+    }
+    if (normalized.includes(skillsMarker)) {
+        return filePath.slice(0, normalized.indexOf(skillsMarker));
+    }
+    return path.dirname(filePath);
+}
+function parseCompatibleSource(input) {
+    const trimmed = input.trim();
+    if (isLocalPath(trimmed)) {
+        return {
+            source: path.resolve(trimmed),
+            type: 'local',
+            url: path.resolve(trimmed),
+        };
+    }
+    const githubPrefixMatch = trimmed.match(/^github:(.+)$/);
+    if (githubPrefixMatch) {
+        return parseCompatibleSource(githubPrefixMatch[1]);
+    }
+    const githubBlobMatch = trimmed.match(/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)/);
+    if (githubBlobMatch) {
+        const [, owner, repo, ref, subpath] = githubBlobMatch;
+        return {
+            ref,
+            source: `${owner}/${repo.replace(/\.git$/, '')}`,
+            subpath: sanitizeSubpath(subpath),
+            type: 'github',
+            url: `https://github.com/${owner}/${repo.replace(/\.git$/, '')}.git`,
+        };
+    }
+    const githubTreeWithPathMatch = trimmed.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/);
+    if (githubTreeWithPathMatch) {
+        const [, owner, repo, ref, subpath] = githubTreeWithPathMatch;
+        return {
+            ref,
+            source: `${owner}/${repo.replace(/\.git$/, '')}`,
+            subpath: sanitizeSubpath(subpath),
+            type: 'github',
+            url: `https://github.com/${owner}/${repo.replace(/\.git$/, '')}.git`,
+        };
+    }
+    const githubTreeMatch = trimmed.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)$/);
+    if (githubTreeMatch) {
+        const [, owner, repo, ref] = githubTreeMatch;
+        return {
+            ref,
+            source: `${owner}/${repo.replace(/\.git$/, '')}`,
+            type: 'github',
+            url: `https://github.com/${owner}/${repo.replace(/\.git$/, '')}.git`,
+        };
+    }
+    const githubRepoMatch = trimmed.match(/github\.com\/([^/]+)\/([^/]+)/);
+    if (githubRepoMatch) {
+        const [, owner, repo] = githubRepoMatch;
+        return {
+            source: `${owner}/${repo.replace(/\.git$/, '')}`,
+            type: 'github',
+            url: `https://github.com/${owner}/${repo.replace(/\.git$/, '')}.git`,
+        };
+    }
+    const shorthandMatch = trimmed.match(/^([^/]+)\/([^/]+)$/);
+    if (shorthandMatch) {
+        const [, owner, repo] = shorthandMatch;
+        return {
+            source: `${owner}/${repo}`,
+            type: 'github',
+            url: `https://github.com/${owner}/${repo}.git`,
+        };
+    }
+    if (trimmed.startsWith('git@') ||
+        trimmed.startsWith('https://') ||
+        trimmed.startsWith('http://')) {
+        return {
+            source: trimmed,
+            type: 'git',
+            url: trimmed,
+        };
+    }
+    throw new Error(`Unsupported source '${input}'`);
+}
+async function runGitClone(url, ref) {
+    const cloneDir = await fs.mkdtemp(path.join(os.tmpdir(), 'skiller-agents-'));
+    const args = ['clone', '--depth', '1'];
+    if (ref) {
+        args.push('--branch', ref);
+    }
+    args.push(url, cloneDir);
+    await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)('git', args, {
+            env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            stdio: 'pipe',
+        });
+        let stderr = '';
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('error', reject);
+        child.on('exit', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(stderr.trim() || `git clone failed with exit code ${code}`));
+        });
+    });
+    return cloneDir;
+}
+async function withSourceWorkspace(rawSource) {
+    const parsed = parseCompatibleSource(rawSource);
+    return withParsedSourceWorkspace(parsed);
+}
+async function withParsedSourceWorkspace(parsed) {
+    if (parsed.type === 'local') {
+        const targetPath = parsed.subpath
+            ? path.join(parsed.url, parsed.subpath)
+            : parsed.url;
+        let rootPath = parsed.url;
+        let searchPath = targetPath;
+        try {
+            const stats = await fs.stat(targetPath);
+            if (stats.isFile()) {
+                rootPath = inferLocalSourceRootFromFile(targetPath);
+                searchPath = targetPath;
+            }
+        }
+        catch {
+            // Let downstream callers surface missing paths consistently.
+        }
+        return {
+            cleanup: async () => undefined,
+            parsed,
+            rootPath,
+            searchPath,
+        };
+    }
+    const cloneDir = await runGitClone(parsed.url, parsed.ref);
+    const searchPath = parsed.subpath
+        ? path.join(cloneDir, parsed.subpath)
+        : cloneDir;
+    return {
+        cleanup: async () => {
+            await fs.rm(cloneDir, { force: true, recursive: true });
+        },
+        parsed,
+        rootPath: cloneDir,
+        searchPath,
+    };
+}
+function parseSourceFromLockEntry(entry) {
+    if (entry.sourceType === 'local') {
+        return {
+            ref: entry.ref,
+            source: entry.source,
+            subpath: entry.subpath,
+            type: 'local',
+            url: entry.source,
+        };
+    }
+    if (entry.sourceType === 'github') {
+        return {
+            ref: entry.ref,
+            source: entry.source,
+            subpath: entry.subpath,
+            type: 'github',
+            url: `https://github.com/${entry.source}.git`,
+        };
+    }
+    return {
+        ref: entry.ref,
+        source: entry.source,
+        subpath: entry.subpath,
+        type: 'git',
+        url: entry.source,
+    };
+}
+function cloneRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    return { ...value };
+}
+function buildCompiledSkillContent(name, rawFrontmatter, body, sourceRelPath) {
+    const frontmatter = rawFrontmatter ? { ...rawFrontmatter } : {};
+    if (typeof frontmatter.name !== 'string' || frontmatter.name.length === 0) {
+        frontmatter.name = name;
+    }
+    if (typeof frontmatter.description !== 'string' ||
+        frontmatter.description.length === 0) {
+        frontmatter.description = `Skill: ${name}`;
+    }
+    const metadata = cloneRecord(frontmatter.metadata);
+    const skiller = cloneRecord(metadata.skiller);
+    skiller.source = sourceRelPath;
+    metadata.skiller = skiller;
+    frontmatter.metadata = metadata;
+    return `---
+${yaml.dump(frontmatter, { lineWidth: -1, noRefs: true }).trim()}
+---
+
+${body.trim()}
+`;
+}
+function shouldSkipDir(name) {
+    return SKIP_DIRS.has(name);
+}
+function isValidRelativePath(value) {
+    return value.startsWith('./');
+}
+async function collectDeclaredPluginBases(basePath) {
+    const pluginBases = new Set();
+    try {
+        const marketplace = JSON.parse(await fs.readFile(path.join(basePath, '.claude-plugin', 'marketplace.json'), 'utf8'));
+        const pluginRoot = marketplace.metadata?.pluginRoot;
+        const validPluginRoot = pluginRoot === undefined || isValidRelativePath(pluginRoot);
+        if (validPluginRoot) {
+            for (const plugin of marketplace.plugins ?? []) {
+                if (typeof plugin.source !== 'string')
+                    continue;
+                if (!isValidRelativePath(plugin.source))
+                    continue;
+                pluginBases.add(path.join(basePath, pluginRoot ?? '', plugin.source));
+            }
+        }
+    }
+    catch {
+        // Ignore invalid or missing marketplace manifests.
+    }
+    try {
+        await fs.access(path.join(basePath, '.claude-plugin', 'plugin.json'));
+        pluginBases.add(basePath);
+    }
+    catch {
+        // Ignore.
+    }
+    return [...pluginBases];
+}
+async function discoverAgentFiles(basePath, rootPath = basePath) {
+    try {
+        const stats = await fs.stat(basePath);
+        if (stats.isFile()) {
+            if (!basePath.endsWith('.md'))
+                return [];
+            return [
+                {
+                    absolutePath: basePath,
+                    relativePath: path.relative(rootPath, basePath).replace(/\\/g, '/'),
+                },
+            ];
+        }
+    }
+    catch {
+        return [];
+    }
+    const discovered = new Map();
+    const candidateDirs = new Set([path.join(basePath, 'agents')]);
+    for (const pluginBase of await collectDeclaredPluginBases(basePath)) {
+        candidateDirs.add(path.join(pluginBase, 'agents'));
+    }
+    const walk = async (currentDir, depth) => {
+        if (depth > 8)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(currentDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const absolutePath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                if (shouldSkipDir(entry.name))
+                    continue;
+                if (entry.name === 'agents') {
+                    candidateDirs.add(absolutePath);
+                }
+                await walk(absolutePath, depth + 1);
+                continue;
+            }
+        }
+    };
+    await walk(basePath, 0);
+    const collectMarkdown = async (dir, depth) => {
+        if (depth > 8)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const absolutePath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (shouldSkipDir(entry.name))
+                    continue;
+                await collectMarkdown(absolutePath, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            const relativePath = path
+                .relative(basePath, absolutePath)
+                .replace(/\\/g, '/');
+            discovered.set(relativePath, { absolutePath, relativePath });
+        }
+    };
+    for (const candidateDir of candidateDirs) {
+        await collectMarkdown(candidateDir, 0);
+    }
+    return [...discovered.values()].sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+async function discoverSkillNames(basePath) {
+    try {
+        const stats = await fs.stat(basePath);
+        if (stats.isFile()) {
+            if (path.basename(basePath) !== 'SKILL.md')
+                return [];
+            const parsed = (0, FrontmatterParser_1.parseFrontmatter)(await fs.readFile(basePath, 'utf8'));
+            const declaredName = typeof parsed.frontmatter?.name === 'string'
+                ? parsed.frontmatter.name
+                : path.basename(path.dirname(basePath));
+            return [normalizeSkillNameForFilesystem(declaredName)];
+        }
+    }
+    catch {
+        // Ignore missing paths.
+    }
+    const discovered = new Set();
+    const candidateDirs = new Set([path.join(basePath, 'skills')]);
+    try {
+        const parsed = (0, FrontmatterParser_1.parseFrontmatter)(await fs.readFile(path.join(basePath, 'SKILL.md'), 'utf8'));
+        const declaredName = typeof parsed.frontmatter?.name === 'string'
+            ? parsed.frontmatter.name
+            : path.basename(basePath);
+        discovered.add(normalizeSkillNameForFilesystem(declaredName));
+    }
+    catch {
+        // Ignore missing root SKILL.md.
+    }
+    for (const pluginBase of await collectDeclaredPluginBases(basePath)) {
+        candidateDirs.add(path.join(pluginBase, 'skills'));
+    }
+    for (const candidateDir of candidateDirs) {
+        let entries;
+        try {
+            entries = await fs.readdir(candidateDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const skillMdPath = path.join(candidateDir, entry.name, 'SKILL.md');
+            try {
+                const parsed = (0, FrontmatterParser_1.parseFrontmatter)(await fs.readFile(skillMdPath, 'utf8'));
+                const declaredName = typeof parsed.frontmatter?.name === 'string'
+                    ? parsed.frontmatter.name
+                    : entry.name;
+                discovered.add(normalizeSkillNameForFilesystem(declaredName));
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return [...discovered].sort((a, b) => a.localeCompare(b));
+}
+async function discoverAgentSkillCandidates(basePath, rootPath = basePath) {
+    const agentFiles = await discoverAgentFiles(basePath, rootPath);
+    const candidates = [];
+    for (const agentFile of agentFiles) {
+        const parsed = (0, FrontmatterParser_1.parseFrontmatter)(await fs.readFile(agentFile.absolutePath, 'utf8'));
+        const declaredName = parsed.frontmatter?.name;
+        const description = parsed.frontmatter?.description;
+        if (typeof declaredName !== 'string' || typeof description !== 'string') {
+            continue;
+        }
+        const compiledContent = buildCompiledSkillContent(declaredName, parsed.rawFrontmatter, parsed.body, agentFile.relativePath);
+        candidates.push({
+            compiledContent,
+            computedHash: hashContent(compiledContent),
+            description,
+            installName: normalizeSkillNameForFilesystem(declaredName),
+            name: declaredName,
+            sourceRelPath: agentFile.relativePath,
+        });
+    }
+    return candidates.sort((a, b) => a.installName.localeCompare(b.installName));
+}
+function parseRequestedSkillFilters(args) {
+    const names = new Set();
+    let wildcard = false;
+    const argv = args ?? [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const current = argv[index];
+        if (current !== '--skill' && current !== '-s')
+            continue;
+        for (let valueIndex = index + 1; valueIndex < argv.length; valueIndex += 1) {
+            const value = argv[valueIndex];
+            if (value.startsWith('-'))
+                break;
+            if (value === '*') {
+                wildcard = true;
+                continue;
+            }
+            names.add(normalizeSkillNameForFilesystem(value));
+        }
+    }
+    return { names, wildcard };
+}
+function hasListFlag(args) {
+    return (args ?? []).some((arg) => arg === '--list' || arg === '-l');
+}
+function hasGlobalFlag(args) {
+    return (args ?? []).some((arg) => arg === '--global' || arg === '-g');
+}
+function extractAddSource(args) {
+    for (const arg of args ?? []) {
+        if (arg.startsWith('-'))
+            continue;
+        return arg;
+    }
+    return null;
+}
+function buildAdjustedSkillsAddArgs(originalArgs, nativeSkillNames) {
+    const args = [...(originalArgs ?? [])];
+    const next = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index];
+        if (current === '--skill' || current === '-s') {
+            index += 1;
+            while (index < args.length && !args[index].startsWith('-')) {
+                index += 1;
+            }
+            index -= 1;
+            continue;
+        }
+        next.push(current);
+    }
+    if (nativeSkillNames.length > 0) {
+        next.push('--skill', ...nativeSkillNames);
+    }
+    return next;
+}
+async function inspectCompatibleSource(rawSource, args) {
+    const workspace = await withSourceWorkspace(rawSource);
+    const [nativeSkillNames, discoveredAgentSkills] = await Promise.all([
+        discoverSkillNames(workspace.searchPath),
+        discoverAgentSkillCandidates(workspace.searchPath, workspace.rootPath),
+    ]);
+    const requested = parseRequestedSkillFilters(args);
+    const agentSkills = discoveredAgentSkills.filter((agentSkill) => {
+        if (requested.wildcard || requested.names.size === 0)
+            return true;
+        return requested.names.has(agentSkill.installName);
+    });
+    return {
+        agentSkills: agentSkills.sort((a, b) => a.installName.localeCompare(b.installName)),
+        nativeSkillNames: requested.wildcard
+            ? nativeSkillNames
+            : nativeSkillNames.filter((name) => requested.names.size === 0 || requested.names.has(name)),
+        workspace,
+    };
+}
+async function installAgentSkillsFromInspection(projectRoot, inspection) {
+    const installed = [];
+    const lockEntries = {};
+    const canonicalSkillsDir = path.join(projectRoot, CANONICAL_SKILLS_DIR);
+    for (const agentSkill of inspection.agentSkills) {
+        const skillDir = path.join(canonicalSkillsDir, agentSkill.installName);
+        await fs.rm(skillDir, { force: true, recursive: true });
+        await fs.mkdir(skillDir, { recursive: true });
+        await fs.writeFile(path.join(skillDir, 'SKILL.md'), agentSkill.compiledContent, 'utf8');
+        lockEntries[agentSkill.installName] = {
+            computedHash: agentSkill.computedHash,
+            ref: inspection.workspace.parsed.ref,
+            source: inspection.workspace.parsed.source,
+            sourceRelPath: agentSkill.sourceRelPath,
+            sourceType: inspection.workspace.parsed.type,
+            subpath: inspection.workspace.parsed.subpath,
+        };
+        installed.push(agentSkill.installName);
+    }
+    await (0, SkillerLock_1.upsertSkillerLockEntries)(projectRoot, lockEntries);
+    await inspection.workspace.cleanup();
+    return installed.sort((a, b) => a.localeCompare(b));
+}
+function groupLockEntriesBySource(skills) {
+    const groups = new Map();
+    for (const [skillName, entry] of Object.entries(skills)) {
+        const key = JSON.stringify([
+            entry.source,
+            entry.sourceType,
+            entry.ref ?? '',
+            entry.subpath ?? '',
+        ]);
+        const existing = groups.get(key) ?? [];
+        existing.push([skillName, entry]);
+        groups.set(key, existing);
+    }
+    return groups;
+}
+async function installSingleAgentSkill(projectRoot, skillName, candidate, entry) {
+    const skillDir = path.join(projectRoot, CANONICAL_SKILLS_DIR, skillName);
+    await fs.rm(skillDir, { force: true, recursive: true });
+    await fs.mkdir(skillDir, { recursive: true });
+    await fs.writeFile(path.join(skillDir, 'SKILL.md'), candidate.compiledContent, 'utf8');
+    await (0, SkillerLock_1.upsertSkillerLockEntries)(projectRoot, {
+        [skillName]: {
+            ...entry,
+            computedHash: candidate.computedHash,
+        },
+    });
+}
+async function restoreAgentSkillsFromLock(projectRoot) {
+    const lock = await (0, SkillerLock_1.readSkillerLock)(projectRoot);
+    const restored = [];
+    const warnings = [];
+    for (const entries of groupLockEntriesBySource(lock.skills).values()) {
+        const [, entry] = entries[0];
+        const workspace = await withParsedSourceWorkspace(parseSourceFromLockEntry(entry));
+        const agentSkills = await discoverAgentSkillCandidates(workspace.searchPath, workspace.rootPath);
+        const candidates = new Map(agentSkills.map((candidate) => [candidate.sourceRelPath, candidate]));
+        for (const [skillName, lockEntry] of entries) {
+            const candidate = candidates.get(lockEntry.sourceRelPath);
+            if (!candidate) {
+                warnings.push(`Could not restore '${skillName}' from ${lockEntry.source}: missing ${lockEntry.sourceRelPath}`);
+                continue;
+            }
+            await installSingleAgentSkill(projectRoot, skillName, candidate, lockEntry);
+            restored.push(skillName);
+        }
+        await workspace.cleanup();
+    }
+    return {
+        restored: restored.sort((a, b) => a.localeCompare(b)),
+        warnings,
+    };
+}
+async function getOutdatedAgentSkills(projectRoot) {
+    const lock = await (0, SkillerLock_1.readSkillerLock)(projectRoot);
+    const outdated = [];
+    const warnings = [];
+    for (const entries of groupLockEntriesBySource(lock.skills).values()) {
+        const [, entry] = entries[0];
+        const workspace = await withParsedSourceWorkspace(parseSourceFromLockEntry(entry));
+        const agentSkills = await discoverAgentSkillCandidates(workspace.searchPath, workspace.rootPath);
+        const candidates = new Map(agentSkills.map((candidate) => [candidate.sourceRelPath, candidate]));
+        for (const [skillName, lockEntry] of entries) {
+            const candidate = candidates.get(lockEntry.sourceRelPath);
+            if (!candidate) {
+                warnings.push(`Could not check '${skillName}' from ${lockEntry.source}: missing ${lockEntry.sourceRelPath}`);
+                continue;
+            }
+            if (candidate.computedHash !== lockEntry.computedHash) {
+                outdated.push(skillName);
+            }
+        }
+        await workspace.cleanup();
+    }
+    return {
+        outdated: outdated.sort((a, b) => a.localeCompare(b)),
+        warnings,
+    };
+}
+async function updateAgentSkillsFromLock(projectRoot) {
+    const lock = await (0, SkillerLock_1.readSkillerLock)(projectRoot);
+    const updated = [];
+    const warnings = [];
+    for (const entries of groupLockEntriesBySource(lock.skills).values()) {
+        const [, entry] = entries[0];
+        const workspace = await withParsedSourceWorkspace(parseSourceFromLockEntry(entry));
+        const agentSkills = await discoverAgentSkillCandidates(workspace.searchPath, workspace.rootPath);
+        const candidates = new Map(agentSkills.map((candidate) => [candidate.sourceRelPath, candidate]));
+        for (const [skillName, lockEntry] of entries) {
+            const candidate = candidates.get(lockEntry.sourceRelPath);
+            if (!candidate) {
+                warnings.push(`Could not update '${skillName}' from ${lockEntry.source}: missing ${lockEntry.sourceRelPath}`);
+                continue;
+            }
+            if (candidate.computedHash === lockEntry.computedHash) {
+                continue;
+            }
+            await installSingleAgentSkill(projectRoot, skillName, candidate, lockEntry);
+            updated.push(skillName);
+        }
+        await workspace.cleanup();
+    }
+    return {
+        updated: updated.sort((a, b) => a.localeCompare(b)),
+        warnings,
+    };
+}
+async function removeAgentManagedSkills(projectRoot, skillNames) {
+    const removed = await (0, SkillerLock_1.removeSkillerLockEntries)(projectRoot, skillNames);
+    if (removed.length === 0)
+        return [];
+    for (const skillName of removed) {
+        await fs.rm(path.join(projectRoot, CANONICAL_SKILLS_DIR, skillName), {
+            force: true,
+            recursive: true,
+        });
+        await fs.rm(path.join(projectRoot, LEGACY_CLAUDE_SKILLS_DIR, skillName), {
+            force: true,
+            recursive: true,
+        });
+    }
+    return removed;
+}
+async function pruneMissingNativeSkillsFromLock(projectRoot) {
+    const lock = await readNativeSkillsLock(projectRoot);
+    const prunedKeys = [];
+    const prunedOutputNames = [];
+    const warnings = [];
+    for (const entries of groupLockEntriesBySource(lock.skills).values()) {
+        const [, entry] = entries[0];
+        if (entry.sourceType === 'node_modules' ||
+            entry.sourceType === 'well-known') {
+            continue;
+        }
+        let workspace = null;
+        try {
+            workspace = await withSourceWorkspace(entry.source);
+            const availableSkillNames = new Set(await discoverSkillNames(workspace.searchPath));
+            for (const [skillName] of entries) {
+                const installName = normalizeSkillNameForFilesystem(skillName);
+                if (availableSkillNames.has(installName))
+                    continue;
+                prunedKeys.push(skillName);
+                prunedOutputNames.push(installName);
+            }
+        }
+        catch (error) {
+            warnings.push(`Could not inspect '${entry.source}' for stale skills: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            if (workspace) {
+                await workspace.cleanup();
+            }
+        }
+    }
+    if (prunedKeys.length > 0) {
+        for (const skillName of prunedKeys) {
+            delete lock.skills[skillName];
+        }
+        await writeNativeSkillsLock(projectRoot, lock);
+    }
+    return {
+        prunedKeys: prunedKeys.sort((a, b) => a.localeCompare(b)),
+        prunedOutputNames: prunedOutputNames.sort((a, b) => a.localeCompare(b)),
+        warnings,
+    };
+}
+async function pruneMissingAgentSkillsFromLock(projectRoot) {
+    const lock = await (0, SkillerLock_1.readSkillerLock)(projectRoot);
+    const prunedKeys = [];
+    const prunedOutputNames = [];
+    const warnings = [];
+    for (const entries of groupLockEntriesBySource(lock.skills).values()) {
+        const [, entry] = entries[0];
+        let workspace = null;
+        try {
+            workspace = await withParsedSourceWorkspace(parseSourceFromLockEntry(entry));
+            const agentSkills = await discoverAgentSkillCandidates(workspace.searchPath, workspace.rootPath);
+            const candidates = new Set(agentSkills.map((candidate) => candidate.sourceRelPath));
+            for (const [skillName, lockEntry] of entries) {
+                if (candidates.has(lockEntry.sourceRelPath))
+                    continue;
+                prunedKeys.push(skillName);
+                prunedOutputNames.push(normalizeSkillNameForFilesystem(skillName));
+            }
+        }
+        catch (error) {
+            warnings.push(`Could not inspect '${entry.source}' for stale agent-derived skills: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            if (workspace) {
+                await workspace.cleanup();
+            }
+        }
+    }
+    if (prunedKeys.length > 0) {
+        await (0, SkillerLock_1.removeSkillerLockEntries)(projectRoot, prunedKeys);
+    }
+    return {
+        prunedKeys: prunedKeys.sort((a, b) => a.localeCompare(b)),
+        prunedOutputNames: prunedOutputNames.sort((a, b) => a.localeCompare(b)),
+        warnings,
+    };
+}

package/dist/core/SkillOwnership.js

@@ -43,6 +43,7 @@ const path = __importStar(require("path"));
 const yaml = __importStar(require("js-yaml"));
 const project_paths_1 = require("./project-paths");
 const FrontmatterParser_1 = require("./FrontmatterParser");
+const SkillerLock_1 = require("./SkillerLock");
 function normalizeSkillNameForFilesystem(name) {
     return name.replace(/:/g, '-');
 }
@@ -306,15 +307,20 @@ async function readCanonicalSkillNames(projectRoot) {
     }
 }
 async function readUpstreamOwnedSkillNames(projectRoot) {
+    const upstreamOwned = new Set();
     try {
         const raw = JSON.parse(await fs.readFile(getSkillsLockPath(projectRoot), 'utf8'));
-        return new Set(Object.keys(raw.skills ?? {})
-            .map(normalizeSkillNameForFilesystem)
-            .sort((a, b) => a.localeCompare(b)));
+        for (const key of Object.keys(raw.skills ?? {})) {
+            upstreamOwned.add(normalizeSkillNameForFilesystem(key));
+        }
     }
     catch {
-        return new Set();
+        // Ignore missing or invalid skills-lock.json.
+    }
+    for (const key of await (0, SkillerLock_1.readSkillerLockNames)(projectRoot)) {
+        upstreamOwned.add(normalizeSkillNameForFilesystem(key));
     }
+    return new Set([...upstreamOwned].sort((a, b) => a.localeCompare(b)));
 }
 async function resolveSkillOwnership(projectRoot) {
     const upstreamOwned = await readUpstreamOwnedSkillNames(projectRoot);
@@ -338,13 +344,13 @@ async function resolveSkillOwnership(projectRoot) {
         ...conflicts.map((name) => {
             const owners = [];
             if (upstreamOwned.has(name))
-                owners.push('skills-lock.json');
+                owners.push('upstream lock');
             if (localOwned.has(name))
                 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 or .agents/rules/${name}.mdc.`;
+            return `Canonical skill '${name}' is unmanaged; leaving it untouched because it is not in skills-lock.json, skiller-lock.json, or .agents/rules/${name}.mdc.`;
         }),
     ];
     return {

package/dist/core/SkillerLock.js

@@ -0,0 +1,112 @@
+"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.SKILLER_LOCK_FILENAME = void 0;
+exports.getSkillerLockPath = getSkillerLockPath;
+exports.readSkillerLock = readSkillerLock;
+exports.writeSkillerLock = writeSkillerLock;
+exports.upsertSkillerLockEntries = upsertSkillerLockEntries;
+exports.removeSkillerLockEntries = removeSkillerLockEntries;
+exports.readSkillerLockNames = readSkillerLockNames;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+exports.SKILLER_LOCK_FILENAME = 'skiller-lock.json';
+const SKILLER_LOCK_VERSION = 1;
+function createEmptyLock() {
+    return {
+        version: SKILLER_LOCK_VERSION,
+        skills: {},
+    };
+}
+function getSkillerLockPath(projectRoot) {
+    return path.join(projectRoot, exports.SKILLER_LOCK_FILENAME);
+}
+async function readSkillerLock(projectRoot) {
+    try {
+        const raw = JSON.parse(await fs.readFile(getSkillerLockPath(projectRoot), 'utf8'));
+        if (raw.version !== SKILLER_LOCK_VERSION || !raw.skills) {
+            return createEmptyLock();
+        }
+        return raw;
+    }
+    catch {
+        return createEmptyLock();
+    }
+}
+async function writeSkillerLock(projectRoot, lock) {
+    const lockPath = getSkillerLockPath(projectRoot);
+    const sortedSkills = {};
+    for (const key of Object.keys(lock.skills).sort((a, b) => a.localeCompare(b))) {
+        sortedSkills[key] = lock.skills[key];
+    }
+    if (Object.keys(sortedSkills).length === 0) {
+        await fs.rm(lockPath, { force: true });
+        return;
+    }
+    await fs.writeFile(lockPath, JSON.stringify({
+        version: SKILLER_LOCK_VERSION,
+        skills: sortedSkills,
+    }, null, 2) + '\n', 'utf8');
+}
+async function upsertSkillerLockEntries(projectRoot, entries) {
+    if (Object.keys(entries).length === 0)
+        return;
+    const lock = await readSkillerLock(projectRoot);
+    lock.skills = {
+        ...lock.skills,
+        ...entries,
+    };
+    await writeSkillerLock(projectRoot, lock);
+}
+async function removeSkillerLockEntries(projectRoot, skillNames) {
+    if (skillNames.length === 0)
+        return [];
+    const lock = await readSkillerLock(projectRoot);
+    const removed = [];
+    for (const skillName of skillNames) {
+        if (!(skillName in lock.skills))
+            continue;
+        delete lock.skills[skillName];
+        removed.push(skillName);
+    }
+    if (removed.length > 0) {
+        await writeSkillerLock(projectRoot, lock);
+    }
+    return removed.sort((a, b) => a.localeCompare(b));
+}
+async function readSkillerLockNames(projectRoot) {
+    const lock = await readSkillerLock(projectRoot);
+    return new Set(Object.keys(lock.skills).sort((a, b) => a.localeCompare(b)));
+}

package/dist/core/SkillsProcessor.js

@@ -727,7 +727,7 @@ async function compileRulesToSkills(skillerDir, projectRoot, verbose, dryRun) {
     for (const ruleFile of ruleFiles) {
         const skillName = path.basename(ruleFile.name, '.mdc');
         if (ownership.upstreamOwned.has(skillName)) {
-            throw new Error(`Local rule '${skillName}' conflicts with upstream-managed skill '${skillName}' in skills-lock.json`);
+            throw new Error(`Local rule '${skillName}' conflicts with lock-managed skill '${skillName}' in skills-lock.json or skiller-lock.json`);
         }
         const sourcePath = path.join(rulesDir, ruleFile.name);
         const sourceContent = await fs.readFile(sourcePath, 'utf8');

package/package.json

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