reskill 0.11.0 → 0.12.1

package/dist/cli/index.js

@@ -3,13 +3,11 @@ import * as __WEBPACK_EXTERNAL_MODULE_node_fs__ from "node:fs";
 import * as __WEBPACK_EXTERNAL_MODULE_commander__ from "commander";
 import * as __WEBPACK_EXTERNAL_MODULE_node_path__ from "node:path";
 import * as __WEBPACK_EXTERNAL_MODULE_chalk__ from "chalk";
-import * as __WEBPACK_EXTERNAL_MODULE__clack_prompts__ from "@clack/prompts";
-import * as __WEBPACK_EXTERNAL_MODULE_semver__ from "semver";
+import * as __WEBPACK_EXTERNAL_MODULE_node_os__ from "node:os";
 import * as __WEBPACK_EXTERNAL_MODULE_node_child_process__ from "node:child_process";
 import * as __WEBPACK_EXTERNAL_MODULE_node_util__ from "node:util";
-import * as __WEBPACK_EXTERNAL_MODULE_os__ from "os";
-import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
-import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
+import * as __WEBPACK_EXTERNAL_MODULE_semver__ from "semver";
+import * as __WEBPACK_EXTERNAL_MODULE__clack_prompts__ from "@clack/prompts";
 import * as __WEBPACK_EXTERNAL_MODULE_ora__ from "ora";
 var __webpack_modules__ = {
     "node:fs": function(module) {
@@ -39,7 +37,7 @@ function writeJson(filePath, data, indent = 2) {
     if (!exists(dir)) external_node_fs_.mkdirSync(dir, {
         recursive: true
     });
-    external_node_fs_.writeFileSync(filePath, JSON.stringify(data, null, indent) + '\n', 'utf-8');
+    external_node_fs_.writeFileSync(filePath, `${JSON.stringify(data, null, indent)}\n`, 'utf-8');
 }
 function ensureDir(dirPath) {
     if (!exists(dirPath)) external_node_fs_.mkdirSync(dirPath, {
@@ -110,121 +108,9 @@ function shortenPath(fullPath, cwd) {
     const home = getHomeDir();
     const currentDir = cwd || process.cwd();
     if (fullPath.startsWith(home)) return fullPath.replace(home, '~');
-    if (fullPath.startsWith(currentDir)) return '.' + fullPath.slice(currentDir.length);
+    if (fullPath.startsWith(currentDir)) return `.${fullPath.slice(currentDir.length)}`;
     return fullPath;
 }
-const DEFAULT_SKILLS_JSON = {
-    skills: {},
-    defaults: {
-        registry: 'github',
-        installDir: '.skills'
-    }
-};
-const DEFAULT_REGISTRIES = {
-    github: 'https://github.com',
-    gitlab: 'https://gitlab.com'
-};
-class ConfigLoader {
-    projectRoot;
-    configPath;
-    config = null;
-    constructor(projectRoot){
-        this.projectRoot = projectRoot || process.cwd();
-        this.configPath = getSkillsJsonPath(this.projectRoot);
-    }
-    getProjectRoot() {
-        return this.projectRoot;
-    }
-    getConfigPath() {
-        return this.configPath;
-    }
-    exists() {
-        return exists(this.configPath);
-    }
-    load() {
-        if (this.config) return this.config;
-        if (!this.exists()) throw new Error(`skills.json not found in ${this.projectRoot}. Run 'reskill init' first.`);
-        try {
-            this.config = readJson(this.configPath);
-            return this.config;
-        } catch (error) {
-            throw new Error(`Failed to parse skills.json: ${error.message}`);
-        }
-    }
-    reload() {
-        this.config = null;
-        return this.load();
-    }
-    save(config) {
-        const toSave = config || this.config;
-        if (!toSave) throw new Error('No config to save');
-        writeJson(this.configPath, toSave);
-        this.config = toSave;
-    }
-    create(options) {
-        const config = {
-            ...DEFAULT_SKILLS_JSON,
-            ...options,
-            skills: options?.skills || {},
-            defaults: {
-                ...DEFAULT_SKILLS_JSON.defaults,
-                ...options?.defaults
-            }
-        };
-        this.save(config);
-        return config;
-    }
-    getDefaults() {
-        const config = this.config || (this.exists() ? this.load() : DEFAULT_SKILLS_JSON);
-        return {
-            registry: config.defaults?.registry || DEFAULT_SKILLS_JSON.defaults.registry,
-            installDir: config.defaults?.installDir || DEFAULT_SKILLS_JSON.defaults.installDir,
-            targetAgents: config.defaults?.targetAgents || [],
-            installMode: config.defaults?.installMode || 'symlink'
-        };
-    }
-    getRegistryUrl(registryName) {
-        const config = this.config || (this.exists() ? this.load() : DEFAULT_SKILLS_JSON);
-        if (config.registries?.[registryName]) return config.registries[registryName];
-        if (DEFAULT_REGISTRIES[registryName]) return DEFAULT_REGISTRIES[registryName];
-        return `https://${registryName}`;
-    }
-    getInstallDir() {
-        const defaults = this.getDefaults();
-        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.projectRoot, defaults.installDir);
-    }
-    addSkill(name, ref) {
-        if (!this.config) this.load();
-        this.config.skills[name] = ref;
-        this.save();
-    }
-    removeSkill(name) {
-        if (!this.config) this.load();
-        if (this.config.skills[name]) {
-            delete this.config.skills[name];
-            this.save();
-            return true;
-        }
-        return false;
-    }
-    getSkills() {
-        if (!this.config) {
-            if (!this.exists()) return {};
-            this.load();
-        }
-        return {
-            ...this.config.skills
-        };
-    }
-    hasSkill(name) {
-        const skills = this.getSkills();
-        return name in skills;
-    }
-    getSkillRef(name) {
-        const skills = this.getSkills();
-        return skills[name];
-    }
-}
 const logger = {
     info (message) {
         console.log(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].blue('ℹ'), message);
@@ -266,49 +152,170 @@ const logger = {
         }
     }
 };
-const initCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('init').description('Initialize a new skills.json configuration').option('-n, --name <name>', 'Project name').option('-r, --registry <registry>', 'Default registry', 'github').option('-d, --install-dir <dir>', 'Skills installation directory', '.skills').option('-y, --yes', 'Skip prompts and use defaults').action(async (options)=>{
-    const configLoader = new ConfigLoader();
-    if (configLoader.exists()) {
-        logger.warn('skills.json already exists');
-        return;
+const agent_registry_home = (0, __WEBPACK_EXTERNAL_MODULE_node_os__.homedir)();
+const agents = {
+    amp: {
+        name: 'amp',
+        displayName: 'Amp',
+        skillsDir: '.agents/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.config/agents/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.config/amp'))
+    },
+    antigravity: {
+        name: 'antigravity',
+        displayName: 'Antigravity',
+        skillsDir: '.agent/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.gemini/antigravity/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(process.cwd(), '.agent')) || (0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.gemini/antigravity'))
+    },
+    'claude-code': {
+        name: 'claude-code',
+        displayName: 'Claude Code',
+        skillsDir: '.claude/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.claude/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.claude'))
+    },
+    clawdbot: {
+        name: 'clawdbot',
+        displayName: 'Clawdbot',
+        skillsDir: 'skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.clawdbot/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.clawdbot'))
+    },
+    codex: {
+        name: 'codex',
+        displayName: 'Codex',
+        skillsDir: '.codex/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.codex/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.codex'))
+    },
+    cursor: {
+        name: 'cursor',
+        displayName: 'Cursor',
+        skillsDir: '.cursor/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.cursor/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.cursor'))
+    },
+    droid: {
+        name: 'droid',
+        displayName: 'Droid',
+        skillsDir: '.factory/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.factory/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.factory/skills'))
+    },
+    'gemini-cli': {
+        name: 'gemini-cli',
+        displayName: 'Gemini CLI',
+        skillsDir: '.gemini/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.gemini/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.gemini'))
+    },
+    'github-copilot': {
+        name: 'github-copilot',
+        displayName: 'GitHub Copilot',
+        skillsDir: '.github/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.copilot/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(process.cwd(), '.github')) || (0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.copilot'))
+    },
+    goose: {
+        name: 'goose',
+        displayName: 'Goose',
+        skillsDir: '.goose/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.config/goose/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.config/goose'))
+    },
+    kilo: {
+        name: 'kilo',
+        displayName: 'Kilo Code',
+        skillsDir: '.kilocode/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.kilocode/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.kilocode'))
+    },
+    'kiro-cli': {
+        name: 'kiro-cli',
+        displayName: 'Kiro CLI',
+        skillsDir: '.kiro/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.kiro/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.kiro'))
+    },
+    opencode: {
+        name: 'opencode',
+        displayName: 'OpenCode',
+        skillsDir: '.opencode/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.config/opencode/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.config/opencode')) || (0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.claude/skills'))
+    },
+    roo: {
+        name: 'roo',
+        displayName: 'Roo Code',
+        skillsDir: '.roo/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.roo/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.roo'))
+    },
+    trae: {
+        name: 'trae',
+        displayName: 'Trae',
+        skillsDir: '.trae/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.trae/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.trae'))
+    },
+    windsurf: {
+        name: 'windsurf',
+        displayName: 'Windsurf',
+        skillsDir: '.windsurf/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.codeium/windsurf/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.codeium/windsurf'))
+    },
+    neovate: {
+        name: 'neovate',
+        displayName: 'Neovate',
+        skillsDir: '.neovate/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.neovate/skills'),
+        detectInstalled: async ()=>(0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(agent_registry_home, '.neovate'))
     }
-    const config = configLoader.create({
-        name: options.name,
-        defaults: {
-            registry: options.registry,
-            installDir: options.installDir
-        }
-    });
-    logger.success('Created skills.json');
-    logger.newline();
-    logger.log('Configuration:');
-    logger.log(`  Name: ${config.name || '(not set)'}`);
-    logger.log(`  Default registry: ${config.defaults?.registry}`);
-    logger.log(`  Install directory: ${config.defaults?.installDir}`);
-    logger.newline();
-    logger.log('Next steps:');
-    logger.log('  reskill install <skill>  Install a skill');
-    logger.log('  reskill list             List installed skills');
-});
+};
+async function detectInstalledAgents() {
+    const installed = [];
+    for (const [type, config] of Object.entries(agents))if (await config.detectInstalled()) installed.push(type);
+    return installed;
+}
+function getAgentConfig(type) {
+    return agents[type];
+}
+function isValidAgentType(type) {
+    return type in agents;
+}
 const execAsync = (0, __WEBPACK_EXTERNAL_MODULE_node_util__.promisify)(__WEBPACK_EXTERNAL_MODULE_node_child_process__.exec);
 class GitCloneError extends Error {
     repoUrl;
     originalError;
     isAuthError;
+    urlType;
     constructor(repoUrl, originalError){
         const isAuthError = GitCloneError.isAuthenticationError(originalError.message);
+        const urlType = GitCloneError.detectUrlType(repoUrl);
         let message = `Failed to clone repository: ${repoUrl}`;
         if (isAuthError) {
-            message += '\n\nTip: For private repos, ensure git SSH keys or credentials are configured:';
-            message += '\n  - SSH: Check ~/.ssh/id_rsa or ~/.ssh/id_ed25519';
-            message += '\n  - HTTPS: Run \'git config --global credential.helper store\'';
-            message += '\n  - Or use a personal access token in the URL';
+            message += '\n\nTip: For private repos, ensure git credentials are configured:';
+            if ('ssh' === urlType) {
+                message += '\n  - Check ~/.ssh/id_rsa or ~/.ssh/id_ed25519';
+                message += '\n  - Ensure SSH key is added to your Git hosting service';
+            } else {
+                message += "\n  - Run 'git config --global credential.helper store'";
+                message += '\n  - Or use a personal access token in the URL';
+            }
         }
         super(message);
         this.name = 'GitCloneError';
         this.repoUrl = repoUrl;
         this.originalError = originalError;
         this.isAuthError = isAuthError;
+        this.urlType = urlType;
+    }
+    static detectUrlType(url) {
+        if (url.startsWith('git@') || url.startsWith('ssh://')) return 'ssh';
+        if (url.startsWith('http://') || url.startsWith('https://')) return 'https';
+        return 'unknown';
     }
     static isAuthenticationError(message) {
         const authPatterns = [
@@ -460,182 +467,10 @@ function parseGitUrl(url) {
     }
     return null;
 }
-class GitResolver {
-    defaultRegistry;
-    constructor(defaultRegistry = 'github'){
-        this.defaultRegistry = defaultRegistry;
-    }
-    parseRef(ref) {
-        const raw = ref;
-        if (isGitUrl(ref)) return this.parseGitUrlRef(ref);
-        let remaining = ref;
-        let registry = this.defaultRegistry;
-        let version;
-        const registryMatch = remaining.match(/^([a-zA-Z0-9.-]+):(.+)$/);
-        if (registryMatch) {
-            registry = registryMatch[1];
-            remaining = registryMatch[2];
-        }
-        const atIndex = remaining.lastIndexOf('@');
-        if (atIndex > 0) {
-            version = remaining.slice(atIndex + 1);
-            remaining = remaining.slice(0, atIndex);
-        }
-        const parts = remaining.split('/');
-        if (parts.length < 2) throw new Error(`Invalid skill reference: ${ref}. Expected format: owner/repo[@version]`);
-        const owner = parts[0];
-        const repo = parts[1];
-        const subPath = parts.length > 2 ? parts.slice(2).join('/') : void 0;
-        return {
-            registry,
-            owner,
-            repo,
-            subPath,
-            version,
-            raw
-        };
-    }
-    parseGitUrlRef(ref) {
-        const raw = ref;
-        let gitUrl = ref;
-        let version;
-        let subPath;
-        const gitSuffixIndex = ref.indexOf('.git');
-        if (-1 !== gitSuffixIndex) {
-            const afterGit = ref.slice(gitSuffixIndex + 4);
-            if (afterGit) {
-                const atIndex = afterGit.lastIndexOf('@');
-                if (-1 !== atIndex) {
-                    version = afterGit.slice(atIndex + 1);
-                    const pathPart = afterGit.slice(0, atIndex);
-                    if (pathPart.startsWith('/')) subPath = pathPart.slice(1);
-                } else if (afterGit.startsWith('/')) subPath = afterGit.slice(1);
-                gitUrl = ref.slice(0, gitSuffixIndex + 4);
-            }
-        } else {
-            const atIndex = ref.lastIndexOf('@');
-            if (atIndex > 4) {
-                version = ref.slice(atIndex + 1);
-                gitUrl = ref.slice(0, atIndex);
-            }
-        }
-        const parsed = parseGitUrl(gitUrl);
-        if (!parsed) throw new Error(`Invalid Git URL: ${ref}. Expected format: git@host:owner/repo.git or https://host/owner/repo.git`);
-        return {
-            registry: parsed.host,
-            owner: parsed.owner,
-            repo: parsed.repo,
-            subPath,
-            version,
-            raw,
-            gitUrl
-        };
-    }
-    parseVersion(versionSpec) {
-        if (!versionSpec) return {
-            type: 'branch',
-            value: 'main',
-            raw: ''
-        };
-        const raw = versionSpec;
-        if ('latest' === versionSpec) return {
-            type: 'latest',
-            value: 'latest',
-            raw
-        };
-        if (versionSpec.startsWith('branch:')) return {
-            type: 'branch',
-            value: versionSpec.slice(7),
-            raw
-        };
-        if (versionSpec.startsWith('commit:')) return {
-            type: 'commit',
-            value: versionSpec.slice(7),
-            raw
-        };
-        if (/^[\^~><]/.test(versionSpec)) return {
-            type: 'range',
-            value: versionSpec,
-            raw
-        };
-        return {
-            type: 'exact',
-            value: versionSpec,
-            raw
-        };
-    }
-    buildRepoUrl(parsed) {
-        if (parsed.gitUrl) return parsed.gitUrl;
-        return buildRepoUrl(parsed.registry, `${parsed.owner}/${parsed.repo}`);
-    }
-    async resolveVersion(repoUrl, versionSpec) {
-        switch(versionSpec.type){
-            case 'exact':
-                return {
-                    ref: versionSpec.value
-                };
-            case 'latest':
-                {
-                    const latestTag = await getLatestTag(repoUrl);
-                    if (!latestTag) {
-                        const defaultBranch = await getDefaultBranch(repoUrl);
-                        return {
-                            ref: defaultBranch
-                        };
-                    }
-                    return {
-                        ref: latestTag.name,
-                        commit: latestTag.commit
-                    };
-                }
-            case 'range':
-                {
-                    const tags = await getRemoteTags(repoUrl);
-                    const matchingTags = tags.filter((tag)=>{
-                        const version = tag.name.replace(/^v/, '');
-                        return __WEBPACK_EXTERNAL_MODULE_semver__.satisfies(version, versionSpec.value);
-                    });
-                    if (0 === matchingTags.length) throw new Error(`No version found matching ${versionSpec.raw} for ${repoUrl}`);
-                    matchingTags.sort((a, b)=>{
-                        const aVer = a.name.replace(/^v/, '');
-                        const bVer = b.name.replace(/^v/, '');
-                        return __WEBPACK_EXTERNAL_MODULE_semver__.compare(bVer, aVer);
-                    });
-                    return {
-                        ref: matchingTags[0].name,
-                        commit: matchingTags[0].commit
-                    };
-                }
-            case 'branch':
-                return {
-                    ref: versionSpec.value
-                };
-            case 'commit':
-                return {
-                    ref: versionSpec.value,
-                    commit: versionSpec.value
-                };
-            default:
-                throw new Error(`Unknown version type: ${versionSpec.type}`);
-        }
-    }
-    async resolve(ref) {
-        const parsed = this.parseRef(ref);
-        const repoUrl = this.buildRepoUrl(parsed);
-        const versionSpec = this.parseVersion(parsed.version);
-        const resolved = await this.resolveVersion(repoUrl, versionSpec);
-        return {
-            parsed,
-            repoUrl,
-            ref: resolved.ref,
-            commit: resolved.commit
-        };
-    }
-}
-class CacheManager {
-    cacheDir;
-    constructor(cacheDir){
-        this.cacheDir = cacheDir || getCacheDir();
+class CacheManager {
+    cacheDir;
+    constructor(cacheDir){
+        this.cacheDir = cacheDir || getCacheDir();
     }
     getCacheDir() {
         return this.cacheDir;
@@ -743,238 +578,294 @@ class CacheManager {
         };
     }
 }
-const LOCKFILE_VERSION = 1;
-class LockManager {
+const DEFAULT_SKILLS_JSON = {
+    skills: {},
+    defaults: {
+        registry: 'github',
+        installDir: '.skills'
+    }
+};
+const DEFAULT_REGISTRIES = {
+    github: 'https://github.com',
+    gitlab: 'https://gitlab.com'
+};
+class ConfigLoader {
     projectRoot;
-    lockPath;
-    lockData = null;
+    configPath;
+    config = null;
     constructor(projectRoot){
         this.projectRoot = projectRoot || process.cwd();
-        this.lockPath = getSkillsLockPath(this.projectRoot);
+        this.configPath = getSkillsJsonPath(this.projectRoot);
     }
-    getLockPath() {
-        return this.lockPath;
+    getProjectRoot() {
+        return this.projectRoot;
+    }
+    getConfigPath() {
+        return this.configPath;
     }
     exists() {
-        return exists(this.lockPath);
+        return exists(this.configPath);
     }
     load() {
-        if (this.lockData) return this.lockData;
-        if (!this.exists()) {
-            this.lockData = {
-                lockfileVersion: LOCKFILE_VERSION,
-                skills: {}
-            };
-            return this.lockData;
-        }
+        if (this.config) return this.config;
+        if (!this.exists()) throw new Error(`skills.json not found in ${this.projectRoot}. Run 'reskill init' first.`);
         try {
-            this.lockData = readJson(this.lockPath);
-            return this.lockData;
+            this.config = readJson(this.configPath);
+            return this.config;
         } catch (error) {
-            throw new Error(`Failed to parse skills.lock: ${error.message}`);
+            throw new Error(`Failed to parse skills.json: ${error.message}`);
         }
     }
     reload() {
-        this.lockData = null;
+        this.config = null;
         return this.load();
     }
-    save(lockToSave) {
-        const toSave = lockToSave || this.lockData;
-        if (!toSave) throw new Error('No lock to save');
-        writeJson(this.lockPath, toSave);
-        this.lockData = toSave;
+    save(config) {
+        const toSave = config || this.config;
+        if (!toSave) throw new Error('No config to save');
+        writeJson(this.configPath, toSave);
+        this.config = toSave;
     }
-    get(name) {
-        const lock = this.load();
-        return lock.skills[name];
+    ensureExists() {
+        if (this.exists()) return false;
+        this.create();
+        return true;
     }
-    set(name, skill) {
-        const lock = this.load();
-        lock.skills[name] = skill;
+    create(options) {
+        const config = {
+            ...DEFAULT_SKILLS_JSON,
+            ...options,
+            skills: options?.skills || {},
+            defaults: {
+                ...DEFAULT_SKILLS_JSON.defaults,
+                ...options?.defaults
+            }
+        };
+        this.save(config);
+        return config;
+    }
+    getDefaults() {
+        const config = this.config || (this.exists() ? this.load() : DEFAULT_SKILLS_JSON);
+        return {
+            registry: config.defaults?.registry || 'github',
+            installDir: config.defaults?.installDir || '.skills',
+            targetAgents: config.defaults?.targetAgents || [],
+            installMode: config.defaults?.installMode || 'symlink'
+        };
+    }
+    getRegistryUrl(registryName) {
+        const config = this.config || (this.exists() ? this.load() : DEFAULT_SKILLS_JSON);
+        if (config.registries?.[registryName]) return config.registries[registryName];
+        if (DEFAULT_REGISTRIES[registryName]) return DEFAULT_REGISTRIES[registryName];
+        return `https://${registryName}`;
+    }
+    getInstallDir() {
+        const defaults = this.getDefaults();
+        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.projectRoot, defaults.installDir);
+    }
+    addSkill(name, ref) {
+        if (!this.config) this.load();
+        if (this.config) this.config.skills[name] = ref;
         this.save();
     }
-    remove(name) {
-        const lock = this.load();
-        if (lock.skills[name]) {
-            delete lock.skills[name];
+    removeSkill(name) {
+        if (!this.config) this.load();
+        if (this.config?.skills[name]) {
+            delete this.config.skills[name];
             this.save();
             return true;
         }
         return false;
     }
-    lockSkill(name, options) {
-        const lockedSkill = {
-            source: options.source,
-            version: options.version,
-            resolved: options.resolved,
-            commit: options.commit,
-            installedAt: new Date().toISOString()
+    getSkills() {
+        if (!this.config) {
+            if (!this.exists()) return {};
+            this.load();
+        }
+        return {
+            ...this.config?.skills
         };
-        this.set(name, lockedSkill);
-        return lockedSkill;
     }
-    getAll() {
-        const lock = this.load();
+    hasSkill(name) {
+        const skills = this.getSkills();
+        return name in skills;
+    }
+    getSkillRef(name) {
+        const skills = this.getSkills();
+        return skills[name];
+    }
+}
+class GitResolver {
+    defaultRegistry;
+    constructor(defaultRegistry = 'github'){
+        this.defaultRegistry = defaultRegistry;
+    }
+    parseRef(ref) {
+        const raw = ref;
+        if (isGitUrl(ref)) return this.parseGitUrlRef(ref);
+        let remaining = ref;
+        let registry = this.defaultRegistry;
+        let version;
+        const registryMatch = remaining.match(/^([a-zA-Z0-9.-]+):(.+)$/);
+        if (registryMatch) {
+            registry = registryMatch[1];
+            remaining = registryMatch[2];
+        }
+        const atIndex = remaining.lastIndexOf('@');
+        if (atIndex > 0) {
+            version = remaining.slice(atIndex + 1);
+            remaining = remaining.slice(0, atIndex);
+        }
+        const parts = remaining.split('/');
+        if (parts.length < 2) throw new Error(`Invalid skill reference: ${ref}. Expected format: owner/repo[@version]`);
+        const owner = parts[0];
+        const repo = parts[1];
+        const subPath = parts.length > 2 ? parts.slice(2).join('/') : void 0;
         return {
-            ...lock.skills
+            registry,
+            owner,
+            repo,
+            subPath,
+            version,
+            raw
         };
     }
-    has(name) {
-        const lock = this.load();
-        return name in lock.skills;
-    }
-    isVersionMatch(name, version) {
-        const locked = this.get(name);
-        if (!locked) return false;
-        return locked.version === version;
+    parseGitUrlRef(ref) {
+        const raw = ref;
+        let gitUrl = ref;
+        let version;
+        let subPath;
+        const gitSuffixIndex = ref.indexOf('.git');
+        if (-1 !== gitSuffixIndex) {
+            const afterGit = ref.slice(gitSuffixIndex + 4);
+            if (afterGit) {
+                const atIndex = afterGit.lastIndexOf('@');
+                if (-1 !== atIndex) {
+                    version = afterGit.slice(atIndex + 1);
+                    const pathPart = afterGit.slice(0, atIndex);
+                    if (pathPart.startsWith('/')) subPath = pathPart.slice(1);
+                } else if (afterGit.startsWith('/')) subPath = afterGit.slice(1);
+                gitUrl = ref.slice(0, gitSuffixIndex + 4);
+            }
+        } else {
+            const atIndex = ref.lastIndexOf('@');
+            if (atIndex > 4) {
+                version = ref.slice(atIndex + 1);
+                gitUrl = ref.slice(0, atIndex);
+            }
+        }
+        const parsed = parseGitUrl(gitUrl);
+        if (!parsed) throw new Error(`Invalid Git URL: ${ref}. Expected format: git@host:owner/repo.git or https://host/owner/repo.git`);
+        return {
+            registry: parsed.host,
+            owner: parsed.owner,
+            repo: parsed.repo,
+            subPath,
+            version,
+            raw,
+            gitUrl
+        };
     }
-    clear() {
-        this.lockData = {
-            lockfileVersion: LOCKFILE_VERSION,
-            skills: {}
+    parseVersion(versionSpec) {
+        if (!versionSpec) return {
+            type: 'branch',
+            value: 'main',
+            raw: ''
+        };
+        const raw = versionSpec;
+        if ('latest' === versionSpec) return {
+            type: 'latest',
+            value: 'latest',
+            raw
+        };
+        if (versionSpec.startsWith('branch:')) return {
+            type: 'branch',
+            value: versionSpec.slice(7),
+            raw
+        };
+        if (versionSpec.startsWith('commit:')) return {
+            type: 'commit',
+            value: versionSpec.slice(7),
+            raw
+        };
+        if (/^[\^~><]/.test(versionSpec)) return {
+            type: 'range',
+            value: versionSpec,
+            raw
+        };
+        return {
+            type: 'exact',
+            value: versionSpec,
+            raw
         };
-        this.save();
     }
-    delete() {
-        if (this.exists()) {
-            const fs = __webpack_require__("node:fs");
-            fs.unlinkSync(this.lockPath);
+    buildRepoUrl(parsed) {
+        if (parsed.gitUrl) return parsed.gitUrl;
+        return buildRepoUrl(parsed.registry, `${parsed.owner}/${parsed.repo}`);
+    }
+    async resolveVersion(repoUrl, versionSpec) {
+        switch(versionSpec.type){
+            case 'exact':
+                return {
+                    ref: versionSpec.value
+                };
+            case 'latest':
+                {
+                    const latestTag = await getLatestTag(repoUrl);
+                    if (!latestTag) {
+                        const defaultBranch = await getDefaultBranch(repoUrl);
+                        return {
+                            ref: defaultBranch
+                        };
+                    }
+                    return {
+                        ref: latestTag.name,
+                        commit: latestTag.commit
+                    };
+                }
+            case 'range':
+                {
+                    const tags = await getRemoteTags(repoUrl);
+                    const matchingTags = tags.filter((tag)=>{
+                        const version = tag.name.replace(/^v/, '');
+                        return __WEBPACK_EXTERNAL_MODULE_semver__.satisfies(version, versionSpec.value);
+                    });
+                    if (0 === matchingTags.length) throw new Error(`No version found matching ${versionSpec.raw} for ${repoUrl}`);
+                    matchingTags.sort((a, b)=>{
+                        const aVer = a.name.replace(/^v/, '');
+                        const bVer = b.name.replace(/^v/, '');
+                        return __WEBPACK_EXTERNAL_MODULE_semver__.compare(bVer, aVer);
+                    });
+                    return {
+                        ref: matchingTags[0].name,
+                        commit: matchingTags[0].commit
+                    };
+                }
+            case 'branch':
+                return {
+                    ref: versionSpec.value
+                };
+            case 'commit':
+                return {
+                    ref: versionSpec.value,
+                    commit: versionSpec.value
+                };
+            default:
+                throw new Error(`Unknown version type: ${versionSpec.type}`);
         }
-        this.lockData = null;
     }
-}
-const agent_registry_home = (0, __WEBPACK_EXTERNAL_MODULE_os__.homedir)();
-const agents = {
-    amp: {
-        name: 'amp',
-        displayName: 'Amp',
-        skillsDir: '.agents/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.config/agents/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.config/amp'))
-    },
-    antigravity: {
-        name: 'antigravity',
-        displayName: 'Antigravity',
-        skillsDir: '.agent/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.gemini/antigravity/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(process.cwd(), '.agent')) || (0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.gemini/antigravity'))
-    },
-    'claude-code': {
-        name: 'claude-code',
-        displayName: 'Claude Code',
-        skillsDir: '.claude/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.claude/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.claude'))
-    },
-    clawdbot: {
-        name: 'clawdbot',
-        displayName: 'Clawdbot',
-        skillsDir: 'skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.clawdbot/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.clawdbot'))
-    },
-    codex: {
-        name: 'codex',
-        displayName: 'Codex',
-        skillsDir: '.codex/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.codex/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.codex'))
-    },
-    cursor: {
-        name: 'cursor',
-        displayName: 'Cursor',
-        skillsDir: '.cursor/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.cursor/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.cursor'))
-    },
-    droid: {
-        name: 'droid',
-        displayName: 'Droid',
-        skillsDir: '.factory/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.factory/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.factory/skills'))
-    },
-    'gemini-cli': {
-        name: 'gemini-cli',
-        displayName: 'Gemini CLI',
-        skillsDir: '.gemini/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.gemini/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.gemini'))
-    },
-    'github-copilot': {
-        name: 'github-copilot',
-        displayName: 'GitHub Copilot',
-        skillsDir: '.github/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.copilot/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(process.cwd(), '.github')) || (0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.copilot'))
-    },
-    goose: {
-        name: 'goose',
-        displayName: 'Goose',
-        skillsDir: '.goose/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.config/goose/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.config/goose'))
-    },
-    kilo: {
-        name: 'kilo',
-        displayName: 'Kilo Code',
-        skillsDir: '.kilocode/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.kilocode/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.kilocode'))
-    },
-    'kiro-cli': {
-        name: 'kiro-cli',
-        displayName: 'Kiro CLI',
-        skillsDir: '.kiro/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.kiro/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.kiro'))
-    },
-    opencode: {
-        name: 'opencode',
-        displayName: 'OpenCode',
-        skillsDir: '.opencode/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.config/opencode/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.config/opencode')) || (0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.claude/skills'))
-    },
-    roo: {
-        name: 'roo',
-        displayName: 'Roo Code',
-        skillsDir: '.roo/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.roo/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.roo'))
-    },
-    trae: {
-        name: 'trae',
-        displayName: 'Trae',
-        skillsDir: '.trae/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.trae/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.trae'))
-    },
-    windsurf: {
-        name: 'windsurf',
-        displayName: 'Windsurf',
-        skillsDir: '.windsurf/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.codeium/windsurf/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.codeium/windsurf'))
-    },
-    neovate: {
-        name: 'neovate',
-        displayName: 'Neovate',
-        skillsDir: '.neovate/skills',
-        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.neovate/skills'),
-        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.neovate'))
+    async resolve(ref) {
+        const parsed = this.parseRef(ref);
+        const repoUrl = this.buildRepoUrl(parsed);
+        const versionSpec = this.parseVersion(parsed.version);
+        const resolved = await this.resolveVersion(repoUrl, versionSpec);
+        return {
+            parsed,
+            repoUrl,
+            ref: resolved.ref,
+            commit: resolved.commit
+        };
     }
-};
-async function detectInstalledAgents() {
-    const installed = [];
-    for (const [type, config] of Object.entries(agents))if (await config.detectInstalled()) installed.push(type);
-    return installed;
-}
-function getAgentConfig(type) {
-    return agents[type];
-}
-function isValidAgentType(type) {
-    return type in agents;
 }
 const installer_AGENTS_DIR = '.agents';
 const installer_SKILLS_SUBDIR = 'skills';
@@ -992,7 +883,7 @@ function installer_isPathSafe(basePath, targetPath) {
     return normalizedTarget.startsWith(normalizedBase + __WEBPACK_EXTERNAL_MODULE_node_path__.sep) || normalizedTarget === normalizedBase;
 }
 function installer_getCanonicalSkillsDir(isGlobal, cwd) {
-    const baseDir = isGlobal ? (0, __WEBPACK_EXTERNAL_MODULE_os__.homedir)() : cwd || process.cwd();
+    const baseDir = isGlobal ? (0, __WEBPACK_EXTERNAL_MODULE_node_os__.homedir)() : cwd || process.cwd();
     return __WEBPACK_EXTERNAL_MODULE_node_path__.join(baseDir, installer_AGENTS_DIR, installer_SKILLS_SUBDIR);
 }
 function installer_ensureDir(dirPath) {
@@ -1009,7 +900,8 @@ function installer_remove(targetPath) {
 function copyDirectory(src, dest, options) {
     const exclude = new Set(options?.exclude || [
         'README.md',
-        'metadata.json'
+        'metadata.json',
+        '.reskill-commit'
     ]);
     installer_ensureDir(dest);
     const entries = external_node_fs_.readdirSync(src, {
@@ -1046,7 +938,7 @@ async function installer_createSymlink(target, linkPath) {
         const linkDir = __WEBPACK_EXTERNAL_MODULE_node_path__.dirname(linkPath);
         installer_ensureDir(linkDir);
         const relativePath = __WEBPACK_EXTERNAL_MODULE_node_path__.relative(linkDir, target);
-        const symlinkType = 'win32' === (0, __WEBPACK_EXTERNAL_MODULE_os__.platform)() ? 'junction' : void 0;
+        const symlinkType = 'win32' === (0, __WEBPACK_EXTERNAL_MODULE_node_os__.platform)() ? 'junction' : void 0;
         external_node_fs_.symlinkSync(relativePath, linkPath, symlinkType);
         return true;
     } catch  {
@@ -1135,38 +1027,138 @@ class Installer {
             };
         }
     }
-    async installToAgents(sourcePath, skillName, targetAgents, options = {}) {
-        const results = new Map();
-        for (const agent of targetAgents){
-            const result = await this.installForAgent(sourcePath, skillName, agent, options);
-            results.set(agent, result);
+    async installToAgents(sourcePath, skillName, targetAgents, options = {}) {
+        const results = new Map();
+        for (const agent of targetAgents){
+            const result = await this.installForAgent(sourcePath, skillName, agent, options);
+            results.set(agent, result);
+        }
+        return results;
+    }
+    isInstalled(skillName, agentType) {
+        const skillPath = this.getAgentSkillPath(skillName, agentType);
+        return external_node_fs_.existsSync(skillPath);
+    }
+    uninstallFromAgent(skillName, agentType) {
+        const skillPath = this.getAgentSkillPath(skillName, agentType);
+        if (!external_node_fs_.existsSync(skillPath)) return false;
+        installer_remove(skillPath);
+        return true;
+    }
+    uninstallFromAgents(skillName, targetAgents) {
+        const results = new Map();
+        for (const agent of targetAgents)results.set(agent, this.uninstallFromAgent(skillName, agent));
+        const canonicalPath = this.getCanonicalPath(skillName);
+        if (external_node_fs_.existsSync(canonicalPath)) installer_remove(canonicalPath);
+        return results;
+    }
+    listInstalledSkills(agentType) {
+        const agent = getAgentConfig(agentType);
+        const skillsDir = this.isGlobal ? agent.globalSkillsDir : __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cwd, agent.skillsDir);
+        if (!external_node_fs_.existsSync(skillsDir)) return [];
+        return external_node_fs_.readdirSync(skillsDir, {
+            withFileTypes: true
+        }).filter((entry)=>entry.isDirectory() || entry.isSymbolicLink()).map((entry)=>entry.name);
+    }
+}
+const LOCKFILE_VERSION = 1;
+class LockManager {
+    projectRoot;
+    lockPath;
+    lockData = null;
+    constructor(projectRoot){
+        this.projectRoot = projectRoot || process.cwd();
+        this.lockPath = getSkillsLockPath(this.projectRoot);
+    }
+    getLockPath() {
+        return this.lockPath;
+    }
+    exists() {
+        return exists(this.lockPath);
+    }
+    load() {
+        if (this.lockData) return this.lockData;
+        if (!this.exists()) {
+            this.lockData = {
+                lockfileVersion: LOCKFILE_VERSION,
+                skills: {}
+            };
+            return this.lockData;
+        }
+        try {
+            this.lockData = readJson(this.lockPath);
+            return this.lockData;
+        } catch (error) {
+            throw new Error(`Failed to parse skills.lock: ${error.message}`);
+        }
+    }
+    reload() {
+        this.lockData = null;
+        return this.load();
+    }
+    save(lockToSave) {
+        const toSave = lockToSave || this.lockData;
+        if (!toSave) throw new Error('No lock to save');
+        writeJson(this.lockPath, toSave);
+        this.lockData = toSave;
+    }
+    get(name) {
+        const lock = this.load();
+        return lock.skills[name];
+    }
+    set(name, skill) {
+        const lock = this.load();
+        lock.skills[name] = skill;
+        this.save();
+    }
+    remove(name) {
+        const lock = this.load();
+        if (lock.skills[name]) {
+            delete lock.skills[name];
+            this.save();
+            return true;
         }
-        return results;
+        return false;
     }
-    isInstalled(skillName, agentType) {
-        const skillPath = this.getAgentSkillPath(skillName, agentType);
-        return external_node_fs_.existsSync(skillPath);
+    lockSkill(name, options) {
+        const lockedSkill = {
+            source: options.source,
+            version: options.version,
+            resolved: options.resolved,
+            commit: options.commit,
+            installedAt: new Date().toISOString()
+        };
+        this.set(name, lockedSkill);
+        return lockedSkill;
     }
-    uninstallFromAgent(skillName, agentType) {
-        const skillPath = this.getAgentSkillPath(skillName, agentType);
-        if (!external_node_fs_.existsSync(skillPath)) return false;
-        installer_remove(skillPath);
-        return true;
+    getAll() {
+        const lock = this.load();
+        return {
+            ...lock.skills
+        };
     }
-    uninstallFromAgents(skillName, targetAgents) {
-        const results = new Map();
-        for (const agent of targetAgents)results.set(agent, this.uninstallFromAgent(skillName, agent));
-        const canonicalPath = this.getCanonicalPath(skillName);
-        if (external_node_fs_.existsSync(canonicalPath)) installer_remove(canonicalPath);
-        return results;
+    has(name) {
+        const lock = this.load();
+        return name in lock.skills;
     }
-    listInstalledSkills(agentType) {
-        const agent = getAgentConfig(agentType);
-        const skillsDir = this.isGlobal ? agent.globalSkillsDir : __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cwd, agent.skillsDir);
-        if (!external_node_fs_.existsSync(skillsDir)) return [];
-        return external_node_fs_.readdirSync(skillsDir, {
-            withFileTypes: true
-        }).filter((entry)=>entry.isDirectory() || entry.isSymbolicLink()).map((entry)=>entry.name);
+    isVersionMatch(name, version) {
+        const locked = this.get(name);
+        if (!locked) return false;
+        return locked.version === version;
+    }
+    clear() {
+        this.lockData = {
+            lockfileVersion: LOCKFILE_VERSION,
+            skills: {}
+        };
+        this.save();
+    }
+    delete() {
+        if (this.exists()) {
+            const fs = __webpack_require__("node:fs");
+            fs.unlinkSync(this.lockPath);
+        }
+        this.lockData = null;
     }
 }
 class SkillManager {
@@ -1195,8 +1187,17 @@ class SkillManager {
         if (this.isGlobal) return getGlobalSkillsDir();
         return this.config.getInstallDir();
     }
+    getCanonicalSkillsDir() {
+        const home = process.env.HOME || process.env.USERPROFILE || '';
+        const baseDir = this.isGlobal ? home : this.projectRoot;
+        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(baseDir, '.agents', 'skills');
+    }
     getSkillPath(name) {
-        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.getInstallDir(), name);
+        const canonicalPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.getCanonicalSkillsDir(), name);
+        if (exists(canonicalPath)) return canonicalPath;
+        const legacyPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.getInstallDir(), name);
+        if (exists(legacyPath)) return legacyPath;
+        return canonicalPath;
     }
     async install(ref, options = {}) {
         const { force = false, save = true } = options;
@@ -1209,11 +1210,13 @@ class SkillManager {
             const locked = this.lockManager.get(skillName);
             if (locked && locked.version === version) {
                 logger.info(`${skillName}@${version} is already installed`);
-                return this.getInstalledSkill(skillName);
+                const installed = this.getInstalledSkill(skillName);
+                if (installed) return installed;
             }
             if (!force) {
                 logger.warn(`${skillName} is already installed. Use --force to reinstall.`);
-                return this.getInstalledSkill(skillName);
+                const installed = this.getInstalledSkill(skillName);
+                if (installed) return installed;
             }
         }
         logger["package"](`Installing ${skillName}@${version}...`);
@@ -1227,15 +1230,20 @@ class SkillManager {
         if (exists(skillPath)) remove(skillPath);
         await this.cache.copyTo(parsed, version, skillPath);
         if (!this.isGlobal) this.lockManager.lockSkill(skillName, {
-            source: `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? '/' + parsed.subPath : ''}`,
+            source: `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? `/${parsed.subPath}` : ''}`,
             version,
             resolved: repoUrl,
             commit: cacheResult.commit
         });
-        if (!this.isGlobal && save && this.config.exists()) this.config.addSkill(skillName, ref);
+        if (!this.isGlobal && save) {
+            this.config.ensureExists();
+            this.config.addSkill(skillName, ref);
+        }
         const locationHint = this.isGlobal ? '(global)' : '';
         logger.success(`Installed ${skillName}@${version} to ${skillPath} ${locationHint}`.trim());
-        return this.getInstalledSkill(skillName);
+        const installed = this.getInstalledSkill(skillName);
+        if (!installed) throw new Error(`Failed to get installed skill info for ${skillName}`);
+        return installed;
     }
     async installAll(options = {}) {
         const skills = this.config.getSkills();
@@ -1302,7 +1310,7 @@ class SkillManager {
             skillName = name || skillJson.name || skillName;
         } catch  {}
         const linkPath = this.getSkillPath(skillName);
-        ensureDir(this.getInstallDir());
+        ensureDir(__WEBPACK_EXTERNAL_MODULE_node_path__.dirname(linkPath));
         createSymlink(absolutePath, linkPath);
         logger.success(`Linked ${skillName} → ${absolutePath}`);
         return {
@@ -1328,20 +1336,36 @@ class SkillManager {
         return true;
     }
     list() {
-        const installDir = this.getInstallDir();
-        if (!exists(installDir)) return [];
         const skills = [];
-        const dirs = listDir(installDir);
-        for (const name of dirs){
-            const skillPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(installDir, name);
+        const seenNames = new Set();
+        const canonicalDir = this.getCanonicalSkillsDir();
+        if (exists(canonicalDir)) for (const name of listDir(canonicalDir)){
+            const skillPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(canonicalDir, name);
+            if (!isDirectory(skillPath)) continue;
+            const skill = this.getInstalledSkillFromPath(name, skillPath);
+            if (skill) {
+                skills.push(skill);
+                seenNames.add(name);
+            }
+        }
+        const legacyDir = this.getInstallDir();
+        if (exists(legacyDir) && legacyDir !== canonicalDir) for (const name of listDir(legacyDir)){
+            if (seenNames.has(name)) continue;
+            const skillPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(legacyDir, name);
             if (!isDirectory(skillPath)) continue;
-            const skill = this.getInstalledSkill(name);
-            if (skill) skills.push(skill);
+            if (isSymlink(skillPath)) try {
+                const realPath = getRealPath(skillPath);
+                if (realPath.includes(__WEBPACK_EXTERNAL_MODULE_node_path__.join('.agents', 'skills'))) continue;
+            } catch  {}
+            const skill = this.getInstalledSkillFromPath(name, skillPath);
+            if (skill) {
+                skills.push(skill);
+                seenNames.add(name);
+            }
         }
         return skills;
     }
-    getInstalledSkill(name) {
-        const skillPath = this.getSkillPath(name);
+    getInstalledSkillFromPath(name, skillPath) {
         if (!exists(skillPath)) return null;
         const isLinked = isSymlink(skillPath);
         const locked = this.lockManager.get(name);
@@ -1359,6 +1383,13 @@ class SkillManager {
             isLinked
         };
     }
+    getInstalledSkill(name) {
+        const canonicalPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.getCanonicalSkillsDir(), name);
+        if (exists(canonicalPath)) return this.getInstalledSkillFromPath(name, canonicalPath);
+        const legacyPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.getInstallDir(), name);
+        if (exists(legacyPath)) return this.getInstalledSkillFromPath(name, legacyPath);
+        return null;
+    }
     getInfo(name) {
         return {
             installed: this.getInstalledSkill(name),
@@ -1420,12 +1451,15 @@ class SkillManager {
             mode: mode
         });
         if (!this.isGlobal) this.lockManager.lockSkill(skillName, {
-            source: `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? '/' + parsed.subPath : ''}`,
+            source: `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? `/${parsed.subPath}` : ''}`,
             version,
             resolved: repoUrl,
             commit: cacheResult.commit
         });
-        if (!this.isGlobal && save && this.config.exists()) this.config.addSkill(skillName, ref);
+        if (!this.isGlobal && save) {
+            this.config.ensureExists();
+            this.config.addSkill(skillName, ref);
+        }
         const successCount = Array.from(results.values()).filter((r)=>r.success).length;
         const failCount = results.size - successCount;
         if (0 === failCount) logger.success(`Installed ${skillName}@${version} to ${successCount} agent(s)`);
@@ -1434,7 +1468,7 @@ class SkillManager {
             name: skillName,
             path: sourcePath,
             version,
-            source: `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? '/' + parsed.subPath : ''}`
+            source: `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? `/${parsed.subPath}` : ''}`
         };
         return {
             skill,
@@ -1477,6 +1511,69 @@ class SkillManager {
         return results;
     }
 }
+const infoCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('info').description('Show skill details').argument('<skill>', 'Skill name').option('-j, --json', 'Output as JSON').action((skillName, options)=>{
+    const skillManager = new SkillManager();
+    const info = skillManager.getInfo(skillName);
+    if (options.json) {
+        console.log(JSON.stringify(info, null, 2));
+        return;
+    }
+    if (!info.installed && !info.config) {
+        logger.error(`Skill ${skillName} not found`);
+        process.exit(1);
+    }
+    logger.log(`Skill: ${skillName}`);
+    logger.newline();
+    if (info.config) {
+        logger.log("Configuration (skills.json):");
+        logger.log(`  Reference: ${info.config}`);
+    }
+    if (info.locked) {
+        logger.log("Locked Version (skills.lock):");
+        logger.log(`  Version: ${info.locked.version}`);
+        logger.log(`  Source: ${info.locked.source}`);
+        logger.log(`  Commit: ${info.locked.commit}`);
+        logger.log(`  Installed: ${info.locked.installedAt}`);
+    }
+    if (info.installed) {
+        logger.log("Installed:");
+        logger.log(`  Path: ${info.installed.path}`);
+        logger.log(`  Version: ${info.installed.version}`);
+        logger.log(`  Linked: ${info.installed.isLinked ? 'Yes' : 'No'}`);
+        if (info.installed.metadata) {
+            const meta = info.installed.metadata;
+            logger.log("Metadata (skill.json):");
+            if (meta.description) logger.log(`  Description: ${meta.description}`);
+            if (meta.author) logger.log(`  Author: ${meta.author}`);
+            if (meta.license) logger.log(`  License: ${meta.license}`);
+            if (meta.keywords?.length) logger.log(`  Keywords: ${meta.keywords.join(', ')}`);
+        }
+    } else logger.warn(`Skill ${skillName} is not installed`);
+});
+const initCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('init').description('Initialize a new skills.json configuration').option('-n, --name <name>', 'Project name').option('-r, --registry <registry>', 'Default registry', 'github').option('-d, --install-dir <dir>', 'Skills installation directory', '.skills').option('-y, --yes', 'Skip prompts and use defaults').action(async (options)=>{
+    const configLoader = new ConfigLoader();
+    if (configLoader.exists()) {
+        logger.warn('skills.json already exists');
+        return;
+    }
+    const config = configLoader.create({
+        name: options.name,
+        defaults: {
+            registry: options.registry,
+            installDir: options.installDir
+        }
+    });
+    logger.success('Created skills.json');
+    logger.newline();
+    logger.log('Configuration:');
+    logger.log(`  Name: ${config.name || '(not set)'}`);
+    logger.log(`  Default registry: ${config.defaults?.registry}`);
+    logger.log(`  Install directory: ${config.defaults?.installDir}`);
+    logger.newline();
+    logger.log('Next steps:');
+    logger.log('  reskill install <skill>  Install a skill');
+    logger.log('  reskill list             List installed skills');
+});
 function formatAgentNames(agentTypes, maxShow = 5) {
     const names = agentTypes.map((a)=>agents[a].displayName);
     if (names.length <= maxShow) return names.join(', ');
@@ -1525,7 +1622,7 @@ const installCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('instal
                             label: config.displayName
                         }));
                     const selected = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.multiselect({
-                        message: 'Select agents to install skills to',
+                        message: `Select agents to install skills to ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('(Space to toggle, Enter to confirm)')}`,
                         options: allAgentChoices,
                         required: true,
                         initialValues: allAgentTypes
@@ -1547,7 +1644,7 @@ const installCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('instal
                         hint: agents[a].skillsDir
                     }));
                 const selected = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.multiselect({
-                    message: 'Select agents to install skills to',
+                    message: `Select agents to install skills to ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('(Space to toggle, Enter to confirm)')}`,
                     options: agentChoices,
                     required: true,
                     initialValues: installedAgents
@@ -1721,6 +1818,23 @@ const installCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('instal
         process.exit(1);
     }
 });
+const linkCmd = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('link').description('Link a local skill for development').argument('<path>', 'Path to local skill directory').option('-n, --name <name>', 'Custom skill name').action((localPath, options)=>{
+    const skillManager = new SkillManager();
+    try {
+        const linked = skillManager.link(localPath, options.name);
+        logger.log(`Linked skill available at: ${linked.path}`);
+    } catch (error) {
+        logger.error(error.message);
+        process.exit(1);
+    }
+});
+const unlinkCmd = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('unlink').description('Unlink a linked skill').argument('<skill>', 'Skill name to unlink').action((skillName)=>{
+    const skillManager = new SkillManager();
+    const result = skillManager.unlink(skillName);
+    if (!result) process.exit(1);
+});
+const linkCommand = linkCmd;
+const unlinkCommand = unlinkCmd;
 const listCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('list').alias('ls').description('List installed skills').option('-j, --json', 'Output as JSON').option('-g, --global', 'List globally installed skills').action((options)=>{
     const isGlobal = options.global || false;
     const skillManager = new SkillManager(void 0, {
@@ -1753,68 +1867,6 @@ const listCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('list').al
     logger.newline();
     logger.log(`Total: ${skills.length} skill(s)`);
 });
-const infoCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('info').description('Show skill details').argument('<skill>', 'Skill name').option('-j, --json', 'Output as JSON').action((skillName, options)=>{
-    const skillManager = new SkillManager();
-    const info = skillManager.getInfo(skillName);
-    if (options.json) {
-        console.log(JSON.stringify(info, null, 2));
-        return;
-    }
-    if (!info.installed && !info.config) {
-        logger.error(`Skill ${skillName} not found`);
-        process.exit(1);
-    }
-    logger.log(`Skill: ${skillName}`);
-    logger.newline();
-    if (info.config) {
-        logger.log("Configuration (skills.json):");
-        logger.log(`  Reference: ${info.config}`);
-    }
-    if (info.locked) {
-        logger.log("Locked Version (skills.lock):");
-        logger.log(`  Version: ${info.locked.version}`);
-        logger.log(`  Source: ${info.locked.source}`);
-        logger.log(`  Commit: ${info.locked.commit}`);
-        logger.log(`  Installed: ${info.locked.installedAt}`);
-    }
-    if (info.installed) {
-        logger.log("Installed:");
-        logger.log(`  Path: ${info.installed.path}`);
-        logger.log(`  Version: ${info.installed.version}`);
-        logger.log(`  Linked: ${info.installed.isLinked ? 'Yes' : 'No'}`);
-        if (info.installed.metadata) {
-            const meta = info.installed.metadata;
-            logger.log("Metadata (skill.json):");
-            if (meta.description) logger.log(`  Description: ${meta.description}`);
-            if (meta.author) logger.log(`  Author: ${meta.author}`);
-            if (meta.license) logger.log(`  License: ${meta.license}`);
-            if (meta.keywords?.length) logger.log(`  Keywords: ${meta.keywords.join(', ')}`);
-        }
-    } else logger.warn(`Skill ${skillName} is not installed`);
-});
-const updateCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('update').alias('up').description('Update installed skills').argument('[skill]', 'Skill name to update (updates all if not specified)').action(async (skill)=>{
-    const configLoader = new ConfigLoader();
-    if (!configLoader.exists()) {
-        logger.error("skills.json not found. Run 'reskill init' first.");
-        process.exit(1);
-    }
-    const skillManager = new SkillManager();
-    const spinner = (0, __WEBPACK_EXTERNAL_MODULE_ora__["default"])(skill ? `Updating ${skill}...` : 'Updating all skills...').start();
-    try {
-        const updated = await skillManager.update(skill);
-        spinner.stop();
-        if (0 === updated.length) {
-            logger.info('No skills to update');
-            return;
-        }
-        logger.success(`Updated ${updated.length} skill(s):`);
-        for (const s of updated)logger.log(`  - ${s.name}@${s.version}`);
-    } catch (error) {
-        spinner.fail('Update failed');
-        logger.error(error.message);
-        process.exit(1);
-    }
-});
 const outdatedCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('outdated').description('Check for outdated skills').option('-j, --json', 'Output as JSON').action(async (options)=>{
     const configLoader = new ConfigLoader();
     if (!configLoader.exists()) {
@@ -1874,23 +1926,29 @@ const uninstallCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('unin
     const result = skillManager.uninstall(skillName);
     if (!result) process.exit(1);
 });
-const linkCmd = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('link').description('Link a local skill for development').argument('<path>', 'Path to local skill directory').option('-n, --name <name>', 'Custom skill name').action((localPath, options)=>{
+const updateCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('update').alias('up').description('Update installed skills').argument('[skill]', 'Skill name to update (updates all if not specified)').action(async (skill)=>{
+    const configLoader = new ConfigLoader();
+    if (!configLoader.exists()) {
+        logger.error("skills.json not found. Run 'reskill init' first.");
+        process.exit(1);
+    }
     const skillManager = new SkillManager();
+    const spinner = (0, __WEBPACK_EXTERNAL_MODULE_ora__["default"])(skill ? `Updating ${skill}...` : 'Updating all skills...').start();
     try {
-        const linked = skillManager.link(localPath, options.name);
-        logger.log(`Linked skill available at: ${linked.path}`);
+        const updated = await skillManager.update(skill);
+        spinner.stop();
+        if (0 === updated.length) {
+            logger.info('No skills to update');
+            return;
+        }
+        logger.success(`Updated ${updated.length} skill(s):`);
+        for (const s of updated)logger.log(`  - ${s.name}@${s.version}`);
     } catch (error) {
+        spinner.fail('Update failed');
         logger.error(error.message);
         process.exit(1);
     }
 });
-const unlinkCmd = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('unlink').description('Unlink a linked skill').argument('<skill>', 'Skill name to unlink').action((skillName)=>{
-    const skillManager = new SkillManager();
-    const result = skillManager.unlink(skillName);
-    if (!result) process.exit(1);
-});
-const linkCommand = linkCmd;
-const unlinkCommand = unlinkCmd;
 const program = new __WEBPACK_EXTERNAL_MODULE_commander__.Command();
 program.name('reskill').description('AI Skills Package Manager - Git-based skills management for AI agents').version('0.1.0');
 program.addCommand(initCommand);