reskill 0.1.0 → 0.12.0

package/dist/cli/index.js

@@ -3,10 +3,12 @@ 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_ora__ from "ora";
-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_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) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_node_fs__;
@@ -35,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, {
@@ -102,115 +104,12 @@ function getGlobalSkillsDir() {
     const home = getHomeDir();
     return __WEBPACK_EXTERNAL_MODULE_node_path__.join(home, '.claude', 'skills');
 }
-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
-        };
-    }
-    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];
-    }
+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)}`;
+    return fullPath;
 }
 const logger = {
     info (message) {
@@ -253,30 +152,139 @@ 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;
@@ -288,7 +296,7 @@ class GitCloneError extends Error {
         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  - HTTPS: Run 'git config --global credential.helper store'";
             message += '\n  - Or use a personal access token in the URL';
         }
         super(message);
@@ -447,6 +455,229 @@ function parseGitUrl(url) {
     }
     return null;
 }
+class CacheManager {
+    cacheDir;
+    constructor(cacheDir){
+        this.cacheDir = cacheDir || getCacheDir();
+    }
+    getCacheDir() {
+        return this.cacheDir;
+    }
+    getSkillCachePath(parsed, version) {
+        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cacheDir, parsed.registry, parsed.owner, parsed.repo, version);
+    }
+    getCachePath(parsed, version) {
+        return this.getSkillCachePath(parsed, version);
+    }
+    isCached(parsed, version) {
+        const cachePath = this.getSkillCachePath(parsed, version);
+        return exists(cachePath) && isDirectory(cachePath);
+    }
+    async get(parsed, version) {
+        const cachePath = this.getSkillCachePath(parsed, version);
+        if (!this.isCached(parsed, version)) return null;
+        const commitFile = __WEBPACK_EXTERNAL_MODULE_node_path__.join(cachePath, '.reskill-commit');
+        let commit = '';
+        try {
+            const fs = await import("node:fs");
+            if (exists(commitFile)) commit = fs.readFileSync(commitFile, 'utf-8').trim();
+        } catch  {}
+        return {
+            path: cachePath,
+            commit
+        };
+    }
+    async cache(repoUrl, parsed, ref, version) {
+        const cachePath = this.getSkillCachePath(parsed, version);
+        if (exists(cachePath)) remove(cachePath);
+        ensureDir(__WEBPACK_EXTERNAL_MODULE_node_path__.dirname(cachePath));
+        const tempPath = `${cachePath}.tmp`;
+        remove(tempPath);
+        await clone(repoUrl, tempPath, {
+            depth: 1,
+            branch: ref
+        });
+        const commit = await getCurrentCommit(tempPath);
+        if (parsed.subPath) {
+            const subDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(tempPath, parsed.subPath);
+            if (!exists(subDir)) {
+                remove(tempPath);
+                throw new Error(`Subpath ${parsed.subPath} not found in repository`);
+            }
+            copyDir(subDir, cachePath, {
+                exclude: [
+                    '.git'
+                ]
+            });
+        } else copyDir(tempPath, cachePath, {
+            exclude: [
+                '.git'
+            ]
+        });
+        const fs = await import("node:fs");
+        fs.writeFileSync(__WEBPACK_EXTERNAL_MODULE_node_path__.join(cachePath, '.reskill-commit'), commit);
+        remove(tempPath);
+        return {
+            path: cachePath,
+            commit
+        };
+    }
+    async copyTo(parsed, version, destPath) {
+        const cached = await this.get(parsed, version);
+        if (!cached) throw new Error(`Skill ${parsed.raw} version ${version} not found in cache`);
+        if (exists(destPath)) remove(destPath);
+        copyDir(cached.path, destPath, {
+            exclude: [
+                '.reskill-commit'
+            ]
+        });
+    }
+    clearSkill(parsed, version) {
+        if (version) {
+            const cachePath = this.getSkillCachePath(parsed, version);
+            remove(cachePath);
+        } else {
+            const skillDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cacheDir, parsed.registry, parsed.owner, parsed.repo);
+            remove(skillDir);
+        }
+    }
+    clearAll() {
+        remove(this.cacheDir);
+    }
+    getStats() {
+        if (!exists(this.cacheDir)) return {
+            totalSkills: 0,
+            registries: []
+        };
+        const registries = listDir(this.cacheDir).filter((name)=>isDirectory(__WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cacheDir, name)));
+        let totalSkills = 0;
+        for (const registry of registries){
+            const registryPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cacheDir, registry);
+            const owners = listDir(registryPath).filter((name)=>isDirectory(__WEBPACK_EXTERNAL_MODULE_node_path__.join(registryPath, name)));
+            for (const owner of owners){
+                const ownerPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(registryPath, owner);
+                const repos = listDir(ownerPath).filter((name)=>isDirectory(__WEBPACK_EXTERNAL_MODULE_node_path__.join(ownerPath, name)));
+                totalSkills += repos.length;
+            }
+        }
+        return {
+            totalSkills,
+            registries
+        };
+    }
+}
+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 || '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();
+    }
+    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];
+    }
+}
 class GitResolver {
     defaultRegistry;
     constructor(defaultRegistry = 'github'){
@@ -619,112 +850,197 @@ class GitResolver {
         };
     }
 }
-class CacheManager {
-    cacheDir;
-    constructor(cacheDir){
-        this.cacheDir = cacheDir || getCacheDir();
-    }
-    getCacheDir() {
-        return this.cacheDir;
-    }
-    getSkillCachePath(parsed, version) {
-        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cacheDir, parsed.registry, parsed.owner, parsed.repo, version);
-    }
-    isCached(parsed, version) {
-        const cachePath = this.getSkillCachePath(parsed, version);
-        return exists(cachePath) && isDirectory(cachePath);
+const installer_AGENTS_DIR = '.agents';
+const installer_SKILLS_SUBDIR = 'skills';
+function installer_sanitizeName(name) {
+    let sanitized = name.replace(/[/\\:\0]/g, '');
+    sanitized = sanitized.replace(/^[.\s]+|[.\s]+$/g, '');
+    sanitized = sanitized.replace(/^\.+/, '');
+    if (!sanitized || 0 === sanitized.length) sanitized = 'unnamed-skill';
+    if (sanitized.length > 255) sanitized = sanitized.substring(0, 255);
+    return sanitized;
+}
+function installer_isPathSafe(basePath, targetPath) {
+    const normalizedBase = __WEBPACK_EXTERNAL_MODULE_node_path__.normalize(__WEBPACK_EXTERNAL_MODULE_node_path__.resolve(basePath));
+    const normalizedTarget = __WEBPACK_EXTERNAL_MODULE_node_path__.normalize(__WEBPACK_EXTERNAL_MODULE_node_path__.resolve(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_node_os__.homedir)() : cwd || process.cwd();
+    return __WEBPACK_EXTERNAL_MODULE_node_path__.join(baseDir, installer_AGENTS_DIR, installer_SKILLS_SUBDIR);
+}
+function installer_ensureDir(dirPath) {
+    if (!external_node_fs_.existsSync(dirPath)) external_node_fs_.mkdirSync(dirPath, {
+        recursive: true
+    });
+}
+function installer_remove(targetPath) {
+    if (external_node_fs_.existsSync(targetPath)) external_node_fs_.rmSync(targetPath, {
+        recursive: true,
+        force: true
+    });
+}
+function copyDirectory(src, dest, options) {
+    const exclude = new Set(options?.exclude || [
+        'README.md',
+        'metadata.json'
+    ]);
+    installer_ensureDir(dest);
+    const entries = external_node_fs_.readdirSync(src, {
+        withFileTypes: true
+    });
+    for (const entry of entries){
+        if (exclude.has(entry.name) || entry.name.startsWith('_')) continue;
+        const srcPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(src, entry.name);
+        const destPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(dest, entry.name);
+        if (entry.isDirectory()) copyDirectory(srcPath, destPath, options);
+        else external_node_fs_.copyFileSync(srcPath, destPath);
     }
-    async get(parsed, version) {
-        const cachePath = this.getSkillCachePath(parsed, version);
-        if (!this.isCached(parsed, version)) return null;
-        const commitFile = __WEBPACK_EXTERNAL_MODULE_node_path__.join(cachePath, '.reskill-commit');
-        let commit = '';
+}
+async function installer_createSymlink(target, linkPath) {
+    try {
         try {
-            const fs = await import("node:fs");
-            if (exists(commitFile)) commit = fs.readFileSync(commitFile, 'utf-8').trim();
-        } catch  {}
-        return {
-            path: cachePath,
-            commit
-        };
-    }
-    async cache(repoUrl, parsed, ref, version) {
-        const cachePath = this.getSkillCachePath(parsed, version);
-        if (exists(cachePath)) remove(cachePath);
-        ensureDir(__WEBPACK_EXTERNAL_MODULE_node_path__.dirname(cachePath));
-        const tempPath = `${cachePath}.tmp`;
-        remove(tempPath);
-        await clone(repoUrl, tempPath, {
-            depth: 1,
-            branch: ref
-        });
-        const commit = await getCurrentCommit(tempPath);
-        if (parsed.subPath) {
-            const subDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(tempPath, parsed.subPath);
-            if (!exists(subDir)) {
-                remove(tempPath);
-                throw new Error(`Subpath ${parsed.subPath} not found in repository`);
-            }
-            copyDir(subDir, cachePath, {
-                exclude: [
-                    '.git'
-                ]
+            const stats = external_node_fs_.lstatSync(linkPath);
+            if (stats.isSymbolicLink()) {
+                const existingTarget = external_node_fs_.readlinkSync(linkPath);
+                if (__WEBPACK_EXTERNAL_MODULE_node_path__.resolve(existingTarget) === __WEBPACK_EXTERNAL_MODULE_node_path__.resolve(target)) return true;
+                external_node_fs_.rmSync(linkPath);
+            } else external_node_fs_.rmSync(linkPath, {
+                recursive: true
             });
-        } else copyDir(tempPath, cachePath, {
-            exclude: [
-                '.git'
-            ]
-        });
-        const fs = await import("node:fs");
-        fs.writeFileSync(__WEBPACK_EXTERNAL_MODULE_node_path__.join(cachePath, '.reskill-commit'), commit);
-        remove(tempPath);
-        return {
-            path: cachePath,
-            commit
-        };
-    }
-    async copyTo(parsed, version, destPath) {
-        const cached = await this.get(parsed, version);
-        if (!cached) throw new Error(`Skill ${parsed.raw} version ${version} not found in cache`);
-        if (exists(destPath)) remove(destPath);
-        copyDir(cached.path, destPath, {
-            exclude: [
-                '.reskill-commit'
-            ]
-        });
-    }
-    clearSkill(parsed, version) {
-        if (version) {
-            const cachePath = this.getSkillCachePath(parsed, version);
-            remove(cachePath);
-        } else {
-            const skillDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cacheDir, parsed.registry, parsed.owner, parsed.repo);
-            remove(skillDir);
+        } catch (err) {
+            if (err && 'object' == typeof err && 'code' in err) {
+                if ('ELOOP' === err.code) try {
+                    external_node_fs_.rmSync(linkPath, {
+                        force: true
+                    });
+                } catch  {}
+            }
         }
+        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_node_os__.platform)() ? 'junction' : void 0;
+        external_node_fs_.symlinkSync(relativePath, linkPath, symlinkType);
+        return true;
+    } catch  {
+        return false;
     }
-    clearAll() {
-        remove(this.cacheDir);
-    }
-    getStats() {
-        if (!exists(this.cacheDir)) return {
-            totalSkills: 0,
-            registries: []
+}
+class Installer {
+    cwd;
+    isGlobal;
+    constructor(options = {}){
+        this.cwd = options.cwd || process.cwd();
+        this.isGlobal = options.global || false;
+    }
+    getCanonicalPath(skillName) {
+        const sanitized = installer_sanitizeName(skillName);
+        const canonicalBase = installer_getCanonicalSkillsDir(this.isGlobal, this.cwd);
+        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(canonicalBase, sanitized);
+    }
+    getAgentSkillPath(skillName, agentType) {
+        const agent = getAgentConfig(agentType);
+        const sanitized = installer_sanitizeName(skillName);
+        const agentBase = this.isGlobal ? agent.globalSkillsDir : __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cwd, agent.skillsDir);
+        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(agentBase, sanitized);
+    }
+    async installForAgent(sourcePath, skillName, agentType, options = {}) {
+        const agent = getAgentConfig(agentType);
+        const installMode = options.mode || 'symlink';
+        const sanitized = installer_sanitizeName(skillName);
+        const canonicalBase = installer_getCanonicalSkillsDir(this.isGlobal, this.cwd);
+        const canonicalDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(canonicalBase, sanitized);
+        const agentBase = this.isGlobal ? agent.globalSkillsDir : __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cwd, agent.skillsDir);
+        const agentDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(agentBase, sanitized);
+        if (!installer_isPathSafe(canonicalBase, canonicalDir)) return {
+            success: false,
+            path: agentDir,
+            mode: installMode,
+            error: 'Invalid skill name: potential path traversal detected'
         };
-        const registries = listDir(this.cacheDir).filter((name)=>isDirectory(__WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cacheDir, name)));
-        let totalSkills = 0;
-        for (const registry of registries){
-            const registryPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cacheDir, registry);
-            const owners = listDir(registryPath).filter((name)=>isDirectory(__WEBPACK_EXTERNAL_MODULE_node_path__.join(registryPath, name)));
-            for (const owner of owners){
-                const ownerPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(registryPath, owner);
-                const repos = listDir(ownerPath).filter((name)=>isDirectory(__WEBPACK_EXTERNAL_MODULE_node_path__.join(ownerPath, name)));
-                totalSkills += repos.length;
+        if (!installer_isPathSafe(agentBase, agentDir)) return {
+            success: false,
+            path: agentDir,
+            mode: installMode,
+            error: 'Invalid skill name: potential path traversal detected'
+        };
+        try {
+            if ('copy' === installMode) {
+                installer_ensureDir(agentDir);
+                installer_remove(agentDir);
+                copyDirectory(sourcePath, agentDir);
+                return {
+                    success: true,
+                    path: agentDir,
+                    mode: 'copy'
+                };
+            }
+            installer_ensureDir(canonicalDir);
+            installer_remove(canonicalDir);
+            copyDirectory(sourcePath, canonicalDir);
+            const symlinkCreated = await installer_createSymlink(canonicalDir, agentDir);
+            if (!symlinkCreated) {
+                try {
+                    installer_remove(agentDir);
+                } catch  {}
+                installer_ensureDir(agentDir);
+                copyDirectory(sourcePath, agentDir);
+                return {
+                    success: true,
+                    path: agentDir,
+                    canonicalPath: canonicalDir,
+                    mode: 'symlink',
+                    symlinkFailed: true
+                };
             }
+            return {
+                success: true,
+                path: agentDir,
+                canonicalPath: canonicalDir,
+                mode: 'symlink'
+            };
+        } catch (error) {
+            return {
+                success: false,
+                path: agentDir,
+                mode: installMode,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    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 {
-            totalSkills,
-            registries
-        };
+        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;
@@ -853,8 +1169,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;
@@ -867,11 +1192,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}...`);
@@ -885,7 +1212,7 @@ 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
@@ -893,7 +1220,9 @@ class SkillManager {
         if (!this.isGlobal && save && this.config.exists()) 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();
@@ -960,7 +1289,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 {
@@ -986,20 +1315,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);
@@ -1017,6 +1362,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),
@@ -1056,91 +1408,85 @@ class SkillManager {
         }
         return results;
     }
-}
-const installCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('install').alias('i').description('Install a skill or all skills from skills.json').argument('[skill]', 'Skill reference (e.g., github:user/skill@v1.0.0 or git@github.com:user/repo.git)').option('-f, --force', 'Force reinstall even if already installed').option('-g, --global', 'Install globally to ~/.claude/skills').option('--no-save', 'Do not save to skills.json').action(async (skill, options)=>{
-    const isGlobal = options.global || false;
-    const configLoader = new ConfigLoader();
-    const skillManager = new SkillManager(void 0, {
-        global: isGlobal
-    });
-    if (isGlobal) logger.info(`Installing to ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(getGlobalSkillsDir())} ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('(global)')}`);
-    if (skill) {
-        const spinner = (0, __WEBPACK_EXTERNAL_MODULE_ora__["default"])(`Installing ${skill}...`).start();
-        try {
-            const installed = await skillManager.install(skill, {
-                force: options.force,
-                save: options.save && !isGlobal,
-                global: isGlobal
-            });
-            const location = isGlobal ? __WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim(' (global)') : '';
-            spinner.succeed(`Installed ${installed.name}@${installed.version}${location}`);
-        } catch (error) {
-            spinner.fail('Installation failed');
-            logger.error(error.message);
-            process.exit(1);
-        }
-    } else {
-        if (isGlobal) {
-            logger.error('Cannot install all skills globally. Please specify a skill to install.');
-            process.exit(1);
-        }
-        if (!configLoader.exists()) {
-            logger.error("skills.json not found. Run 'reskill init' first.");
-            process.exit(1);
-        }
-        const skills = configLoader.getSkills();
-        if (0 === Object.keys(skills).length) {
-            logger.info('No skills defined in skills.json');
-            return;
-        }
-        logger["package"]('Installing all skills from skills.json...');
-        const spinner = (0, __WEBPACK_EXTERNAL_MODULE_ora__["default"])('Installing...').start();
-        try {
-            const installed = await skillManager.installAll({
-                force: options.force
-            });
-            spinner.stop();
-            logger.newline();
-            logger.success(`Installed ${installed.length} skill(s)`);
-        } catch (error) {
-            spinner.fail('Installation failed');
-            logger.error(error.message);
-            process.exit(1);
+    async installToAgents(ref, targetAgents, options = {}) {
+        const { save = true, mode = 'symlink' } = options;
+        const resolved = await this.resolver.resolve(ref);
+        const { parsed, repoUrl } = resolved;
+        const version = resolved.ref;
+        const skillName = parsed.subPath ? __WEBPACK_EXTERNAL_MODULE_node_path__.basename(parsed.subPath) : parsed.repo;
+        logger["package"](`Installing ${skillName}@${version} to ${targetAgents.length} agent(s)...`);
+        let cacheResult = await this.cache.get(parsed, version);
+        if (cacheResult) logger.debug(`Using cached ${skillName}@${version}`);
+        else {
+            logger.debug(`Caching ${skillName}@${version} from ${repoUrl}`);
+            cacheResult = await this.cache.cache(repoUrl, parsed, version, version);
         }
+        const sourcePath = this.cache.getCachePath(parsed, version);
+        const installer = new Installer({
+            cwd: this.projectRoot,
+            global: this.isGlobal
+        });
+        const results = await installer.installToAgents(sourcePath, skillName, targetAgents, {
+            mode: mode
+        });
+        if (!this.isGlobal) this.lockManager.lockSkill(skillName, {
+            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);
+        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)`);
+        else logger.warn(`Installed ${skillName}@${version} to ${successCount} agent(s), ${failCount} failed`);
+        const skill = {
+            name: skillName,
+            path: sourcePath,
+            version,
+            source: `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? `/${parsed.subPath}` : ''}`
+        };
+        return {
+            skill,
+            results
+        };
     }
-});
-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, {
-        global: isGlobal
-    });
-    const skills = skillManager.list();
-    if (0 === skills.length) {
-        const location = isGlobal ? 'globally' : 'in this project';
-        logger.info(`No skills installed ${location}`);
-        return;
+    async getDefaultTargetAgents() {
+        const defaults = this.config.getDefaults();
+        if (defaults.targetAgents && defaults.targetAgents.length > 0) return defaults.targetAgents.filter(isValidAgentType);
+        return detectInstalledAgents();
     }
-    if (options.json) {
-        console.log(JSON.stringify(skills, null, 2));
-        return;
+    getDefaultInstallMode() {
+        const defaults = this.config.getDefaults();
+        if ('copy' === defaults.installMode || 'symlink' === defaults.installMode) return defaults.installMode;
+        return 'symlink';
+    }
+    validateAgentTypes(agentNames) {
+        const valid = [];
+        const invalid = [];
+        for (const name of agentNames)if (isValidAgentType(name)) valid.push(name);
+        else invalid.push(name);
+        return {
+            valid,
+            invalid
+        };
     }
-    const locationLabel = isGlobal ? __WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim(' (global)') : '';
-    logger.log(`Installed Skills (${skillManager.getInstallDir()})${locationLabel}:`);
-    logger.newline();
-    const headers = [
-        'Name',
-        'Version',
-        'Source'
-    ];
-    const rows = skills.map((skill)=>[
-            skill.name,
-            skill.isLinked ? `${skill.version} (linked)` : skill.version,
-            skill.source || '-'
-        ]);
-    logger.table(headers, rows);
-    logger.newline();
-    logger.log(`Total: ${skills.length} skill(s)`);
-});
+    getAllAgentTypes() {
+        return Object.keys(agents);
+    }
+    uninstallFromAgents(name, targetAgents) {
+        const installer = new Installer({
+            cwd: this.projectRoot,
+            global: this.isGlobal
+        });
+        const results = installer.uninstallFromAgents(name, targetAgents);
+        if (!this.isGlobal) this.lockManager.remove(name);
+        if (!this.isGlobal && this.config.exists()) this.config.removeSkill(name);
+        const successCount = Array.from(results.values()).filter((r)=>r).length;
+        logger.success(`Uninstalled ${name} from ${successCount} agent(s)`);
+        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);
@@ -1180,29 +1526,323 @@ const infoCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('info').de
         }
     } 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 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.error("skills.json not found. Run 'reskill init' first.");
+    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(', ');
+    const shown = names.slice(0, maxShow);
+    const remaining = names.length - maxShow;
+    return `${shown.join(', ')} +${remaining} more`;
+}
+const installCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('install').alias('i').description('Install a skill or all skills from skills.json').argument('[skill]', 'Skill reference (e.g., github:user/skill@v1.0.0 or git@github.com:user/repo.git)').option('-f, --force', 'Force reinstall even if already installed').option('-g, --global', 'Install globally to user home directory').option('--no-save', 'Do not save to skills.json').option('-a, --agent <agents...>', 'Specify target agents (e.g., cursor, claude-code)').option('--mode <mode>', 'Installation mode: symlink or copy').option('-y, --yes', 'Skip confirmation prompts').option('--all', 'Install to all agents (implies -y -g)').action(async (skill, options)=>{
+    if (options.all) {
+        options.yes = true;
+        options.global = true;
+    }
+    const skipConfirm = options.yes || false;
+    const configLoader = new ConfigLoader();
+    const allAgentTypes = Object.keys(agents);
+    console.log();
+    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.intro(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].bgCyan.black(' reskill '));
+    try {
+        const spinner = __WEBPACK_EXTERNAL_MODULE__clack_prompts__.spinner();
+        let targetAgents;
+        if (options.all) {
+            targetAgents = allAgentTypes;
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info(`Installing to all ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(targetAgents.length)} agents`);
+        } else if (options.agent && options.agent.length > 0) {
+            const validAgents = Object.keys(agents);
+            const invalidAgents = options.agent.filter((a)=>!validAgents.includes(a));
+            if (invalidAgents.length > 0) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.error(`Invalid agents: ${invalidAgents.join(', ')}`);
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info(`Valid agents: ${validAgents.join(', ')}`);
+                process.exit(1);
+            }
+            targetAgents = options.agent;
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info(`Installing to: ${formatAgentNames(targetAgents)}`);
+        } else {
+            spinner.start('Detecting installed agents...');
+            const installedAgents = await detectInstalledAgents();
+            spinner.stop(`Detected ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(installedAgents.length)} agent${1 !== installedAgents.length ? 's' : ''}`);
+            if (0 === installedAgents.length) {
+                if (skipConfirm) {
+                    targetAgents = allAgentTypes;
+                    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info('Installing to all agents (none detected)');
+                } else {
+                    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.warn('No coding agents detected. You can still install skills.');
+                    const allAgentChoices = Object.entries(agents).map(([key, config])=>({
+                            value: key,
+                            label: config.displayName
+                        }));
+                    const selected = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.multiselect({
+                        message: 'Select agents to install skills to',
+                        options: allAgentChoices,
+                        required: true,
+                        initialValues: allAgentTypes
+                    });
+                    if (__WEBPACK_EXTERNAL_MODULE__clack_prompts__.isCancel(selected)) {
+                        __WEBPACK_EXTERNAL_MODULE__clack_prompts__.cancel('Installation cancelled');
+                        process.exit(0);
+                    }
+                    targetAgents = selected;
+                }
+            } else if (1 === installedAgents.length || skipConfirm) {
+                targetAgents = installedAgents;
+                if (1 === installedAgents.length) __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info(`Installing to: ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(agents[installedAgents[0]].displayName)}`);
+                else __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info(`Installing to: ${installedAgents.map((a)=>__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(agents[a].displayName)).join(', ')}`);
+            } else {
+                const agentChoices = installedAgents.map((a)=>({
+                        value: a,
+                        label: agents[a].displayName,
+                        hint: agents[a].skillsDir
+                    }));
+                const selected = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.multiselect({
+                    message: 'Select agents to install skills to',
+                    options: agentChoices,
+                    required: true,
+                    initialValues: installedAgents
+                });
+                if (__WEBPACK_EXTERNAL_MODULE__clack_prompts__.isCancel(selected)) {
+                    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.cancel('Installation cancelled');
+                    process.exit(0);
+                }
+                targetAgents = selected;
+            }
+        }
+        let installGlobally = options.global ?? false;
+        if (void 0 === options.global && !skipConfirm) {
+            const scope = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.select({
+                message: 'Installation scope',
+                options: [
+                    {
+                        value: false,
+                        label: 'Project',
+                        hint: 'Install in current directory (committed with your project)'
+                    },
+                    {
+                        value: true,
+                        label: 'Global',
+                        hint: 'Install in home directory (available across all projects)'
+                    }
+                ]
+            });
+            if (__WEBPACK_EXTERNAL_MODULE__clack_prompts__.isCancel(scope)) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.cancel('Installation cancelled');
+                process.exit(0);
+            }
+            installGlobally = scope;
+        }
+        let installMode = options.mode || 'symlink';
+        if (!options.mode && !skipConfirm) {
+            const modeChoice = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.select({
+                message: 'Installation method',
+                options: [
+                    {
+                        value: 'symlink',
+                        label: 'Symlink (Recommended)',
+                        hint: 'Single source of truth, easy updates'
+                    },
+                    {
+                        value: 'copy',
+                        label: 'Copy to all agents',
+                        hint: 'Independent copies for each agent'
+                    }
+                ]
+            });
+            if (__WEBPACK_EXTERNAL_MODULE__clack_prompts__.isCancel(modeChoice)) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.cancel('Installation cancelled');
+                process.exit(0);
+            }
+            installMode = modeChoice;
+        }
+        const skillManager = new SkillManager(void 0, {
+            global: installGlobally
+        });
+        const cwd = process.cwd();
+        if (skill) {
+            const summaryLines = [];
+            summaryLines.push(`${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(skill)}`);
+            summaryLines.push(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('→')} ${formatAgentNames(targetAgents)}`);
+            summaryLines.push(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('Scope:')} ${installGlobally ? 'Global' : 'Project'}${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim(', Mode:')} ${installMode}`);
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts__.note(summaryLines.join('\n'), 'Installation Summary');
+            if (!skipConfirm) {
+                const confirmed = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.confirm({
+                    message: 'Proceed with installation?'
+                });
+                if (__WEBPACK_EXTERNAL_MODULE__clack_prompts__.isCancel(confirmed) || !confirmed) {
+                    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.cancel('Installation cancelled');
+                    process.exit(0);
+                }
+            }
+            spinner.start(`Installing ${skill}...`);
+            const { skill: installed, results } = await skillManager.installToAgents(skill, targetAgents, {
+                force: options.force,
+                save: options.save && !installGlobally,
+                mode: installMode
+            });
+            spinner.stop('Installation complete');
+            const successful = Array.from(results.entries()).filter(([, r])=>r.success);
+            const failed = Array.from(results.entries()).filter(([, r])=>!r.success);
+            const symlinkFailed = successful.filter(([, r])=>'symlink' === r.mode && r.symlinkFailed);
+            if (successful.length > 0) {
+                const resultLines = [];
+                const firstResult = successful[0][1];
+                if ('copy' === firstResult.mode) {
+                    resultLines.push(`${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green('✓')} ${installed.name}@${installed.version} ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('(copied)')}`);
+                    for (const [, result] of successful){
+                        const shortPath = shortenPath(result.path, cwd);
+                        resultLines.push(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('→')} ${shortPath}`);
+                    }
+                } else {
+                    if (firstResult.canonicalPath) {
+                        const shortPath = shortenPath(firstResult.canonicalPath, cwd);
+                        resultLines.push(`${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green('✓')} ${shortPath}`);
+                    } else resultLines.push(`${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green('✓')} ${installed.name}@${installed.version}`);
+                    const symlinked = successful.filter(([, r])=>!r.symlinkFailed).map(([a])=>agents[a].displayName);
+                    const copied = successful.filter(([, r])=>r.symlinkFailed).map(([a])=>agents[a].displayName);
+                    if (symlinked.length > 0) resultLines.push(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('symlink →')} ${symlinked.join(', ')}`);
+                    if (copied.length > 0) resultLines.push(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].yellow('copied →')} ${copied.join(', ')}`);
+                }
+                const title = __WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(`Installed 1 skill to ${successful.length} agent${1 !== successful.length ? 's' : ''}`);
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.note(resultLines.join('\n'), title);
+                if (symlinkFailed.length > 0) {
+                    const copiedAgentNames = symlinkFailed.map(([a])=>agents[a].displayName);
+                    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.warn(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].yellow(`Symlinks failed for: ${copiedAgentNames.join(', ')}`));
+                    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.message(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('  Files were copied instead. On Windows, enable Developer Mode for symlink support.'));
+                }
+            }
+            if (failed.length > 0) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.error(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].red(`Failed to install to ${failed.length} agent(s)`));
+                for (const [agent, result] of failed)__WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.message(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].red('✗')} ${agents[agent].displayName}: ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim(result.error)}`);
+            }
+        } else {
+            if (installGlobally) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.error('Cannot install all skills globally. Please specify a skill to install.');
+                process.exit(1);
+            }
+            if (!configLoader.exists()) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.error("skills.json not found. Run 'reskill init' first.");
+                process.exit(1);
+            }
+            const skills = configLoader.getSkills();
+            if (0 === Object.keys(skills).length) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info('No skills defined in skills.json');
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.outro('Done');
+                return;
+            }
+            const summaryLines = [];
+            summaryLines.push(`${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(Object.keys(skills).length)} skill(s) → ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(targetAgents.length)} agent(s)`);
+            summaryLines.push(`${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('Scope:')} ${installGlobally ? 'Global (~/)' : 'Project (./)'}${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim(', Mode:')} ${installMode}`);
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts__.note(summaryLines.join('\n'), 'Installation Summary');
+            if (!skipConfirm) {
+                const confirmed = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.confirm({
+                    message: 'Proceed with installation?'
+                });
+                if (__WEBPACK_EXTERNAL_MODULE__clack_prompts__.isCancel(confirmed) || !confirmed) {
+                    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.cancel('Installation cancelled');
+                    process.exit(0);
+                }
+            }
+            spinner.start('Installing skills...');
+            let totalInstalled = 0;
+            let totalFailed = 0;
+            for (const [name, ref] of Object.entries(skills))try {
+                const { results } = await skillManager.installToAgents(ref, targetAgents, {
+                    force: options.force,
+                    save: false,
+                    mode: installMode
+                });
+                const successCount = Array.from(results.values()).filter((r)=>r.success).length;
+                totalInstalled += successCount;
+                totalFailed += results.size - successCount;
+            } catch (error) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.error(`Failed to install ${name}: ${error.message}`);
+                totalFailed += targetAgents.length;
+            }
+            spinner.stop('Installation complete');
+            if (0 === totalFailed) __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.success(`Installed ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(Object.keys(skills).length)} skill(s) to ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(targetAgents.length)} agent(s)`);
+            else __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.warn(`Installed ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(totalInstalled)} successfully, ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].red(totalFailed)} failed`);
+        }
+        console.log();
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts__.outro(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green('Done!'));
+    } catch (error) {
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.error(error.message);
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts__.outro(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].red('Installation failed'));
         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();
-    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}`);
+        const linked = skillManager.link(localPath, options.name);
+        logger.log(`Linked skill available at: ${linked.path}`);
     } 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 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, {
+        global: isGlobal
+    });
+    const skills = skillManager.list();
+    if (0 === skills.length) {
+        const location = isGlobal ? 'globally' : 'in this project';
+        logger.info(`No skills installed ${location}`);
+        return;
+    }
+    if (options.json) {
+        console.log(JSON.stringify(skills, null, 2));
+        return;
+    }
+    const locationLabel = isGlobal ? __WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim(' (global)') : '';
+    logger.log(`Installed Skills (${skillManager.getInstallDir()})${locationLabel}:`);
+    logger.newline();
+    const headers = [
+        'Name',
+        'Version',
+        'Source'
+    ];
+    const rows = skills.map((skill)=>[
+            skill.name,
+            skill.isLinked ? `${skill.version} (linked)` : skill.version,
+            skill.source || '-'
+        ]);
+    logger.table(headers, rows);
+    logger.newline();
+    logger.log(`Total: ${skills.length} skill(s)`);
+});
 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()) {
@@ -1262,23 +1902,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);