reskill 1.20.3 → 1.22.0

package/dist/cli/index.js

@@ -156,10 +156,616 @@ var external_node_fs_ = __webpack_require__("node:fs");
 └────────────────────────────────────────────────────┘
 `;
 }
+/**
+ * Skill Parser - SKILL.md parser
+ *
+ * Following agentskills.io specification: https://agentskills.io/specification
+ *
+ * SKILL.md format requirements:
+ * - YAML frontmatter containing name and description (required)
+ * - name: max 64 characters, lowercase letters, numbers, hyphens
+ * - description: max 1024 characters
+ * - Optional fields: license, compatibility, metadata, allowed-tools
+ */ /**
+ * Skill validation error
+ */ class SkillValidationError extends Error {
+    field;
+    constructor(message, field){
+        super(message), this.field = field;
+        this.name = 'SkillValidationError';
+    }
+}
+/**
+ * Simple YAML frontmatter parser
+ * Parses --- delimited YAML header
+ *
+ * Supports:
+ * - Basic key: value pairs
+ * - Multiline strings (| and >)
+ * - Nested objects (one level deep, for metadata field)
+ */ function parseFrontmatter(content) {
+    const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) return {
+        data: {},
+        content
+    };
+    const yamlContent = match[1];
+    const markdownContent = match[2];
+    // Simple YAML parsing (supports basic key: value, one level of nesting,
+    // block scalars (| and >), and plain scalars spanning multiple indented lines)
+    const data = {};
+    const lines = yamlContent.split('\n');
+    let currentKey = '';
+    let currentValue = '';
+    let inMultiline = false;
+    let inNestedObject = false;
+    let inPlainScalar = false;
+    let nestedObject = {};
+    /**
+   * Save the current key/value accumulated so far, then reset state.
+   */ function flushCurrent() {
+        if (!currentKey) return;
+        if (inNestedObject) {
+            data[currentKey] = nestedObject;
+            nestedObject = {};
+            inNestedObject = false;
+        } else if (inPlainScalar || inMultiline) {
+            data[currentKey] = currentValue.trim();
+            inPlainScalar = false;
+            inMultiline = false;
+        } else data[currentKey] = parseYamlValue(currentValue.trim());
+        currentKey = '';
+        currentValue = '';
+    }
+    for (const line of lines){
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.startsWith('#')) continue;
+        const isIndented = line.startsWith('  ');
+        // ---- Inside a block scalar (| or >) ----
+        if (inMultiline) {
+            if (isIndented) {
+                currentValue += (currentValue ? '\n' : '') + line.slice(2);
+                continue;
+            }
+            // Unindented line ends the block scalar — fall through to top-level parsing
+            flushCurrent();
+        }
+        // ---- Inside a plain scalar (multiline value without | or >) ----
+        if (inPlainScalar) {
+            if (isIndented) {
+                // Continuation line: join with a space (YAML plain scalar folding)
+                currentValue += ` ${trimmedLine}`;
+                continue;
+            }
+            // Unindented line ends the plain scalar — fall through to top-level parsing
+            flushCurrent();
+        }
+        // ---- Inside a nested object ----
+        if (inNestedObject && isIndented) {
+            const nestedMatch = line.match(/^ {2}([a-zA-Z_-]+):\s*(.*)$/);
+            if (nestedMatch) {
+                const [, nestedKey, nestedValue] = nestedMatch;
+                nestedObject[nestedKey] = parseYamlValue(nestedValue.trim());
+                continue;
+            }
+            // Indented line that isn't a nested key:value — this key was actually
+            // a plain scalar, not a nested object. Switch modes.
+            inNestedObject = false;
+            inPlainScalar = true;
+            currentValue = trimmedLine;
+            continue;
+        }
+        // ---- Top-level key: value ----
+        const keyValueMatch = line.match(/^([a-zA-Z_-]+):\s*(.*)$/);
+        if (keyValueMatch) {
+            flushCurrent();
+            currentKey = keyValueMatch[1];
+            currentValue = keyValueMatch[2];
+            if ('|' === currentValue || '>' === currentValue) {
+                inMultiline = true;
+                currentValue = '';
+            } else if ('' === currentValue) {
+                // Empty value — could be nested object or plain scalar; peek at next lines
+                inNestedObject = true;
+                nestedObject = {};
+            }
+            continue;
+        }
+        // ---- Unindented line that isn't key:value while in nested object ----
+        if (inNestedObject) flushCurrent();
+    }
+    // Save last accumulated value
+    flushCurrent();
+    return {
+        data,
+        content: markdownContent
+    };
+}
+/**
+ * Parse YAML value
+ */ function parseYamlValue(value) {
+    if (!value) return '';
+    // Boolean value
+    if ('true' === value) return true;
+    if ('false' === value) return false;
+    // Number
+    if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+    if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
+    // Remove quotes
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+    return value;
+}
+/**
+ * Validate skill name format
+ *
+ * Specification requirements:
+ * - Max 64 characters
+ * - Only lowercase letters, numbers, hyphens allowed
+ * - Cannot start or end with hyphen
+ * - Cannot contain consecutive hyphens
+ */ function validateSkillName(name) {
+    if (!name) throw new SkillValidationError('Skill name is required', 'name');
+    if (name.length > 64) throw new SkillValidationError('Skill name must be at most 64 characters', 'name');
+    if (!/^[a-z0-9]/.test(name)) throw new SkillValidationError('Skill name must start with a lowercase letter or number', 'name');
+    if (!/[a-z0-9]$/.test(name)) throw new SkillValidationError('Skill name must end with a lowercase letter or number', 'name');
+    if (/--/.test(name)) throw new SkillValidationError('Skill name cannot contain consecutive hyphens', 'name');
+    if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(name) && name.length > 1) throw new SkillValidationError('Skill name can only contain lowercase letters, numbers, and hyphens', 'name');
+    // Single character name
+    if (1 === name.length && !/^[a-z0-9]$/.test(name)) throw new SkillValidationError('Single character skill name must be a lowercase letter or number', 'name');
+}
+/**
+ * Validate skill description
+ *
+ * Specification requirements:
+ * - Max 1024 characters
+ * - Angle brackets are allowed per agentskills.io spec
+ */ function validateSkillDescription(description) {
+    if (!description) throw new SkillValidationError('Skill description is required', 'description');
+    if (description.length > 1024) throw new SkillValidationError('Skill description must be at most 1024 characters', 'description');
+// Note: angle brackets are allowed per agentskills.io spec
+}
+/**
+ * Parse SKILL.md content
+ *
+ * @param content - SKILL.md file content
+ * @param options - Parse options
+ * @returns Parsed skill info, or null if format is invalid
+ * @throws SkillValidationError if validation fails in strict mode
+ */ function parseSkillMd(content, options = {}) {
+    const { strict = false } = options;
+    try {
+        const { data, content: body } = parseFrontmatter(content);
+        // Check required fields
+        if (!data.name || !data.description) {
+            if (strict) throw new SkillValidationError('SKILL.md must have name and description in frontmatter');
+            return null;
+        }
+        const name = String(data.name);
+        const description = String(data.description);
+        // Validate field format
+        if (strict) {
+            validateSkillName(name);
+            validateSkillDescription(description);
+        }
+        // Parse allowed-tools
+        let allowedTools;
+        if (data['allowed-tools']) {
+            const toolsStr = String(data['allowed-tools']);
+            allowedTools = toolsStr.split(/\s+/).filter(Boolean);
+        }
+        return {
+            name,
+            description,
+            version: data.version ? String(data.version) : void 0,
+            license: data.license ? String(data.license) : void 0,
+            compatibility: data.compatibility ? String(data.compatibility) : void 0,
+            metadata: data.metadata,
+            allowedTools,
+            content: body,
+            rawContent: content
+        };
+    } catch (error) {
+        if (error instanceof SkillValidationError) throw error;
+        if (strict) throw new SkillValidationError(`Failed to parse SKILL.md: ${error}`);
+        return null;
+    }
+}
+/**
+ * Parse SKILL.md from file path
+ */ function parseSkillMdFile(filePath, options = {}) {
+    if (!external_node_fs_.existsSync(filePath)) {
+        if (options.strict) throw new SkillValidationError(`SKILL.md not found: ${filePath}`);
+        return null;
+    }
+    const content = external_node_fs_.readFileSync(filePath, 'utf-8');
+    return parseSkillMd(content, options);
+}
+/**
+ * Parse SKILL.md from skill directory
+ */ function parseSkillFromDir(dirPath, options = {}) {
+    const skillMdPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(dirPath, 'SKILL.md');
+    return parseSkillMdFile(skillMdPath, options);
+}
+/**
+ * Check if directory contains valid SKILL.md
+ */ function hasValidSkillMd(dirPath) {
+    const skillMdPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(dirPath, 'SKILL.md');
+    if (!external_node_fs_.existsSync(skillMdPath)) return false;
+    try {
+        const skill = parseSkillMdFile(skillMdPath);
+        return null !== skill;
+    } catch  {
+        return false;
+    }
+}
+const SKIP_DIRS = [
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    '__pycache__'
+];
+const MAX_DISCOVER_DEPTH = 5;
+const PRIORITY_SKILL_DIRS = [
+    'skills',
+    '.agents/skills',
+    '.cursor/skills',
+    '.claude/skills',
+    '.windsurf/skills',
+    '.github/skills'
+];
+function findSkillDirsRecursive(dir, depth, maxDepth, visitedDirs) {
+    if (depth > maxDepth) return [];
+    const resolvedDir = __WEBPACK_EXTERNAL_MODULE_node_path__.resolve(dir);
+    if (visitedDirs.has(resolvedDir)) return [];
+    if (!external_node_fs_.existsSync(dir) || !external_node_fs_.statSync(dir).isDirectory()) return [];
+    visitedDirs.add(resolvedDir);
+    const results = [];
+    let entries;
+    try {
+        entries = external_node_fs_.readdirSync(dir);
+    } catch  {
+        return [];
+    }
+    for (const entry of entries){
+        if (SKIP_DIRS.includes(entry)) continue;
+        const fullPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(dir, entry);
+        const resolvedFull = __WEBPACK_EXTERNAL_MODULE_node_path__.resolve(fullPath);
+        if (visitedDirs.has(resolvedFull)) continue;
+        let stat;
+        try {
+            stat = external_node_fs_.statSync(fullPath);
+        } catch  {
+            continue;
+        }
+        if (!!stat.isDirectory()) {
+            if (hasValidSkillMd(fullPath)) results.push(fullPath);
+            results.push(...findSkillDirsRecursive(fullPath, depth + 1, maxDepth, visitedDirs));
+        }
+    }
+    return results;
+}
+/**
+ * Discover all skills in a directory by scanning for SKILL.md files.
+ *
+ * Strategy:
+ * 1. Check root for SKILL.md
+ * 2. Search priority directories (skills/, .agents/skills/, .cursor/skills/, etc.)
+ * 3. Fall back to recursive search (max depth 5, skip node_modules, .git, dist, etc.)
+ *
+ * @param basePath - Root directory to search
+ * @returns List of parsed skills with their directory paths (absolute)
+ */ function discoverSkillsInDir(basePath) {
+    const resolvedBase = __WEBPACK_EXTERNAL_MODULE_node_path__.resolve(basePath);
+    const results = [];
+    const seenNames = new Set();
+    function addSkill(dirPath) {
+        const skill = parseSkillFromDir(dirPath);
+        if (skill && !seenNames.has(skill.name)) {
+            seenNames.add(skill.name);
+            results.push({
+                ...skill,
+                dirPath: __WEBPACK_EXTERNAL_MODULE_node_path__.resolve(dirPath)
+            });
+        }
+    }
+    if (hasValidSkillMd(resolvedBase)) addSkill(resolvedBase);
+    // Track visited directories to avoid redundant I/O during recursive scan
+    const visitedDirs = new Set();
+    for (const sub of PRIORITY_SKILL_DIRS){
+        const dir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(resolvedBase, sub);
+        if (!!external_node_fs_.existsSync(dir) && !!external_node_fs_.statSync(dir).isDirectory()) {
+            visitedDirs.add(__WEBPACK_EXTERNAL_MODULE_node_path__.resolve(dir));
+            try {
+                const entries = external_node_fs_.readdirSync(dir);
+                for (const entry of entries){
+                    const skillDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(dir, entry);
+                    try {
+                        if (external_node_fs_.statSync(skillDir).isDirectory() && hasValidSkillMd(skillDir)) {
+                            addSkill(skillDir);
+                            visitedDirs.add(__WEBPACK_EXTERNAL_MODULE_node_path__.resolve(skillDir));
+                        }
+                    } catch  {
+                    // Skip entries that can't be stat'd (race condition, permission, etc.)
+                    }
+                }
+            } catch  {
+            // Skip if unreadable
+            }
+        }
+    }
+    const recursiveDirs = findSkillDirsRecursive(resolvedBase, 0, MAX_DISCOVER_DEPTH, visitedDirs);
+    for (const skillDir of recursiveDirs)addSkill(skillDir);
+    return results;
+}
+/**
+ * Filter skills by name (case-insensitive exact match).
+ *
+ * Note: an empty `names` array returns an empty result (not all skills).
+ * Callers should check `names.length` before calling if "no filter = all" is desired.
+ *
+ * @param skills - List of discovered skills
+ * @param names - Skill names to match (e.g. from --skill pdf commit)
+ * @returns Skills whose name matches any of the given names
+ */ function filterSkillsByName(skills, names) {
+    const normalized = names.map((n)=>n.toLowerCase());
+    return skills.filter((skill)=>{
+        // Match against SKILL.md name field
+        if (normalized.includes(skill.name.toLowerCase())) return true;
+        // Also match against the directory name (basename of dirPath)
+        // Users naturally refer to skills by their directory name
+        const dirName = __WEBPACK_EXTERNAL_MODULE_node_path__.basename(skill.dirPath).toLowerCase();
+        return normalized.includes(dirName);
+    });
+}
+const claude_3p_installer_CLAUDE_COWORK_3P_AGENT = 'claude-cowork-3p';
+const CLAUDE_3P_SKILLS_ROOT_ENV = 'CLAUDE_3P_SKILLS_ROOT';
+const CLAUDE_3P_SKILLS_PLUGIN_BASE_ENV = 'CLAUDE_3P_SKILLS_PLUGIN_BASE';
+const DEFAULT_EXCLUDE_FILES = [
+    'README.md',
+    'metadata.json',
+    '.reskill-commit'
+];
+const EXCLUDE_PREFIX = '_';
+const MAX_MANIFEST_BACKUPS = 10;
+function exists(targetPath) {
+    return external_node_fs_.existsSync(targetPath);
+}
+function ensureDir(dirPath) {
+    if (!exists(dirPath)) external_node_fs_.mkdirSync(dirPath, {
+        recursive: true
+    });
+}
+function remove(targetPath) {
+    if (exists(targetPath)) external_node_fs_.rmSync(targetPath, {
+        recursive: true,
+        force: true
+    });
+}
+function isSafeSkillId(name) {
+    return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name) && '.' !== name && '..' !== name;
+}
+function 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);
+}
+function getSafeSkillPath(root, skillName) {
+    if (!isSafeSkillId(skillName)) throw new Error(`Skill name is not safe for Claude Cowork 3P: ${skillName}`);
+    const skillsDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(root, 'skills');
+    const skillPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(skillsDir, skillName);
+    if (!isPathSafe(skillsDir, skillPath)) throw new Error(`Skill path escapes Claude Cowork 3P skills directory: ${skillName}`);
+    return skillPath;
+}
+function isSkillsRoot(root) {
+    return exists(__WEBPACK_EXTERNAL_MODULE_node_path__.join(root, 'manifest.json')) && exists(__WEBPACK_EXTERNAL_MODULE_node_path__.join(root, 'skills'));
+}
+function copyDirectory(src, dest) {
+    ensureDir(dest);
+    for (const entry of external_node_fs_.readdirSync(src, {
+        withFileTypes: true
+    })){
+        if (DEFAULT_EXCLUDE_FILES.includes(entry.name) || entry.name.startsWith(EXCLUDE_PREFIX)) 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);
+        else if (entry.isFile()) external_node_fs_.copyFileSync(srcPath, destPath);
+    }
+}
+function getClaude3pSkillsPluginBase(options = {}) {
+    const env = options.env ?? process.env;
+    const explicitBase = env[CLAUDE_3P_SKILLS_PLUGIN_BASE_ENV];
+    if (explicitBase) return explicitBase;
+    const homeDir = options.homeDir ?? (0, __WEBPACK_EXTERNAL_MODULE_node_os__.homedir)();
+    const currentPlatform = options.platform ?? (0, __WEBPACK_EXTERNAL_MODULE_node_os__.platform)();
+    if ('darwin' === currentPlatform) return __WEBPACK_EXTERNAL_MODULE_node_path__.join(homeDir, 'Library', 'Application Support', 'Claude-3p', 'local-agent-mode-sessions', 'skills-plugin');
+    if ('win32' === currentPlatform) return __WEBPACK_EXTERNAL_MODULE_node_path__.join(env.APPDATA ?? __WEBPACK_EXTERNAL_MODULE_node_path__.join(homeDir, 'AppData', 'Roaming'), 'Claude-3p', 'local-agent-mode-sessions', 'skills-plugin');
+    return __WEBPACK_EXTERNAL_MODULE_node_path__.join(env.XDG_CONFIG_HOME ?? __WEBPACK_EXTERNAL_MODULE_node_path__.join(homeDir, '.config'), 'Claude-3p', 'local-agent-mode-sessions', 'skills-plugin');
+}
+function findClaude3pSkillsRoots(options = {}) {
+    const env = options.env ?? process.env;
+    const explicitRoot = env[CLAUDE_3P_SKILLS_ROOT_ENV];
+    if (explicitRoot) return isSkillsRoot(explicitRoot) ? [
+        explicitRoot
+    ] : [];
+    const base = getClaude3pSkillsPluginBase(options);
+    if (!exists(base)) return [];
+    const roots = [];
+    for (const organization of external_node_fs_.readdirSync(base, {
+        withFileTypes: true
+    })){
+        if (!organization.isDirectory()) continue;
+        const organizationPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(base, organization.name);
+        for (const account of external_node_fs_.readdirSync(organizationPath, {
+            withFileTypes: true
+        })){
+            if (!account.isDirectory()) continue;
+            const candidate = __WEBPACK_EXTERNAL_MODULE_node_path__.join(organizationPath, account.name);
+            if (isSkillsRoot(candidate)) roots.push(candidate);
+        }
+    }
+    return roots;
+}
+function claude_3p_installer_resolveClaude3pSkillsRoot(options = {}) {
+    const env = options.env ?? process.env;
+    const explicitRoot = env[CLAUDE_3P_SKILLS_ROOT_ENV];
+    if (explicitRoot) {
+        if (!isSkillsRoot(explicitRoot)) throw new Error(`${CLAUDE_3P_SKILLS_ROOT_ENV} must contain manifest.json and skills/: ${explicitRoot}`);
+        return explicitRoot;
+    }
+    const roots = findClaude3pSkillsRoots(options);
+    if (1 === roots.length) return roots[0];
+    const base = getClaude3pSkillsPluginBase(options);
+    if (0 === roots.length) throw new Error(`Claude Cowork 3P skills root not found under ${base}. Set ${CLAUDE_3P_SKILLS_ROOT_ENV} to the account directory containing manifest.json and skills/.`);
+    throw new Error(`Multiple Claude Cowork 3P skills roots found. Set ${CLAUDE_3P_SKILLS_ROOT_ENV} to one of:\n${roots.map((root)=>`  ${root}`).join('\n')}`);
+}
+function getClaude3pSkillPath(skillName) {
+    const root = claude_3p_installer_resolveClaude3pSkillsRoot();
+    return getSafeSkillPath(root, skillName);
+}
+function readManifest(manifestPath) {
+    const content = external_node_fs_.readFileSync(manifestPath, 'utf-8');
+    return JSON.parse(content);
+}
+function writeManifest(manifestPath, manifest) {
+    external_node_fs_.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf-8');
+}
+function createManifestBackup(manifestPath) {
+    const backupPath = `${manifestPath}.bak.${Date.now()}`;
+    external_node_fs_.copyFileSync(manifestPath, backupPath);
+    return backupPath;
+}
+function pruneManifestBackups(manifestPath) {
+    const manifestDir = __WEBPACK_EXTERNAL_MODULE_node_path__.dirname(manifestPath);
+    const backupPrefix = `${__WEBPACK_EXTERNAL_MODULE_node_path__.basename(manifestPath)}.bak.`;
+    const backups = external_node_fs_.readdirSync(manifestDir, {
+        withFileTypes: true
+    }).filter((entry)=>entry.isFile() && entry.name.startsWith(backupPrefix)).map((entry)=>({
+            name: entry.name,
+            path: __WEBPACK_EXTERNAL_MODULE_node_path__.join(manifestDir, entry.name),
+            mtimeMs: external_node_fs_.statSync(__WEBPACK_EXTERNAL_MODULE_node_path__.join(manifestDir, entry.name)).mtimeMs
+        })).sort((a, b)=>b.mtimeMs - a.mtimeMs);
+    for (const backup of backups.slice(MAX_MANIFEST_BACKUPS))remove(backup.path);
+}
+function updateManifest(manifestPath, skillId, name, description) {
+    const manifest = readManifest(manifestPath);
+    if (!Array.isArray(manifest.skills)) manifest.skills = [];
+    const entry = {
+        skillId,
+        name,
+        description,
+        creatorType: 'user',
+        syncManaged: false,
+        updatedAt: new Date().toISOString(),
+        enabled: true
+    };
+    const index = manifest.skills.findIndex((skill)=>skill.skillId === skillId || skill.name === name);
+    if (index >= 0) manifest.skills[index] = {
+        ...manifest.skills[index],
+        ...entry
+    };
+    else manifest.skills.push(entry);
+    manifest.lastUpdated = Date.now();
+    writeManifest(manifestPath, manifest);
+}
+function removeFromManifest(manifestPath, skillId) {
+    const manifest = readManifest(manifestPath);
+    if (!Array.isArray(manifest.skills)) return;
+    const before = manifest.skills.length;
+    manifest.skills = manifest.skills.filter((skill)=>skill.skillId !== skillId && skill.name !== skillId);
+    if (manifest.skills.length !== before) {
+        manifest.lastUpdated = Date.now();
+        writeManifest(manifestPath, manifest);
+    }
+}
+function installClaude3pSkill(sourcePath, fallbackName, _options = {}) {
+    const installMode = 'copy';
+    let manifestPath;
+    let manifestBackupPath;
+    let targetPath;
+    let tmpTarget;
+    let rollbackTarget;
+    try {
+        const metadata = parseSkillFromDir(sourcePath);
+        const skillId = metadata?.name ?? fallbackName;
+        const description = metadata?.description ?? '';
+        if (!isSafeSkillId(skillId)) return {
+            success: false,
+            path: '',
+            mode: installMode,
+            error: `SKILL.md name is not safe for Claude Cowork 3P: ${skillId}`
+        };
+        const root = claude_3p_installer_resolveClaude3pSkillsRoot();
+        manifestPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(root, 'manifest.json');
+        const skillsDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(root, 'skills');
+        targetPath = getSafeSkillPath(root, skillId);
+        tmpTarget = __WEBPACK_EXTERNAL_MODULE_node_path__.join(skillsDir, `.${skillId}.installing.${process.pid}`);
+        rollbackTarget = __WEBPACK_EXTERNAL_MODULE_node_path__.join(skillsDir, `.${skillId}.rollback.${process.pid}`);
+        if (!isPathSafe(skillsDir, tmpTarget)) throw new Error(`Temporary skill path escapes Claude Cowork 3P skills directory: ${skillId}`);
+        if (!isPathSafe(skillsDir, rollbackTarget)) throw new Error(`Rollback skill path escapes Claude Cowork 3P skills directory: ${skillId}`);
+        manifestBackupPath = createManifestBackup(manifestPath);
+        remove(tmpTarget);
+        remove(rollbackTarget);
+        copyDirectory(sourcePath, tmpTarget);
+        if (exists(targetPath)) external_node_fs_.renameSync(targetPath, rollbackTarget);
+        external_node_fs_.renameSync(tmpTarget, targetPath);
+        try {
+            updateManifest(manifestPath, skillId, skillId, description);
+        } catch (error) {
+            remove(targetPath);
+            if (rollbackTarget && exists(rollbackTarget)) external_node_fs_.renameSync(rollbackTarget, targetPath);
+            if (manifestBackupPath && manifestPath && exists(manifestBackupPath)) external_node_fs_.copyFileSync(manifestBackupPath, manifestPath);
+            throw error;
+        }
+        if (rollbackTarget) remove(rollbackTarget);
+        pruneManifestBackups(manifestPath);
+        return {
+            success: true,
+            path: targetPath,
+            mode: installMode
+        };
+    } catch (error) {
+        if (tmpTarget) remove(tmpTarget);
+        if (targetPath && rollbackTarget && exists(rollbackTarget) && !exists(targetPath)) try {
+            external_node_fs_.renameSync(rollbackTarget, targetPath);
+        } catch  {
+        // Ignore rollback errors while reporting the original installation failure.
+        }
+        if (manifestPath) try {
+            pruneManifestBackups(manifestPath);
+        } catch  {
+        // Ignore cleanup errors while reporting the original installation failure.
+        }
+        return {
+            success: false,
+            path: '',
+            mode: installMode,
+            error: error instanceof Error ? error.message : 'Unknown error'
+        };
+    }
+}
+function uninstallClaude3pSkill(skillName) {
+    const root = claude_3p_installer_resolveClaude3pSkillsRoot();
+    const targetPath = getSafeSkillPath(root, skillName);
+    const manifestPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(root, 'manifest.json');
+    const existed = exists(targetPath);
+    if (existed) remove(targetPath);
+    removeFromManifest(manifestPath, skillName);
+    return existed;
+}
+function listClaude3pSkills() {
+    const root = claude_3p_installer_resolveClaude3pSkillsRoot();
+    const skillsDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(root, 'skills');
+    if (!exists(skillsDir)) return [];
+    return external_node_fs_.readdirSync(skillsDir, {
+        withFileTypes: true
+    }).filter((entry)=>entry.isDirectory() && isSafeSkillId(entry.name)).map((entry)=>entry.name);
+}
 /**
  * Agent Registry - Multi-Agent configuration definitions
  *
- * Supports global and project-level installation for 17 coding agents
+ * Supports global and project-level installation for 18 coding agents
  * Reference: https://github.com/vercel-labs/add-skill
  */ const agent_registry_home = (0, __WEBPACK_EXTERNAL_MODULE_node_os__.homedir)();
 /**
@@ -186,6 +792,20 @@ var external_node_fs_ = __webpack_require__("node:fs");
         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'))
     },
+    [claude_3p_installer_CLAUDE_COWORK_3P_AGENT]: {
+        name: claude_3p_installer_CLAUDE_COWORK_3P_AGENT,
+        displayName: 'Claude Cowork 3P',
+        skillsDir: '.claude-3p/skills',
+        globalSkillsDir: getClaude3pSkillsPluginBase(),
+        detectInstalled: async ()=>{
+            try {
+                claude_3p_installer_resolveClaude3pSkillsRoot();
+                return true;
+            } catch  {
+                return false;
+            }
+        }
+    },
     clawdbot: {
         name: 'clawdbot',
         displayName: 'Clawdbot',
@@ -306,1151 +926,788 @@ var external_node_fs_ = __webpack_require__("node:fs");
  * File system utilities
  */ /**
  * Check if a file or directory exists
- */ function exists(filePath) {
+ */ function fs_exists(filePath) {
     return external_node_fs_.existsSync(filePath);
 }
 /**
  * Read JSON file
  */ function readJson(filePath) {
-    const content = external_node_fs_.readFileSync(filePath, 'utf-8');
-    return JSON.parse(content);
-}
-/**
- * Write JSON file
- */ function writeJson(filePath, data, indent = 2) {
-    const dir = __WEBPACK_EXTERNAL_MODULE_node_path__.dirname(filePath);
-    if (!exists(dir)) external_node_fs_.mkdirSync(dir, {
-        recursive: true
-    });
-    external_node_fs_.writeFileSync(filePath, `${JSON.stringify(data, null, indent)}\n`, 'utf-8');
-}
-/**
- * Create directory recursively
- */ function ensureDir(dirPath) {
-    if (!exists(dirPath)) external_node_fs_.mkdirSync(dirPath, {
-        recursive: true
-    });
-}
-/**
- * Remove file or directory
- */ function remove(targetPath) {
-    if (exists(targetPath)) external_node_fs_.rmSync(targetPath, {
-        recursive: true,
-        force: true
-    });
-}
-/**
- * Copy directory recursively
- *
- * @param src - Source directory
- * @param dest - Destination directory
- * @param options.exclude - Array of filenames to exclude
- * @param options.excludePrefix - Prefix for files to exclude (e.g., '_' to exclude _private.md)
- */ function copyDir(src, dest, options) {
-    const exclude = options?.exclude || [];
-    const excludePrefix = options?.excludePrefix || '_';
-    ensureDir(dest);
-    const entries = external_node_fs_.readdirSync(src, {
-        withFileTypes: true
-    });
-    for (const entry of entries){
-        // Skip files in exclude list or starting with excludePrefix
-        if (exclude.includes(entry.name) || entry.name.startsWith(excludePrefix)) 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()) copyDir(srcPath, destPath, options);
-        else external_node_fs_.copyFileSync(srcPath, destPath);
-    }
-}
-/**
- * List directory contents
- */ function listDir(dirPath) {
-    if (!exists(dirPath)) return [];
-    return external_node_fs_.readdirSync(dirPath);
-}
-/**
- * Check if path is a directory
- */ function isDirectory(targetPath) {
-    if (!exists(targetPath)) return false;
-    return external_node_fs_.statSync(targetPath).isDirectory();
-}
-/**
- * Check if path is a symbolic link
- */ function isSymlink(targetPath) {
-    if (!exists(targetPath)) return false;
-    return external_node_fs_.lstatSync(targetPath).isSymbolicLink();
-}
-/**
- * Get real path of symbolic link
- */ function getRealPath(linkPath) {
-    return external_node_fs_.realpathSync(linkPath);
-}
-/**
- * Get skills.json path for current project
- */ function getSkillsJsonPath(projectRoot) {
-    const root = projectRoot || process.cwd();
-    return __WEBPACK_EXTERNAL_MODULE_node_path__.join(root, 'skills.json');
-}
-/**
- * Get skills.lock path for current project
- */ function getSkillsLockPath(projectRoot) {
-    const root = projectRoot || process.cwd();
-    return __WEBPACK_EXTERNAL_MODULE_node_path__.join(root, 'skills.lock');
-}
-/**
- * Get global cache directory
- */ function getCacheDir() {
-    const home = process.env.HOME || process.env.USERPROFILE || '';
-    return process.env.RESKILL_CACHE_DIR || __WEBPACK_EXTERNAL_MODULE_node_path__.join(home, '.reskill-cache');
-}
-/**
- * Get home directory
- */ function getHomeDir() {
-    return process.env.HOME || process.env.USERPROFILE || '';
-}
-/**
- * Shorten path display (replace home directory with ~)
- */ 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 git_execAsync = (0, __WEBPACK_EXTERNAL_MODULE_node_util__.promisify)(__WEBPACK_EXTERNAL_MODULE_node_child_process__.exec);
-/**
- * Git utilities
- */ /**
- * SSH command with auto-accept for new host keys
- * Uses StrictHostKeyChecking=accept-new which:
- * - Automatically accepts keys for hosts not in known_hosts
- * - Still rejects connections if a known host's key has changed (security)
- */ const GIT_SSH_COMMAND = 'ssh -o StrictHostKeyChecking=accept-new -o BatchMode=yes';
-/**
- * Get environment variables for git commands that access remote repositories
- * Configures SSH to auto-accept new host keys and disables interactive prompts
- */ function getGitEnv() {
-    return {
-        ...process.env,
-        GIT_SSH_COMMAND,
-        // Disable interactive prompts for HTTPS as well
-        GIT_TERMINAL_PROMPT: '0'
-    };
-}
-/**
- * Custom error class for Git clone failures
- * Provides helpful tips for private repository authentication
- */ 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 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 {
-                // HTTPS or unknown
-                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;
-    }
-    /**
-   * Detect URL type from repository URL
-   */ static detectUrlType(url) {
-        if (url.startsWith('git@') || url.startsWith('ssh://')) return 'ssh';
-        if (url.startsWith('http://') || url.startsWith('https://')) return 'https';
-        return 'unknown';
-    }
-    /**
-   * Check if an error message indicates an authentication problem
-   */ static isAuthenticationError(message) {
-        const authPatterns = [
-            /permission denied/i,
-            /could not read from remote/i,
-            /authentication failed/i,
-            /fatal: repository.*not found/i,
-            /host key verification failed/i,
-            /access denied/i,
-            /unauthorized/i,
-            /403/,
-            /401/
-        ];
-        return authPatterns.some((pattern)=>pattern.test(message));
-    }
-}
-/**
- * Execute git command asynchronously
- */ async function git(args, cwd) {
-    const { stdout } = await git_execAsync(`git ${args.join(' ')}`, {
-        cwd,
-        encoding: 'utf-8',
-        env: getGitEnv()
+    const content = external_node_fs_.readFileSync(filePath, 'utf-8');
+    return JSON.parse(content);
+}
+/**
+ * Write JSON file
+ */ function writeJson(filePath, data, indent = 2) {
+    const dir = __WEBPACK_EXTERNAL_MODULE_node_path__.dirname(filePath);
+    if (!fs_exists(dir)) external_node_fs_.mkdirSync(dir, {
+        recursive: true
     });
-    return stdout.trim();
+    external_node_fs_.writeFileSync(filePath, `${JSON.stringify(data, null, indent)}\n`, 'utf-8');
 }
 /**
- * Get remote tags for a repository
- */ async function getRemoteTags(repoUrl) {
-    try {
-        const output = await git([
-            'ls-remote',
-            '--tags',
-            '--refs',
-            repoUrl
-        ]);
-        if (!output) return [];
-        const tags = [];
-        const lines = output.split('\n');
-        for (const line of lines){
-            const [commit, ref] = line.split('\t');
-            if (commit && ref) {
-                // Extract tag name from refs/tags/v1.0.0
-                const tagName = ref.replace('refs/tags/', '');
-                tags.push({
-                    name: tagName,
-                    commit
-                });
-            }
-        }
-        return tags;
-    } catch  {
-        return [];
-    }
+ * Create directory recursively
+ */ function fs_ensureDir(dirPath) {
+    if (!fs_exists(dirPath)) external_node_fs_.mkdirSync(dirPath, {
+        recursive: true
+    });
 }
 /**
- * Get latest tag from repository
- */ async function getLatestTag(repoUrl) {
-    const tags = await getRemoteTags(repoUrl);
-    if (0 === tags.length) return null;
-    // Sort by semver (simple version sort)
-    const sortedTags = tags.sort((a, b)=>{
-        const aVer = a.name.replace(/^v/, '');
-        const bVer = b.name.replace(/^v/, '');
-        return compareVersions(bVer, aVer);
+ * Remove file or directory
+ */ function fs_remove(targetPath) {
+    if (fs_exists(targetPath)) external_node_fs_.rmSync(targetPath, {
+        recursive: true,
+        force: true
     });
-    return sortedTags[0];
 }
 /**
- * Clone a repository with shallow clone
+ * Copy directory recursively
  *
- * @throws {GitCloneError} When clone fails, with helpful tips for authentication issues
- */ async function clone(repoUrl, destPath, options) {
-    const args = [
-        'clone'
-    ];
-    if (options?.depth) args.push('--depth', options.depth.toString());
-    if (options?.branch) args.push('--branch', options.branch);
-    args.push(repoUrl, destPath);
-    try {
-        await git(args);
-    } catch (error) {
-        throw new GitCloneError(repoUrl, error);
+ * @param src - Source directory
+ * @param dest - Destination directory
+ * @param options.exclude - Array of filenames to exclude
+ * @param options.excludePrefix - Prefix for files to exclude (e.g., '_' to exclude _private.md)
+ */ function copyDir(src, dest, options) {
+    const exclude = options?.exclude || [];
+    const excludePrefix = options?.excludePrefix || '_';
+    fs_ensureDir(dest);
+    const entries = external_node_fs_.readdirSync(src, {
+        withFileTypes: true
+    });
+    for (const entry of entries){
+        // Skip files in exclude list or starting with excludePrefix
+        if (exclude.includes(entry.name) || entry.name.startsWith(excludePrefix)) 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()) copyDir(srcPath, destPath, options);
+        else external_node_fs_.copyFileSync(srcPath, destPath);
     }
 }
 /**
- * Get current commit hash
- */ async function getCurrentCommit(cwd) {
-    return git([
-        'rev-parse',
-        'HEAD'
-    ], cwd);
+ * List directory contents
+ */ function listDir(dirPath) {
+    if (!fs_exists(dirPath)) return [];
+    return external_node_fs_.readdirSync(dirPath);
 }
 /**
- * Get default branch name
- */ async function getDefaultBranch(repoUrl) {
-    try {
-        const output = await git([
-            'ls-remote',
-            '--symref',
-            repoUrl,
-            'HEAD'
-        ]);
-        const match = output.match(/ref: refs\/heads\/(\S+)/);
-        return match ? match[1] : 'main';
-    } catch  {
-        return 'main';
-    }
+ * Check if path is a directory
+ */ function isDirectory(targetPath) {
+    if (!fs_exists(targetPath)) return false;
+    return external_node_fs_.statSync(targetPath).isDirectory();
 }
 /**
- * Simple version comparison (for sorting)
- */ function compareVersions(a, b) {
-    const aParts = a.split('.').map((p)=>parseInt(p, 10) || 0);
-    const bParts = b.split('.').map((p)=>parseInt(p, 10) || 0);
-    const maxLength = Math.max(aParts.length, bParts.length);
-    for(let i = 0; i < maxLength; i++){
-        const aPart = aParts[i] || 0;
-        const bPart = bParts[i] || 0;
-        if (aPart > bPart) return 1;
-        if (aPart < bPart) return -1;
-    }
-    return 0;
+ * Check if path is a symbolic link
+ */ function isSymlink(targetPath) {
+    if (!fs_exists(targetPath)) return false;
+    return external_node_fs_.lstatSync(targetPath).isSymbolicLink();
 }
 /**
- * Check if a source string is a complete Git URL (SSH, HTTPS, git://, or file://)
- *
- * Supported formats:
- * - SSH: git@github.com:user/repo.git
- * - HTTPS: https://github.com/user/repo.git
- * - Git protocol: git://github.com/user/repo.git
- * - File protocol: file:///path/to/repo (for local testing)
- * - URLs ending with .git
- */ function isGitUrl(source) {
-    return source.startsWith('git@') || source.startsWith('git://') || source.startsWith('http://') || source.startsWith('https://') || source.startsWith('file://') || source.endsWith('.git');
+ * Get real path of symbolic link
+ */ function getRealPath(linkPath) {
+    return external_node_fs_.realpathSync(linkPath);
 }
 /**
- * Parse a Git URL and extract host, owner, and repo information
- *
- * Supports:
- * - SSH: git@github.com:user/repo.git
- * - HTTPS: https://github.com/user/repo.git
- * - Git protocol: git://github.com/user/repo.git
- *
- * Note: GitHub/GitLab web URLs (with /tree/, /blob/, etc.) are handled
- * at a higher level in GitResolver.parseGitUrlRef() before calling this function.
- *
- * @param url The Git URL to parse
- * @returns Parsed URL information or null if parsing fails
- */ function parseGitUrl(url) {
-    // Remove trailing .git if present
-    const cleanUrl = url.replace(/\.git$/, '');
-    // SSH format: git@github.com:user/repo
-    const sshMatch = cleanUrl.match(/^git@([^:]+):(.+)$/);
-    if (sshMatch) {
-        const [, host, path] = sshMatch;
-        const parts = path.split('/');
-        if (parts.length >= 2) {
-            // Handle nested paths like org/sub/repo
-            const owner = parts.slice(0, -1).join('/');
-            const repo = parts[parts.length - 1];
-            return {
-                host,
-                owner,
-                repo,
-                url,
-                type: 'ssh'
-            };
-        }
-    }
-    // HTTPS/Git protocol format: https://github.com/user/repo or git://github.com/user/repo
-    const httpMatch = cleanUrl.match(/^(https?|git):\/\/([^/]+)\/(.+)$/);
-    if (httpMatch) {
-        const [, protocol, host, path] = httpMatch;
-        const parts = path.split('/');
-        if (parts.length >= 2) {
-            const owner = parts.slice(0, -1).join('/');
-            const repo = parts[parts.length - 1];
-            return {
-                host,
-                owner,
-                repo,
-                url,
-                type: 'git' === protocol ? 'git' : 'https'
-            };
-        }
-    }
-    // File protocol format: file:///path/to/repo
-    // Used for local testing and development
-    const fileMatch = cleanUrl.match(/^file:\/\/(.+)$/);
-    if (fileMatch) {
-        const [, filePath] = fileMatch;
-        const parts = filePath.split('/').filter(Boolean);
-        if (parts.length >= 1) {
-            // Use 'local' as host, path components as owner/repo
-            const repo = parts[parts.length - 1];
-            const owner = parts.length > 1 ? parts[parts.length - 2] : 'local';
-            return {
-                host: 'local',
-                owner,
-                repo,
-                url,
-                type: 'file'
-            };
-        }
-    }
-    return null;
+ * Get skills.json path for current project
+ */ function getSkillsJsonPath(projectRoot) {
+    const root = projectRoot || process.cwd();
+    return __WEBPACK_EXTERNAL_MODULE_node_path__.join(root, 'skills.json');
 }
 /**
- * Registry-Scope Mapping Utilities
- *
- * Maps registry URLs to their corresponding scopes.
- * Currently hardcoded; TODO: fetch from /api/registry/info in the future.
- */ /**
- * Public Registry URL
- * Used for installing skills without a scope
- */ const PUBLIC_REGISTRY = 'https://reskill.info/';
-/**
- * Hardcoded registry to scope mapping
- * TODO: Replace with dynamic fetching from /api/registry/info
- */ const REGISTRY_SCOPE_MAP = {
-    // rush-app (private registry, new)
-    'https://rush-test.zhenguanyu.com': '@kanyun-test',
-    'https://rush.zhenguanyu.com': '@kanyun',
-    // reskill-app (private registry, legacy)
-    'https://reskill-test.zhenguanyu.com': '@kanyun-test',
-    // Local development
-    'http://localhost:3000': '@kanyun-test'
-};
+ * Get skills.lock path for current project
+ */ function getSkillsLockPath(projectRoot) {
+    const root = projectRoot || process.cwd();
+    return __WEBPACK_EXTERNAL_MODULE_node_path__.join(root, 'skills.lock');
+}
 /**
- * Get the scope for a given registry URL
- *
- * @param registry - Registry URL
- * @returns Scope string (e.g., "@kanyun") or null if not found
- *
- * @example
- * getScopeForRegistry('https://rush-test.zhenguanyu.com') // '@kanyun'
- * getScopeForRegistry('https://unknown.com') // null
- */ function getScopeForRegistry(registry) {
-    if (!registry) return null;
-    // Try exact match first
-    if (REGISTRY_SCOPE_MAP[registry]) return REGISTRY_SCOPE_MAP[registry];
-    // Try with/without trailing slash
-    const normalized = registry.endsWith('/') ? registry.slice(0, -1) : `${registry}/`;
-    return REGISTRY_SCOPE_MAP[normalized] || null;
+ * Get global cache directory
+ */ function getCacheDir() {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    return process.env.RESKILL_CACHE_DIR || __WEBPACK_EXTERNAL_MODULE_node_path__.join(home, '.reskill-cache');
 }
 /**
- * Get the registry URL for a given scope (reverse lookup)
- *
- * @param scope - Scope string (with or without @ prefix), e.g., "@kanyun" or "kanyun"
- * @param customRegistries - Optional custom scope-to-registry mapping (from skills.json)
- * @returns Registry URL (with trailing slash) or null if not found
- *
- * @example
- * getRegistryForScope('@kanyun') // 'https://rush-test.zhenguanyu.com/'
- * getRegistryForScope('kanyun') // 'https://rush-test.zhenguanyu.com/'
- * getRegistryForScope('@unknown') // null
- * getRegistryForScope('@mycompany', { '@mycompany': 'https://my.registry.com/' }) // 'https://my.registry.com/'
- */ function getRegistryForScope(scope, customRegistries) {
-    if (!scope) return null;
-    // Normalize scope: ensure @ prefix
-    const normalizedScope = scope.startsWith('@') ? scope : `@${scope}`;
-    // 1. First check custom scopeRegistries (from skills.json)
-    if (customRegistries?.[normalizedScope]) {
-        const url = customRegistries[normalizedScope];
-        // Normalize trailing slash
-        return url.endsWith('/') ? url : `${url}/`;
-    }
-    // 2. Fall back to hardcoded defaults
-    for (const [registry, registryScope] of Object.entries(REGISTRY_SCOPE_MAP))if (registryScope === normalizedScope) // Return URL with trailing slash (normalized format)
-    return registry.endsWith('/') ? registry : `${registry}/`;
-    return null;
+ * Get home directory
+ */ function getHomeDir() {
+    return process.env.HOME || process.env.USERPROFILE || '';
 }
 /**
- * Get the registry URL for a given scope
- *
- * - With scope → lookup private Registry (throws if not found)
- * - Without scope (null/undefined/'') → returns public Registry
- *
- * @param scope - Scope string (with or without @ prefix), null, undefined, or empty string
- * @param customRegistries - Optional custom scope-to-registry mapping (from skills.json)
- * @returns Registry URL (with trailing slash)
- * @throws Error if scope is provided but not found in the registry map
- *
- * @example
- * getRegistryUrl('@kanyun') // 'https://rush-test.zhenguanyu.com/'
- * getRegistryUrl('kanyun') // 'https://rush-test.zhenguanyu.com/'
- * getRegistryUrl(null) // 'https://reskill.info/'
- * getRegistryUrl('') // 'https://reskill.info/'
- * getRegistryUrl('@unknown') // throws Error
- * getRegistryUrl('@mycompany', { '@mycompany': 'https://my.registry.com/' }) // 'https://my.registry.com/'
- */ function getRegistryUrl(scope, customRegistries) {
-    // No scope → return public Registry
-    if (!scope) return PUBLIC_REGISTRY;
-    // With scope → lookup private Registry
-    const registry = getRegistryForScope(scope, customRegistries);
-    if (!registry) {
-        // Normalize scope for error message
-        const normalizedScope = scope.startsWith('@') ? scope : `@${scope}`;
-        throw new Error(`Unknown scope ${normalizedScope}. No registry configured for this scope.`);
-    }
-    return registry;
+ * Shorten path display (replace home directory with ~)
+ */ 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 git_execAsync = (0, __WEBPACK_EXTERNAL_MODULE_node_util__.promisify)(__WEBPACK_EXTERNAL_MODULE_node_child_process__.exec);
 /**
- * Parse a skill name into its components
- *
- * @param skillName - Full or short skill name
- * @returns Parsed skill name with scope and name
- *
- * @example
- * parseSkillName('@kanyun/planning-with-files')
- * // { scope: '@kanyun', name: 'planning-with-files', fullName: '@kanyun/planning-with-files' }
- *
- * parseSkillName('planning-with-files')
- * // { scope: null, name: 'planning-with-files', fullName: 'planning-with-files' }
- */ function parseSkillName(skillName) {
-    // Match @scope/name pattern
-    const match = skillName.match(/^(@[^/]+)\/(.+)$/);
-    if (match) return {
-        scope: match[1],
-        name: match[2],
-        fullName: skillName
-    };
+ * Git utilities
+ */ /**
+ * SSH command with auto-accept for new host keys
+ * Uses StrictHostKeyChecking=accept-new which:
+ * - Automatically accepts keys for hosts not in known_hosts
+ * - Still rejects connections if a known host's key has changed (security)
+ */ const GIT_SSH_COMMAND = 'ssh -o StrictHostKeyChecking=accept-new -o BatchMode=yes';
+/**
+ * Get environment variables for git commands that access remote repositories
+ * Configures SSH to auto-accept new host keys and disables interactive prompts
+ */ function getGitEnv() {
     return {
-        scope: null,
-        name: skillName,
-        fullName: skillName
+        ...process.env,
+        GIT_SSH_COMMAND,
+        // Disable interactive prompts for HTTPS as well
+        GIT_TERMINAL_PROMPT: '0'
     };
 }
 /**
- * Build full skill name from scope and name
- *
- * @param scope - Scope (with or without @ prefix), or null
- * @param name - Short skill name
- * @returns Full skill name (e.g., "@kanyun/planning-with-files")
- *
- * @example
- * buildFullSkillName('@kanyun', 'planning-with-files') // '@kanyun/planning-with-files'
- * buildFullSkillName('kanyun', 'my-skill') // '@kanyun/my-skill'
- * buildFullSkillName(null, 'my-skill') // 'my-skill'
- */ function buildFullSkillName(scope, name) {
-    if (!scope) return name;
-    // Ensure scope starts with @
-    const normalizedScope = scope.startsWith('@') ? scope : `@${scope}`;
-    return `${normalizedScope}/${name}`;
+ * Custom error class for Git clone failures
+ * Provides helpful tips for private repository authentication
+ */ 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 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 {
+                // HTTPS or unknown
+                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;
+    }
+    /**
+   * Detect URL type from repository URL
+   */ static detectUrlType(url) {
+        if (url.startsWith('git@') || url.startsWith('ssh://')) return 'ssh';
+        if (url.startsWith('http://') || url.startsWith('https://')) return 'https';
+        return 'unknown';
+    }
+    /**
+   * Check if an error message indicates an authentication problem
+   */ static isAuthenticationError(message) {
+        const authPatterns = [
+            /permission denied/i,
+            /could not read from remote/i,
+            /authentication failed/i,
+            /fatal: repository.*not found/i,
+            /host key verification failed/i,
+            /access denied/i,
+            /unauthorized/i,
+            /403/,
+            /401/
+        ];
+        return authPatterns.some((pattern)=>pattern.test(message));
+    }
 }
 /**
- * Get short name from a skill name (removes scope if present)
- *
- * @param skillName - Full or short skill name
- * @returns Short name without scope
- *
- * @example
- * getShortName('@kanyun/planning-with-files') // 'planning-with-files'
- * getShortName('planning-with-files') // 'planning-with-files'
- */ function getShortName(skillName) {
-    return parseSkillName(skillName).name;
+ * Execute git command asynchronously
+ */ async function git(args, cwd) {
+    const { stdout } = await git_execAsync(`git ${args.join(' ')}`, {
+        cwd,
+        encoding: 'utf-8',
+        env: getGitEnv()
+    });
+    return stdout.trim();
 }
 /**
- * Parse a skill identifier into its components (with version support)
- *
- * Supports both private registry (with @scope) and public registry (without scope) formats.
- *
- * @param identifier - Skill identifier string
- * @returns Parsed skill identifier with scope, name, version, and fullName
- * @throws Error if identifier is invalid
- *
- * @example
- * // Private registry
- * parseSkillIdentifier('@kanyun/planning-with-files')
- * // { scope: '@kanyun', name: 'planning-with-files', version: undefined, fullName: '@kanyun/planning-with-files' }
- *
- * parseSkillIdentifier('@kanyun/skill@2.4.5')
- * // { scope: '@kanyun', name: 'skill', version: '2.4.5', fullName: '@kanyun/skill' }
- *
- * // Public registry
- * parseSkillIdentifier('planning-with-files')
- * // { scope: null, name: 'planning-with-files', version: undefined, fullName: 'planning-with-files' }
- *
- * parseSkillIdentifier('skill@latest')
- * // { scope: null, name: 'skill', version: 'latest', fullName: 'skill' }
- */ function parseSkillIdentifier(identifier) {
-    const trimmed = identifier.trim();
-    // Empty string or whitespace only
-    if (!trimmed) throw new Error('Invalid skill identifier: empty string');
-    // Starting with @@ is invalid
-    if (trimmed.startsWith('@@')) throw new Error('Invalid skill identifier: invalid scope format');
-    // Bare @ is invalid
-    if ('@' === trimmed) throw new Error('Invalid skill identifier: missing scope and name');
-    // Scoped format: @scope/name[@version]
-    if (trimmed.startsWith('@')) {
-        // Regex: @scope/name[@version]
-        // scope: starts with @, followed by alphanumeric, hyphens, underscores
-        // name: alphanumeric, hyphens, underscores
-        // version: optional, @ followed by any non-empty string
-        const scopedMatch = trimmed.match(/^(@[\w-]+)\/([\w-]+)(?:@(.+))?$/);
-        if (!scopedMatch) throw new Error(`Invalid skill identifier: ${identifier}`);
-        const [, scope, name, version] = scopedMatch;
-        return {
-            scope,
-            name,
-            version: version || void 0,
-            fullName: `${scope}/${name}`
-        };
+ * Get remote tags for a repository
+ */ async function getRemoteTags(repoUrl) {
+    try {
+        const output = await git([
+            'ls-remote',
+            '--tags',
+            '--refs',
+            repoUrl
+        ]);
+        if (!output) return [];
+        const tags = [];
+        const lines = output.split('\n');
+        for (const line of lines){
+            const [commit, ref] = line.split('\t');
+            if (commit && ref) {
+                // Extract tag name from refs/tags/v1.0.0
+                const tagName = ref.replace('refs/tags/', '');
+                tags.push({
+                    name: tagName,
+                    commit
+                });
+            }
+        }
+        return tags;
+    } catch  {
+        return [];
     }
-    // Unscoped format: name[@version] (public registry)
-    // name must not contain / (otherwise it might be a git shorthand)
-    const unscopedMatch = trimmed.match(/^([\w-]+)(?:@(.+))?$/);
-    if (!unscopedMatch) throw new Error(`Invalid skill identifier: ${identifier}`);
-    const [, name, version] = unscopedMatch;
-    return {
-        scope: null,
-        name,
-        version: version || void 0,
-        fullName: name
-    };
 }
 /**
- * HTTP utilities for downloading and extracting skill archives
- */ /**
- * Custom error class for HTTP download failures
- */ class HttpDownloadError extends Error {
-    url;
-    statusCode;
-    originalError;
-    constructor(url, message, statusCode, originalError){
-        super(message);
-        this.name = 'HttpDownloadError';
-        this.url = url;
-        this.statusCode = statusCode;
-        this.originalError = originalError;
-    }
+ * Get latest tag from repository
+ */ async function getLatestTag(repoUrl) {
+    const tags = await getRemoteTags(repoUrl);
+    if (0 === tags.length) return null;
+    // Sort by semver (simple version sort)
+    const sortedTags = tags.sort((a, b)=>{
+        const aVer = a.name.replace(/^v/, '');
+        const bVer = b.name.replace(/^v/, '');
+        return compareVersions(bVer, aVer);
+    });
+    return sortedTags[0];
 }
 /**
- * Download a file from HTTP/HTTPS URL
+ * Clone a repository with shallow clone
  *
- * @param url - URL to download from
- * @param destPath - Destination file path
- * @param options - Download options
- */ async function downloadFile(url, destPath, options = {}) {
-    const { timeout = 60000, headers = {} } = options;
-    // Ensure destination directory exists
-    ensureDir(__WEBPACK_EXTERNAL_MODULE_node_path__.dirname(destPath));
+ * @throws {GitCloneError} When clone fails, with helpful tips for authentication issues
+ */ async function clone(repoUrl, destPath, options) {
+    const args = [
+        'clone'
+    ];
+    if (options?.depth) args.push('--depth', options.depth.toString());
+    if (options?.branch) args.push('--branch', options.branch);
+    args.push(repoUrl, destPath);
     try {
-        // Use native fetch for HTTP/HTTPS
-        const controller = new AbortController();
-        const timeoutId = setTimeout(()=>controller.abort(), timeout);
-        const response = await fetch(url, {
-            signal: controller.signal,
-            headers: {
-                'User-Agent': 'reskill/1.0',
-                ...headers
-            }
-        });
-        clearTimeout(timeoutId);
-        if (!response.ok) throw new HttpDownloadError(url, `HTTP ${response.status}: ${response.statusText}`, response.status);
-        // Stream response to file
-        const fileStream = external_node_fs_.createWriteStream(destPath);
-        const body = response.body;
-        if (!body) throw new HttpDownloadError(url, 'Response body is empty');
-        // Convert Web ReadableStream to Node.js Readable
-        const { Readable } = await import("node:stream");
-        const nodeStream = Readable.fromWeb(body);
-        await (0, __WEBPACK_EXTERNAL_MODULE_node_stream_promises__.pipeline)(nodeStream, fileStream);
+        await git(args);
     } catch (error) {
-        // Clean up partial download
-        if (external_node_fs_.existsSync(destPath)) external_node_fs_.unlinkSync(destPath);
-        if (error instanceof HttpDownloadError) throw error;
-        const err = error;
-        if ('AbortError' === err.name) throw new HttpDownloadError(url, `Download timeout after ${timeout}ms`);
-        throw new HttpDownloadError(url, `Download failed: ${err.message}`, void 0, err);
+        throw new GitCloneError(repoUrl, error);
     }
 }
 /**
- * Extract an archive to a directory
- *
- * @param archivePath - Path to the archive file
- * @param destDir - Destination directory
- * @param format - Archive format (auto-detected from extension if not provided)
- */ async function extractArchive(archivePath, destDir, format) {
-    // Auto-detect format from extension
-    const detectedFormat = format || detectArchiveFormat(archivePath);
-    if (!detectedFormat) throw new Error(`Unable to detect archive format for: ${archivePath}`);
-    // Ensure destination directory exists
-    ensureDir(destDir);
-    switch(detectedFormat){
-        case 'tar.gz':
-        case 'tgz':
-        case 'tar':
-            await extractTar(archivePath, destDir, 'tar.gz' === detectedFormat || 'tgz' === detectedFormat);
-            break;
-        case 'zip':
-            await extractZip(archivePath, destDir);
-            break;
-        default:
-            throw new Error(`Unsupported archive format: ${detectedFormat}`);
-    }
+ * Get current commit hash
+ */ async function getCurrentCommit(cwd) {
+    return git([
+        'rev-parse',
+        'HEAD'
+    ], cwd);
 }
 /**
- * Extract tar archive using native tar command
- */ async function extractTar(archivePath, destDir, gzipped) {
-    const { exec } = await import("node:child_process");
-    const { promisify } = await import("node:util");
-    const execAsync = promisify(exec);
-    const flags = gzipped ? '-xzf' : '-xf';
+ * Get default branch name
+ */ async function getDefaultBranch(repoUrl) {
     try {
-        // Extract to a temp directory first to handle single-folder archives
-        const tempExtractDir = `${destDir}.extract-temp`;
-        ensureDir(tempExtractDir);
-        await execAsync(`tar ${flags} "${archivePath}" -C "${tempExtractDir}"`, {
-            encoding: 'utf-8'
-        });
-        // Check if archive contains a single root directory
-        const extractedItems = external_node_fs_.readdirSync(tempExtractDir);
-        if (1 === extractedItems.length) {
-            const singleItem = __WEBPACK_EXTERNAL_MODULE_node_path__.join(tempExtractDir, extractedItems[0]);
-            if (external_node_fs_.statSync(singleItem).isDirectory()) {
-                // Move contents of single directory to destination
-                const contents = external_node_fs_.readdirSync(singleItem);
-                for (const item of contents){
-                    const src = __WEBPACK_EXTERNAL_MODULE_node_path__.join(singleItem, item);
-                    const dest = __WEBPACK_EXTERNAL_MODULE_node_path__.join(destDir, item);
-                    external_node_fs_.renameSync(src, dest);
-                }
-                remove(tempExtractDir);
-                return;
-            }
-        }
-        // Move all items to destination
-        for (const item of extractedItems){
-            const src = __WEBPACK_EXTERNAL_MODULE_node_path__.join(tempExtractDir, item);
-            const dest = __WEBPACK_EXTERNAL_MODULE_node_path__.join(destDir, item);
-            external_node_fs_.renameSync(src, dest);
-        }
-        remove(tempExtractDir);
-    } catch (error) {
-        throw new Error(`Failed to extract tar archive: ${error.message}`);
+        const output = await git([
+            'ls-remote',
+            '--symref',
+            repoUrl,
+            'HEAD'
+        ]);
+        const match = output.match(/ref: refs\/heads\/(\S+)/);
+        return match ? match[1] : 'main';
+    } catch  {
+        return 'main';
     }
 }
 /**
- * Extract zip archive using native unzip command or Node.js
- */ async function extractZip(archivePath, destDir) {
-    const { exec } = await import("node:child_process");
-    const { promisify } = await import("node:util");
-    const execAsync = promisify(exec);
-    try {
-        // Extract to a temp directory first
-        const tempExtractDir = `${destDir}.extract-temp`;
-        ensureDir(tempExtractDir);
-        // Try using unzip command (available on most systems)
-        await execAsync(`unzip -q "${archivePath}" -d "${tempExtractDir}"`, {
-            encoding: 'utf-8'
-        });
-        // Check if archive contains a single root directory
-        const extractedItems = external_node_fs_.readdirSync(tempExtractDir);
-        if (1 === extractedItems.length) {
-            const singleItem = __WEBPACK_EXTERNAL_MODULE_node_path__.join(tempExtractDir, extractedItems[0]);
-            if (external_node_fs_.statSync(singleItem).isDirectory()) {
-                // Move contents of single directory to destination
-                const contents = external_node_fs_.readdirSync(singleItem);
-                for (const item of contents){
-                    const src = __WEBPACK_EXTERNAL_MODULE_node_path__.join(singleItem, item);
-                    const dest = __WEBPACK_EXTERNAL_MODULE_node_path__.join(destDir, item);
-                    external_node_fs_.renameSync(src, dest);
-                }
-                remove(tempExtractDir);
-                return;
-            }
+ * Simple version comparison (for sorting)
+ */ function compareVersions(a, b) {
+    const aParts = a.split('.').map((p)=>parseInt(p, 10) || 0);
+    const bParts = b.split('.').map((p)=>parseInt(p, 10) || 0);
+    const maxLength = Math.max(aParts.length, bParts.length);
+    for(let i = 0; i < maxLength; i++){
+        const aPart = aParts[i] || 0;
+        const bPart = bParts[i] || 0;
+        if (aPart > bPart) return 1;
+        if (aPart < bPart) return -1;
+    }
+    return 0;
+}
+/**
+ * Check if a source string is a complete Git URL (SSH, HTTPS, git://, or file://)
+ *
+ * Supported formats:
+ * - SSH: git@github.com:user/repo.git
+ * - HTTPS: https://github.com/user/repo.git
+ * - Git protocol: git://github.com/user/repo.git
+ * - File protocol: file:///path/to/repo (for local testing)
+ * - URLs ending with .git
+ */ function isGitUrl(source) {
+    return source.startsWith('git@') || source.startsWith('git://') || source.startsWith('http://') || source.startsWith('https://') || source.startsWith('file://') || source.endsWith('.git');
+}
+/**
+ * Parse a Git URL and extract host, owner, and repo information
+ *
+ * Supports:
+ * - SSH: git@github.com:user/repo.git
+ * - HTTPS: https://github.com/user/repo.git
+ * - Git protocol: git://github.com/user/repo.git
+ *
+ * Note: GitHub/GitLab web URLs (with /tree/, /blob/, etc.) are handled
+ * at a higher level in GitResolver.parseGitUrlRef() before calling this function.
+ *
+ * @param url The Git URL to parse
+ * @returns Parsed URL information or null if parsing fails
+ */ function parseGitUrl(url) {
+    // Remove trailing .git if present
+    const cleanUrl = url.replace(/\.git$/, '');
+    // SSH format: git@github.com:user/repo
+    const sshMatch = cleanUrl.match(/^git@([^:]+):(.+)$/);
+    if (sshMatch) {
+        const [, host, path] = sshMatch;
+        const parts = path.split('/');
+        if (parts.length >= 2) {
+            // Handle nested paths like org/sub/repo
+            const owner = parts.slice(0, -1).join('/');
+            const repo = parts[parts.length - 1];
+            return {
+                host,
+                owner,
+                repo,
+                url,
+                type: 'ssh'
+            };
         }
-        // Move all items to destination
-        for (const item of extractedItems){
-            const src = __WEBPACK_EXTERNAL_MODULE_node_path__.join(tempExtractDir, item);
-            const dest = __WEBPACK_EXTERNAL_MODULE_node_path__.join(destDir, item);
-            external_node_fs_.renameSync(src, dest);
+    }
+    // HTTPS/Git protocol format: https://github.com/user/repo or git://github.com/user/repo
+    const httpMatch = cleanUrl.match(/^(https?|git):\/\/([^/]+)\/(.+)$/);
+    if (httpMatch) {
+        const [, protocol, host, path] = httpMatch;
+        const parts = path.split('/');
+        if (parts.length >= 2) {
+            const owner = parts.slice(0, -1).join('/');
+            const repo = parts[parts.length - 1];
+            return {
+                host,
+                owner,
+                repo,
+                url,
+                type: 'git' === protocol ? 'git' : 'https'
+            };
+        }
+    }
+    // File protocol format: file:///path/to/repo
+    // Used for local testing and development
+    const fileMatch = cleanUrl.match(/^file:\/\/(.+)$/);
+    if (fileMatch) {
+        const [, filePath] = fileMatch;
+        const parts = filePath.split('/').filter(Boolean);
+        if (parts.length >= 1) {
+            // Use 'local' as host, path components as owner/repo
+            const repo = parts[parts.length - 1];
+            const owner = parts.length > 1 ? parts[parts.length - 2] : 'local';
+            return {
+                host: 'local',
+                owner,
+                repo,
+                url,
+                type: 'file'
+            };
         }
-        remove(tempExtractDir);
-    } catch (error) {
-        throw new Error(`Failed to extract zip archive: ${error.message}`);
     }
+    return null;
 }
 /**
- * Detect archive format from file path
- */ function detectArchiveFormat(filePath) {
-    const lower = filePath.toLowerCase();
-    if (lower.endsWith('.tar.gz')) return 'tar.gz';
-    if (lower.endsWith('.tgz')) return 'tgz';
-    if (lower.endsWith('.zip')) return 'zip';
-    if (lower.endsWith('.tar')) return 'tar';
+ * Registry-Scope Mapping Utilities
+ *
+ * Maps registry URLs to their corresponding scopes.
+ * Currently hardcoded; TODO: fetch from /api/registry/info in the future.
+ */ /**
+ * Public Registry URL
+ * Used for installing skills without a scope
+ */ const PUBLIC_REGISTRY = 'https://reskill.info/';
+/**
+ * Hardcoded registry to scope mapping
+ * TODO: Replace with dynamic fetching from /api/registry/info
+ */ const REGISTRY_SCOPE_MAP = {
+    // rush-app (private registry, new)
+    'https://rush-test.zhenguanyu.com': '@kanyun-test',
+    'https://rush.zhenguanyu.com': '@kanyun',
+    // reskill-app (private registry, legacy)
+    'https://reskill-test.zhenguanyu.com': '@kanyun-test',
+    // Local development
+    'http://localhost:3000': '@kanyun-test'
+};
+/**
+ * Get the scope for a given registry URL
+ *
+ * @param registry - Registry URL
+ * @returns Scope string (e.g., "@kanyun") or null if not found
+ *
+ * @example
+ * getScopeForRegistry('https://rush-test.zhenguanyu.com') // '@kanyun'
+ * getScopeForRegistry('https://unknown.com') // null
+ */ function getScopeForRegistry(registry) {
+    if (!registry) return null;
+    // Try exact match first
+    if (REGISTRY_SCOPE_MAP[registry]) return REGISTRY_SCOPE_MAP[registry];
+    // Try with/without trailing slash
+    const normalized = registry.endsWith('/') ? registry.slice(0, -1) : `${registry}/`;
+    return REGISTRY_SCOPE_MAP[normalized] || null;
 }
 /**
- * Download and extract an archive in one operation
+ * Get the registry URL for a given scope (reverse lookup)
  *
- * @param url - URL to download from
- * @param destDir - Destination directory for extracted contents
- * @param options - Download options
- * @returns Path to extracted contents
- */ async function downloadAndExtract(url, destDir, options = {}) {
-    // Determine archive filename from URL
-    const urlObj = new URL(url);
-    const filename = __WEBPACK_EXTERNAL_MODULE_node_path__.basename(urlObj.pathname);
-    // Detect format from original filename before adding .download suffix
-    const format = detectArchiveFormat(filename);
-    if (!format) throw new Error(`Unable to detect archive format from URL: ${url}`);
-    const tempArchive = __WEBPACK_EXTERNAL_MODULE_node_path__.join(destDir, `../${filename}.download`);
-    try {
-        // Download archive
-        await downloadFile(url, tempArchive, options);
-        // Extract archive with explicit format
-        await extractArchive(tempArchive, destDir, format);
-        return destDir;
-    } finally{
-        // Clean up temp archive
-        if (external_node_fs_.existsSync(tempArchive)) external_node_fs_.unlinkSync(tempArchive);
+ * @param scope - Scope string (with or without @ prefix), e.g., "@kanyun" or "kanyun"
+ * @param customRegistries - Optional custom scope-to-registry mapping (from skills.json)
+ * @returns Registry URL (with trailing slash) or null if not found
+ *
+ * @example
+ * getRegistryForScope('@kanyun') // 'https://rush-test.zhenguanyu.com/'
+ * getRegistryForScope('kanyun') // 'https://rush-test.zhenguanyu.com/'
+ * getRegistryForScope('@unknown') // null
+ * getRegistryForScope('@mycompany', { '@mycompany': 'https://my.registry.com/' }) // 'https://my.registry.com/'
+ */ function getRegistryForScope(scope, customRegistries) {
+    if (!scope) return null;
+    // Normalize scope: ensure @ prefix
+    const normalizedScope = scope.startsWith('@') ? scope : `@${scope}`;
+    // 1. First check custom scopeRegistries (from skills.json)
+    if (customRegistries?.[normalizedScope]) {
+        const url = customRegistries[normalizedScope];
+        // Normalize trailing slash
+        return url.endsWith('/') ? url : `${url}/`;
     }
+    // 2. Fall back to hardcoded defaults
+    for (const [registry, registryScope] of Object.entries(REGISTRY_SCOPE_MAP))if (registryScope === normalizedScope) // Return URL with trailing slash (normalized format)
+    return registry.endsWith('/') ? registry : `${registry}/`;
+    return null;
 }
 /**
- * Skill Parser - SKILL.md parser
+ * Get the registry URL for a given scope
  *
- * Following agentskills.io specification: https://agentskills.io/specification
+ * - With scope → lookup private Registry (throws if not found)
+ * - Without scope (null/undefined/'') → returns public Registry
  *
- * SKILL.md format requirements:
- * - YAML frontmatter containing name and description (required)
- * - name: max 64 characters, lowercase letters, numbers, hyphens
- * - description: max 1024 characters
- * - Optional fields: license, compatibility, metadata, allowed-tools
- */ /**
- * Skill validation error
- */ class SkillValidationError extends Error {
-    field;
-    constructor(message, field){
-        super(message), this.field = field;
-        this.name = 'SkillValidationError';
+ * @param scope - Scope string (with or without @ prefix), null, undefined, or empty string
+ * @param customRegistries - Optional custom scope-to-registry mapping (from skills.json)
+ * @returns Registry URL (with trailing slash)
+ * @throws Error if scope is provided but not found in the registry map
+ *
+ * @example
+ * getRegistryUrl('@kanyun') // 'https://rush-test.zhenguanyu.com/'
+ * getRegistryUrl('kanyun') // 'https://rush-test.zhenguanyu.com/'
+ * getRegistryUrl(null) // 'https://reskill.info/'
+ * getRegistryUrl('') // 'https://reskill.info/'
+ * getRegistryUrl('@unknown') // throws Error
+ * getRegistryUrl('@mycompany', { '@mycompany': 'https://my.registry.com/' }) // 'https://my.registry.com/'
+ */ function getRegistryUrl(scope, customRegistries) {
+    // No scope → return public Registry
+    if (!scope) return PUBLIC_REGISTRY;
+    // With scope → lookup private Registry
+    const registry = getRegistryForScope(scope, customRegistries);
+    if (!registry) {
+        // Normalize scope for error message
+        const normalizedScope = scope.startsWith('@') ? scope : `@${scope}`;
+        throw new Error(`Unknown scope ${normalizedScope}. No registry configured for this scope.`);
     }
+    return registry;
 }
 /**
- * Simple YAML frontmatter parser
- * Parses --- delimited YAML header
+ * Parse a skill name into its components
  *
- * Supports:
- * - Basic key: value pairs
- * - Multiline strings (| and >)
- * - Nested objects (one level deep, for metadata field)
- */ function parseFrontmatter(content) {
-    const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
-    const match = content.match(frontmatterRegex);
-    if (!match) return {
-        data: {},
-        content
-    };
-    const yamlContent = match[1];
-    const markdownContent = match[2];
-    // Simple YAML parsing (supports basic key: value, one level of nesting,
-    // block scalars (| and >), and plain scalars spanning multiple indented lines)
-    const data = {};
-    const lines = yamlContent.split('\n');
-    let currentKey = '';
-    let currentValue = '';
-    let inMultiline = false;
-    let inNestedObject = false;
-    let inPlainScalar = false;
-    let nestedObject = {};
-    /**
-   * Save the current key/value accumulated so far, then reset state.
-   */ function flushCurrent() {
-        if (!currentKey) return;
-        if (inNestedObject) {
-            data[currentKey] = nestedObject;
-            nestedObject = {};
-            inNestedObject = false;
-        } else if (inPlainScalar || inMultiline) {
-            data[currentKey] = currentValue.trim();
-            inPlainScalar = false;
-            inMultiline = false;
-        } else data[currentKey] = parseYamlValue(currentValue.trim());
-        currentKey = '';
-        currentValue = '';
-    }
-    for (const line of lines){
-        const trimmedLine = line.trim();
-        if (!trimmedLine || trimmedLine.startsWith('#')) continue;
-        const isIndented = line.startsWith('  ');
-        // ---- Inside a block scalar (| or >) ----
-        if (inMultiline) {
-            if (isIndented) {
-                currentValue += (currentValue ? '\n' : '') + line.slice(2);
-                continue;
-            }
-            // Unindented line ends the block scalar — fall through to top-level parsing
-            flushCurrent();
-        }
-        // ---- Inside a plain scalar (multiline value without | or >) ----
-        if (inPlainScalar) {
-            if (isIndented) {
-                // Continuation line: join with a space (YAML plain scalar folding)
-                currentValue += ` ${trimmedLine}`;
-                continue;
-            }
-            // Unindented line ends the plain scalar — fall through to top-level parsing
-            flushCurrent();
-        }
-        // ---- Inside a nested object ----
-        if (inNestedObject && isIndented) {
-            const nestedMatch = line.match(/^ {2}([a-zA-Z_-]+):\s*(.*)$/);
-            if (nestedMatch) {
-                const [, nestedKey, nestedValue] = nestedMatch;
-                nestedObject[nestedKey] = parseYamlValue(nestedValue.trim());
-                continue;
-            }
-            // Indented line that isn't a nested key:value — this key was actually
-            // a plain scalar, not a nested object. Switch modes.
-            inNestedObject = false;
-            inPlainScalar = true;
-            currentValue = trimmedLine;
-            continue;
-        }
-        // ---- Top-level key: value ----
-        const keyValueMatch = line.match(/^([a-zA-Z_-]+):\s*(.*)$/);
-        if (keyValueMatch) {
-            flushCurrent();
-            currentKey = keyValueMatch[1];
-            currentValue = keyValueMatch[2];
-            if ('|' === currentValue || '>' === currentValue) {
-                inMultiline = true;
-                currentValue = '';
-            } else if ('' === currentValue) {
-                // Empty value — could be nested object or plain scalar; peek at next lines
-                inNestedObject = true;
-                nestedObject = {};
-            }
-            continue;
-        }
-        // ---- Unindented line that isn't key:value while in nested object ----
-        if (inNestedObject) flushCurrent();
-    }
-    // Save last accumulated value
-    flushCurrent();
+ * @param skillName - Full or short skill name
+ * @returns Parsed skill name with scope and name
+ *
+ * @example
+ * parseSkillName('@kanyun/planning-with-files')
+ * // { scope: '@kanyun', name: 'planning-with-files', fullName: '@kanyun/planning-with-files' }
+ *
+ * parseSkillName('planning-with-files')
+ * // { scope: null, name: 'planning-with-files', fullName: 'planning-with-files' }
+ */ function parseSkillName(skillName) {
+    // Match @scope/name pattern
+    const match = skillName.match(/^(@[^/]+)\/(.+)$/);
+    if (match) return {
+        scope: match[1],
+        name: match[2],
+        fullName: skillName
+    };
     return {
-        data,
-        content: markdownContent
+        scope: null,
+        name: skillName,
+        fullName: skillName
     };
 }
 /**
- * Parse YAML value
- */ function parseYamlValue(value) {
-    if (!value) return '';
-    // Boolean value
-    if ('true' === value) return true;
-    if ('false' === value) return false;
-    // Number
-    if (/^-?\d+$/.test(value)) return parseInt(value, 10);
-    if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
-    // Remove quotes
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
-    return value;
-}
-/**
- * Validate skill name format
+ * Build full skill name from scope and name
  *
- * Specification requirements:
- * - Max 64 characters
- * - Only lowercase letters, numbers, hyphens allowed
- * - Cannot start or end with hyphen
- * - Cannot contain consecutive hyphens
- */ function validateSkillName(name) {
-    if (!name) throw new SkillValidationError('Skill name is required', 'name');
-    if (name.length > 64) throw new SkillValidationError('Skill name must be at most 64 characters', 'name');
-    if (!/^[a-z0-9]/.test(name)) throw new SkillValidationError('Skill name must start with a lowercase letter or number', 'name');
-    if (!/[a-z0-9]$/.test(name)) throw new SkillValidationError('Skill name must end with a lowercase letter or number', 'name');
-    if (/--/.test(name)) throw new SkillValidationError('Skill name cannot contain consecutive hyphens', 'name');
-    if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(name) && name.length > 1) throw new SkillValidationError('Skill name can only contain lowercase letters, numbers, and hyphens', 'name');
-    // Single character name
-    if (1 === name.length && !/^[a-z0-9]$/.test(name)) throw new SkillValidationError('Single character skill name must be a lowercase letter or number', 'name');
+ * @param scope - Scope (with or without @ prefix), or null
+ * @param name - Short skill name
+ * @returns Full skill name (e.g., "@kanyun/planning-with-files")
+ *
+ * @example
+ * buildFullSkillName('@kanyun', 'planning-with-files') // '@kanyun/planning-with-files'
+ * buildFullSkillName('kanyun', 'my-skill') // '@kanyun/my-skill'
+ * buildFullSkillName(null, 'my-skill') // 'my-skill'
+ */ function buildFullSkillName(scope, name) {
+    if (!scope) return name;
+    // Ensure scope starts with @
+    const normalizedScope = scope.startsWith('@') ? scope : `@${scope}`;
+    return `${normalizedScope}/${name}`;
 }
 /**
- * Validate skill description
+ * Get short name from a skill name (removes scope if present)
  *
- * Specification requirements:
- * - Max 1024 characters
- * - Angle brackets are allowed per agentskills.io spec
- */ function validateSkillDescription(description) {
-    if (!description) throw new SkillValidationError('Skill description is required', 'description');
-    if (description.length > 1024) throw new SkillValidationError('Skill description must be at most 1024 characters', 'description');
-// Note: angle brackets are allowed per agentskills.io spec
+ * @param skillName - Full or short skill name
+ * @returns Short name without scope
+ *
+ * @example
+ * getShortName('@kanyun/planning-with-files') // 'planning-with-files'
+ * getShortName('planning-with-files') // 'planning-with-files'
+ */ function getShortName(skillName) {
+    return parseSkillName(skillName).name;
 }
 /**
- * Parse SKILL.md content
+ * Parse a skill identifier into its components (with version support)
  *
- * @param content - SKILL.md file content
- * @param options - Parse options
- * @returns Parsed skill info, or null if format is invalid
- * @throws SkillValidationError if validation fails in strict mode
- */ function parseSkillMd(content, options = {}) {
-    const { strict = false } = options;
-    try {
-        const { data, content: body } = parseFrontmatter(content);
-        // Check required fields
-        if (!data.name || !data.description) {
-            if (strict) throw new SkillValidationError('SKILL.md must have name and description in frontmatter');
-            return null;
-        }
-        const name = String(data.name);
-        const description = String(data.description);
-        // Validate field format
-        if (strict) {
-            validateSkillName(name);
-            validateSkillDescription(description);
-        }
-        // Parse allowed-tools
-        let allowedTools;
-        if (data['allowed-tools']) {
-            const toolsStr = String(data['allowed-tools']);
-            allowedTools = toolsStr.split(/\s+/).filter(Boolean);
-        }
+ * Supports both private registry (with @scope) and public registry (without scope) formats.
+ *
+ * @param identifier - Skill identifier string
+ * @returns Parsed skill identifier with scope, name, version, and fullName
+ * @throws Error if identifier is invalid
+ *
+ * @example
+ * // Private registry
+ * parseSkillIdentifier('@kanyun/planning-with-files')
+ * // { scope: '@kanyun', name: 'planning-with-files', version: undefined, fullName: '@kanyun/planning-with-files' }
+ *
+ * parseSkillIdentifier('@kanyun/skill@2.4.5')
+ * // { scope: '@kanyun', name: 'skill', version: '2.4.5', fullName: '@kanyun/skill' }
+ *
+ * // Public registry
+ * parseSkillIdentifier('planning-with-files')
+ * // { scope: null, name: 'planning-with-files', version: undefined, fullName: 'planning-with-files' }
+ *
+ * parseSkillIdentifier('skill@latest')
+ * // { scope: null, name: 'skill', version: 'latest', fullName: 'skill' }
+ */ function parseSkillIdentifier(identifier) {
+    const trimmed = identifier.trim();
+    // Empty string or whitespace only
+    if (!trimmed) throw new Error('Invalid skill identifier: empty string');
+    // Starting with @@ is invalid
+    if (trimmed.startsWith('@@')) throw new Error('Invalid skill identifier: invalid scope format');
+    // Bare @ is invalid
+    if ('@' === trimmed) throw new Error('Invalid skill identifier: missing scope and name');
+    // Scoped format: @scope/name[@version]
+    if (trimmed.startsWith('@')) {
+        // Regex: @scope/name[@version]
+        // scope: starts with @, followed by alphanumeric, hyphens, underscores
+        // name: alphanumeric, hyphens, underscores
+        // version: optional, @ followed by any non-empty string
+        const scopedMatch = trimmed.match(/^(@[\w-]+)\/([\w-]+)(?:@(.+))?$/);
+        if (!scopedMatch) throw new Error(`Invalid skill identifier: ${identifier}`);
+        const [, scope, name, version] = scopedMatch;
         return {
+            scope,
             name,
-            description,
-            version: data.version ? String(data.version) : void 0,
-            license: data.license ? String(data.license) : void 0,
-            compatibility: data.compatibility ? String(data.compatibility) : void 0,
-            metadata: data.metadata,
-            allowedTools,
-            content: body,
-            rawContent: content
+            version: version || void 0,
+            fullName: `${scope}/${name}`
         };
-    } catch (error) {
-        if (error instanceof SkillValidationError) throw error;
-        if (strict) throw new SkillValidationError(`Failed to parse SKILL.md: ${error}`);
-        return null;
     }
+    // Unscoped format: name[@version] (public registry)
+    // name must not contain / (otherwise it might be a git shorthand)
+    const unscopedMatch = trimmed.match(/^([\w-]+)(?:@(.+))?$/);
+    if (!unscopedMatch) throw new Error(`Invalid skill identifier: ${identifier}`);
+    const [, name, version] = unscopedMatch;
+    return {
+        scope: null,
+        name,
+        version: version || void 0,
+        fullName: name
+    };
 }
 /**
- * Parse SKILL.md from file path
- */ function parseSkillMdFile(filePath, options = {}) {
-    if (!external_node_fs_.existsSync(filePath)) {
-        if (options.strict) throw new SkillValidationError(`SKILL.md not found: ${filePath}`);
-        return null;
+ * HTTP utilities for downloading and extracting skill archives
+ */ /**
+ * Custom error class for HTTP download failures
+ */ class HttpDownloadError extends Error {
+    url;
+    statusCode;
+    originalError;
+    constructor(url, message, statusCode, originalError){
+        super(message);
+        this.name = 'HttpDownloadError';
+        this.url = url;
+        this.statusCode = statusCode;
+        this.originalError = originalError;
     }
-    const content = external_node_fs_.readFileSync(filePath, 'utf-8');
-    return parseSkillMd(content, options);
 }
 /**
- * Parse SKILL.md from skill directory
- */ function parseSkillFromDir(dirPath, options = {}) {
-    const skillMdPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(dirPath, 'SKILL.md');
-    return parseSkillMdFile(skillMdPath, options);
+ * Download a file from HTTP/HTTPS URL
+ *
+ * @param url - URL to download from
+ * @param destPath - Destination file path
+ * @param options - Download options
+ */ async function downloadFile(url, destPath, options = {}) {
+    const { timeout = 60000, headers = {} } = options;
+    // Ensure destination directory exists
+    fs_ensureDir(__WEBPACK_EXTERNAL_MODULE_node_path__.dirname(destPath));
+    try {
+        // Use native fetch for HTTP/HTTPS
+        const controller = new AbortController();
+        const timeoutId = setTimeout(()=>controller.abort(), timeout);
+        const response = await fetch(url, {
+            signal: controller.signal,
+            headers: {
+                'User-Agent': 'reskill/1.0',
+                ...headers
+            }
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) throw new HttpDownloadError(url, `HTTP ${response.status}: ${response.statusText}`, response.status);
+        // Stream response to file
+        const fileStream = external_node_fs_.createWriteStream(destPath);
+        const body = response.body;
+        if (!body) throw new HttpDownloadError(url, 'Response body is empty');
+        // Convert Web ReadableStream to Node.js Readable
+        const { Readable } = await import("node:stream");
+        const nodeStream = Readable.fromWeb(body);
+        await (0, __WEBPACK_EXTERNAL_MODULE_node_stream_promises__.pipeline)(nodeStream, fileStream);
+    } catch (error) {
+        // Clean up partial download
+        if (external_node_fs_.existsSync(destPath)) external_node_fs_.unlinkSync(destPath);
+        if (error instanceof HttpDownloadError) throw error;
+        const err = error;
+        if ('AbortError' === err.name) throw new HttpDownloadError(url, `Download timeout after ${timeout}ms`);
+        throw new HttpDownloadError(url, `Download failed: ${err.message}`, void 0, err);
+    }
 }
 /**
- * Check if directory contains valid SKILL.md
- */ function hasValidSkillMd(dirPath) {
-    const skillMdPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(dirPath, 'SKILL.md');
-    if (!external_node_fs_.existsSync(skillMdPath)) return false;
-    try {
-        const skill = parseSkillMdFile(skillMdPath);
-        return null !== skill;
-    } catch  {
-        return false;
+ * Extract an archive to a directory
+ *
+ * @param archivePath - Path to the archive file
+ * @param destDir - Destination directory
+ * @param format - Archive format (auto-detected from extension if not provided)
+ */ async function extractArchive(archivePath, destDir, format) {
+    // Auto-detect format from extension
+    const detectedFormat = format || detectArchiveFormat(archivePath);
+    if (!detectedFormat) throw new Error(`Unable to detect archive format for: ${archivePath}`);
+    // Ensure destination directory exists
+    fs_ensureDir(destDir);
+    switch(detectedFormat){
+        case 'tar.gz':
+        case 'tgz':
+        case 'tar':
+            await extractTar(archivePath, destDir, 'tar.gz' === detectedFormat || 'tgz' === detectedFormat);
+            break;
+        case 'zip':
+            await extractZip(archivePath, destDir);
+            break;
+        default:
+            throw new Error(`Unsupported archive format: ${detectedFormat}`);
     }
 }
-const SKIP_DIRS = [
-    'node_modules',
-    '.git',
-    'dist',
-    'build',
-    '__pycache__'
-];
-const MAX_DISCOVER_DEPTH = 5;
-const PRIORITY_SKILL_DIRS = [
-    'skills',
-    '.agents/skills',
-    '.cursor/skills',
-    '.claude/skills',
-    '.windsurf/skills',
-    '.github/skills'
-];
-function findSkillDirsRecursive(dir, depth, maxDepth, visitedDirs) {
-    if (depth > maxDepth) return [];
-    const resolvedDir = __WEBPACK_EXTERNAL_MODULE_node_path__.resolve(dir);
-    if (visitedDirs.has(resolvedDir)) return [];
-    if (!external_node_fs_.existsSync(dir) || !external_node_fs_.statSync(dir).isDirectory()) return [];
-    visitedDirs.add(resolvedDir);
-    const results = [];
-    let entries;
+/**
+ * Extract tar archive using native tar command
+ */ async function extractTar(archivePath, destDir, gzipped) {
+    const { exec } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const execAsync = promisify(exec);
+    const flags = gzipped ? '-xzf' : '-xf';
     try {
-        entries = external_node_fs_.readdirSync(dir);
-    } catch  {
-        return [];
-    }
-    for (const entry of entries){
-        if (SKIP_DIRS.includes(entry)) continue;
-        const fullPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(dir, entry);
-        const resolvedFull = __WEBPACK_EXTERNAL_MODULE_node_path__.resolve(fullPath);
-        if (visitedDirs.has(resolvedFull)) continue;
-        let stat;
-        try {
-            stat = external_node_fs_.statSync(fullPath);
-        } catch  {
-            continue;
+        // Extract to a temp directory first to handle single-folder archives
+        const tempExtractDir = `${destDir}.extract-temp`;
+        fs_ensureDir(tempExtractDir);
+        await execAsync(`tar ${flags} "${archivePath}" -C "${tempExtractDir}"`, {
+            encoding: 'utf-8'
+        });
+        // Check if archive contains a single root directory
+        const extractedItems = external_node_fs_.readdirSync(tempExtractDir);
+        if (1 === extractedItems.length) {
+            const singleItem = __WEBPACK_EXTERNAL_MODULE_node_path__.join(tempExtractDir, extractedItems[0]);
+            if (external_node_fs_.statSync(singleItem).isDirectory()) {
+                // Move contents of single directory to destination
+                const contents = external_node_fs_.readdirSync(singleItem);
+                for (const item of contents){
+                    const src = __WEBPACK_EXTERNAL_MODULE_node_path__.join(singleItem, item);
+                    const dest = __WEBPACK_EXTERNAL_MODULE_node_path__.join(destDir, item);
+                    external_node_fs_.renameSync(src, dest);
+                }
+                fs_remove(tempExtractDir);
+                return;
+            }
         }
-        if (!!stat.isDirectory()) {
-            if (hasValidSkillMd(fullPath)) results.push(fullPath);
-            results.push(...findSkillDirsRecursive(fullPath, depth + 1, maxDepth, visitedDirs));
+        // Move all items to destination
+        for (const item of extractedItems){
+            const src = __WEBPACK_EXTERNAL_MODULE_node_path__.join(tempExtractDir, item);
+            const dest = __WEBPACK_EXTERNAL_MODULE_node_path__.join(destDir, item);
+            external_node_fs_.renameSync(src, dest);
         }
+        fs_remove(tempExtractDir);
+    } catch (error) {
+        throw new Error(`Failed to extract tar archive: ${error.message}`);
     }
-    return results;
 }
 /**
- * Discover all skills in a directory by scanning for SKILL.md files.
- *
- * Strategy:
- * 1. Check root for SKILL.md
- * 2. Search priority directories (skills/, .agents/skills/, .cursor/skills/, etc.)
- * 3. Fall back to recursive search (max depth 5, skip node_modules, .git, dist, etc.)
- *
- * @param basePath - Root directory to search
- * @returns List of parsed skills with their directory paths (absolute)
- */ function discoverSkillsInDir(basePath) {
-    const resolvedBase = __WEBPACK_EXTERNAL_MODULE_node_path__.resolve(basePath);
-    const results = [];
-    const seenNames = new Set();
-    function addSkill(dirPath) {
-        const skill = parseSkillFromDir(dirPath);
-        if (skill && !seenNames.has(skill.name)) {
-            seenNames.add(skill.name);
-            results.push({
-                ...skill,
-                dirPath: __WEBPACK_EXTERNAL_MODULE_node_path__.resolve(dirPath)
-            });
-        }
-    }
-    if (hasValidSkillMd(resolvedBase)) addSkill(resolvedBase);
-    // Track visited directories to avoid redundant I/O during recursive scan
-    const visitedDirs = new Set();
-    for (const sub of PRIORITY_SKILL_DIRS){
-        const dir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(resolvedBase, sub);
-        if (!!external_node_fs_.existsSync(dir) && !!external_node_fs_.statSync(dir).isDirectory()) {
-            visitedDirs.add(__WEBPACK_EXTERNAL_MODULE_node_path__.resolve(dir));
-            try {
-                const entries = external_node_fs_.readdirSync(dir);
-                for (const entry of entries){
-                    const skillDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(dir, entry);
-                    try {
-                        if (external_node_fs_.statSync(skillDir).isDirectory() && hasValidSkillMd(skillDir)) {
-                            addSkill(skillDir);
-                            visitedDirs.add(__WEBPACK_EXTERNAL_MODULE_node_path__.resolve(skillDir));
-                        }
-                    } catch  {
-                    // Skip entries that can't be stat'd (race condition, permission, etc.)
-                    }
+ * Extract zip archive using native unzip command or Node.js
+ */ async function extractZip(archivePath, destDir) {
+    const { exec } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const execAsync = promisify(exec);
+    try {
+        // Extract to a temp directory first
+        const tempExtractDir = `${destDir}.extract-temp`;
+        fs_ensureDir(tempExtractDir);
+        // Try using unzip command (available on most systems)
+        await execAsync(`unzip -q "${archivePath}" -d "${tempExtractDir}"`, {
+            encoding: 'utf-8'
+        });
+        // Check if archive contains a single root directory
+        const extractedItems = external_node_fs_.readdirSync(tempExtractDir);
+        if (1 === extractedItems.length) {
+            const singleItem = __WEBPACK_EXTERNAL_MODULE_node_path__.join(tempExtractDir, extractedItems[0]);
+            if (external_node_fs_.statSync(singleItem).isDirectory()) {
+                // Move contents of single directory to destination
+                const contents = external_node_fs_.readdirSync(singleItem);
+                for (const item of contents){
+                    const src = __WEBPACK_EXTERNAL_MODULE_node_path__.join(singleItem, item);
+                    const dest = __WEBPACK_EXTERNAL_MODULE_node_path__.join(destDir, item);
+                    external_node_fs_.renameSync(src, dest);
                 }
-            } catch  {
-            // Skip if unreadable
+                fs_remove(tempExtractDir);
+                return;
             }
         }
+        // Move all items to destination
+        for (const item of extractedItems){
+            const src = __WEBPACK_EXTERNAL_MODULE_node_path__.join(tempExtractDir, item);
+            const dest = __WEBPACK_EXTERNAL_MODULE_node_path__.join(destDir, item);
+            external_node_fs_.renameSync(src, dest);
+        }
+        fs_remove(tempExtractDir);
+    } catch (error) {
+        throw new Error(`Failed to extract zip archive: ${error.message}`);
     }
-    const recursiveDirs = findSkillDirsRecursive(resolvedBase, 0, MAX_DISCOVER_DEPTH, visitedDirs);
-    for (const skillDir of recursiveDirs)addSkill(skillDir);
-    return results;
 }
 /**
- * Filter skills by name (case-insensitive exact match).
- *
- * Note: an empty `names` array returns an empty result (not all skills).
- * Callers should check `names.length` before calling if "no filter = all" is desired.
+ * Detect archive format from file path
+ */ function detectArchiveFormat(filePath) {
+    const lower = filePath.toLowerCase();
+    if (lower.endsWith('.tar.gz')) return 'tar.gz';
+    if (lower.endsWith('.tgz')) return 'tgz';
+    if (lower.endsWith('.zip')) return 'zip';
+    if (lower.endsWith('.tar')) return 'tar';
+}
+/**
+ * Download and extract an archive in one operation
  *
- * @param skills - List of discovered skills
- * @param names - Skill names to match (e.g. from --skill pdf commit)
- * @returns Skills whose name matches any of the given names
- */ function filterSkillsByName(skills, names) {
-    const normalized = names.map((n)=>n.toLowerCase());
-    return skills.filter((skill)=>{
-        // Match against SKILL.md name field
-        if (normalized.includes(skill.name.toLowerCase())) return true;
-        // Also match against the directory name (basename of dirPath)
-        // Users naturally refer to skills by their directory name
-        const dirName = __WEBPACK_EXTERNAL_MODULE_node_path__.basename(skill.dirPath).toLowerCase();
-        return normalized.includes(dirName);
-    });
+ * @param url - URL to download from
+ * @param destDir - Destination directory for extracted contents
+ * @param options - Download options
+ * @returns Path to extracted contents
+ */ async function downloadAndExtract(url, destDir, options = {}) {
+    // Determine archive filename from URL
+    const urlObj = new URL(url);
+    const filename = __WEBPACK_EXTERNAL_MODULE_node_path__.basename(urlObj.pathname);
+    // Detect format from original filename before adding .download suffix
+    const format = detectArchiveFormat(filename);
+    if (!format) throw new Error(`Unable to detect archive format from URL: ${url}`);
+    const tempArchive = __WEBPACK_EXTERNAL_MODULE_node_path__.join(destDir, `../${filename}.download`);
+    try {
+        // Download archive
+        await downloadFile(url, tempArchive, options);
+        // Extract archive with explicit format
+        await extractArchive(tempArchive, destDir, format);
+        return destDir;
+    } finally{
+        // Clean up temp archive
+        if (external_node_fs_.existsSync(tempArchive)) external_node_fs_.unlinkSync(tempArchive);
+    }
 }
 /**
  * Installer - Multi-Agent installer
@@ -1469,14 +1726,14 @@ const installer_SKILLS_SUBDIR = 'skills';
 /**
  * Default files to exclude when copying skills
  * These files are typically used for repository metadata and should not be copied to agent directories
- */ const DEFAULT_EXCLUDE_FILES = [
+ */ const installer_DEFAULT_EXCLUDE_FILES = [
     'README.md',
     'metadata.json',
     '.reskill-commit'
 ];
 /**
  * Prefix for files that should be excluded (internal/private files)
- */ const EXCLUDE_PREFIX = '_';
+ */ const installer_EXCLUDE_PREFIX = '_';
 /**
  * Sanitize filename to prevent path traversal attacks
  */ function installer_sanitizeName(name) {
@@ -1530,18 +1787,18 @@ const installer_SKILLS_SUBDIR = 'skills';
  * By default excludes:
  * - Files in DEFAULT_EXCLUDE_FILES (README.md, metadata.json, .reskill-commit)
  * - Files starting with EXCLUDE_PREFIX ('_')
- */ function copyDirectory(src, dest, options) {
-    const exclude = new Set(options?.exclude || DEFAULT_EXCLUDE_FILES);
+ */ function installer_copyDirectory(src, dest, options) {
+    const exclude = new Set(options?.exclude || installer_DEFAULT_EXCLUDE_FILES);
     installer_ensureDir(dest);
     const entries = external_node_fs_.readdirSync(src, {
         withFileTypes: true
     });
     for (const entry of entries){
         // Skip files starting with EXCLUDE_PREFIX and files in exclude list
-        if (exclude.has(entry.name) || entry.name.startsWith(EXCLUDE_PREFIX)) continue;
+        if (exclude.has(entry.name) || entry.name.startsWith(installer_EXCLUDE_PREFIX)) 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);
+        if (entry.isDirectory()) installer_copyDirectory(srcPath, destPath, options);
         else external_node_fs_.copyFileSync(srcPath, destPath);
     }
 }
@@ -1608,6 +1865,7 @@ const installer_SKILLS_SUBDIR = 'skills';
     /**
    * Get agent's skill installation path
    */ getAgentSkillPath(skillName, agentType) {
+        if (agentType === claude_3p_installer_CLAUDE_COWORK_3P_AGENT) return getClaude3pSkillPath(skillName);
         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);
@@ -1621,6 +1879,9 @@ const installer_SKILLS_SUBDIR = 'skills';
    * @param agentType - Target agent type
    * @param options - Installation options
    */ async installForAgent(sourcePath, skillName, agentType, options = {}) {
+        if (agentType === claude_3p_installer_CLAUDE_COWORK_3P_AGENT) return installClaude3pSkill(sourcePath, skillName, {
+            mode: options.mode
+        });
         const agent = getAgentConfig(agentType);
         const installMode = options.mode || 'symlink';
         const sanitized = installer_sanitizeName(skillName);
@@ -1649,7 +1910,7 @@ const installer_SKILLS_SUBDIR = 'skills';
             if ('copy' === installMode) {
                 installer_ensureDir(agentDir);
                 installer_remove(agentDir);
-                copyDirectory(sourcePath, agentDir);
+                installer_copyDirectory(sourcePath, agentDir);
                 result = {
                     success: true,
                     path: agentDir,
@@ -1659,7 +1920,7 @@ const installer_SKILLS_SUBDIR = 'skills';
                 // Symlink mode: copy to canonical location, then create symlink
                 installer_ensureDir(canonicalDir);
                 installer_remove(canonicalDir);
-                copyDirectory(sourcePath, canonicalDir);
+                installer_copyDirectory(sourcePath, canonicalDir);
                 const symlinkCreated = await installer_createSymlink(canonicalDir, agentDir);
                 if (symlinkCreated) result = {
                     success: true,
@@ -1675,7 +1936,7 @@ const installer_SKILLS_SUBDIR = 'skills';
                     // Ignore cleanup errors
                     }
                     installer_ensureDir(agentDir);
-                    copyDirectory(sourcePath, agentDir);
+                    installer_copyDirectory(sourcePath, agentDir);
                     result = {
                         success: true,
                         path: agentDir,
@@ -1710,8 +1971,12 @@ const installer_SKILLS_SUBDIR = 'skills';
     /**
    * Check if skill is installed to specified agent
    */ isInstalled(skillName, agentType) {
-        const skillPath = this.getAgentSkillPath(skillName, agentType);
-        return external_node_fs_.existsSync(skillPath);
+        try {
+            const skillPath = this.getAgentSkillPath(skillName, agentType);
+            return external_node_fs_.existsSync(skillPath);
+        } catch  {
+            return false;
+        }
     }
     /**
    * Check if skill is installed in canonical location
@@ -1722,6 +1987,11 @@ const installer_SKILLS_SUBDIR = 'skills';
     /**
    * Uninstall skill from specified agent
    */ uninstallFromAgent(skillName, agentType) {
+        if (agentType === claude_3p_installer_CLAUDE_COWORK_3P_AGENT) try {
+            return uninstallClaude3pSkill(skillName);
+        } catch  {
+            return false;
+        }
         const skillPath = this.getAgentSkillPath(skillName, agentType);
         if (!external_node_fs_.existsSync(skillPath)) return false;
         installer_remove(skillPath);
@@ -1742,6 +2012,11 @@ const installer_SKILLS_SUBDIR = 'skills';
     /**
    * Get all skills installed to specified agent
    */ listInstalledSkills(agentType) {
+        if (agentType === claude_3p_installer_CLAUDE_COWORK_3P_AGENT) try {
+            return listClaude3pSkills();
+        } catch  {
+            return [];
+        }
         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 [];
@@ -1869,7 +2144,7 @@ ${CURSOR_BRIDGE_MARKER}
    * Check if skill is cached
    */ isCached(parsed, version) {
         const cachePath = this.getSkillCachePath(parsed, version);
-        return exists(cachePath) && isDirectory(cachePath);
+        return fs_exists(cachePath) && isDirectory(cachePath);
     }
     /**
    * Get cached skill
@@ -1881,7 +2156,7 @@ ${CURSOR_BRIDGE_MARKER}
         let commit = '';
         try {
             const fs = await import("node:fs");
-            if (exists(commitFile)) commit = fs.readFileSync(commitFile, 'utf-8').trim();
+            if (fs_exists(commitFile)) commit = fs.readFileSync(commitFile, 'utf-8').trim();
         } catch  {
         // Ignore read errors
         }
@@ -1895,11 +2170,11 @@ ${CURSOR_BRIDGE_MARKER}
    */ async cache(repoUrl, parsed, ref, version) {
         const cachePath = this.getSkillCachePath(parsed, version);
         // If exists, delete first
-        if (exists(cachePath)) remove(cachePath);
-        ensureDir(__WEBPACK_EXTERNAL_MODULE_node_path__.dirname(cachePath));
+        if (fs_exists(cachePath)) fs_remove(cachePath);
+        fs_ensureDir(__WEBPACK_EXTERNAL_MODULE_node_path__.dirname(cachePath));
         // Clone repository
         const tempPath = `${cachePath}.tmp`;
-        remove(tempPath);
+        fs_remove(tempPath);
         await clone(repoUrl, tempPath, {
             depth: 1,
             branch: ref
@@ -1909,8 +2184,8 @@ ${CURSOR_BRIDGE_MARKER}
         // If has subPath, only keep subdirectory
         if (parsed.subPath) {
             const subDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(tempPath, parsed.subPath);
-            if (!exists(subDir)) {
-                remove(tempPath);
+            if (!fs_exists(subDir)) {
+                fs_remove(tempPath);
                 throw new Error(`Subpath ${parsed.subPath} not found in repository`);
             }
             copyDir(subDir, cachePath, {
@@ -1926,7 +2201,7 @@ ${CURSOR_BRIDGE_MARKER}
         // Save commit info
         external_node_fs_.writeFileSync(__WEBPACK_EXTERNAL_MODULE_node_path__.join(cachePath, '.reskill-commit'), commit);
         // Clean up temp directory
-        remove(tempPath);
+        fs_remove(tempPath);
         return {
             path: cachePath,
             commit
@@ -1945,8 +2220,8 @@ ${CURSOR_BRIDGE_MARKER}
    */ async cacheFromHttp(url, parsed, version) {
         const cachePath = this.getSkillCachePath(parsed, version);
         // If exists, delete first
-        if (exists(cachePath)) remove(cachePath);
-        ensureDir(__WEBPACK_EXTERNAL_MODULE_node_path__.dirname(cachePath));
+        if (fs_exists(cachePath)) fs_remove(cachePath);
+        fs_ensureDir(__WEBPACK_EXTERNAL_MODULE_node_path__.dirname(cachePath));
         // Download and extract to cache path
         await downloadAndExtract(url, cachePath);
         // Generate a commit-like identifier from URL and version
@@ -1971,10 +2246,10 @@ ${CURSOR_BRIDGE_MARKER}
         const cached = await this.get(parsed, version);
         if (!cached) throw new Error(`Skill ${parsed.raw} version ${version} not found in cache`);
         // If target exists, delete first
-        if (exists(destPath)) remove(destPath);
+        if (fs_exists(destPath)) fs_remove(destPath);
         // Use same exclude rules as Installer for consistency
         copyDir(cached.path, destPath, {
-            exclude: DEFAULT_EXCLUDE_FILES
+            exclude: installer_DEFAULT_EXCLUDE_FILES
         });
     }
     /**
@@ -1982,22 +2257,22 @@ ${CURSOR_BRIDGE_MARKER}
    */ clearSkill(parsed, version) {
         if (version) {
             const cachePath = this.getSkillCachePath(parsed, version);
-            remove(cachePath);
+            fs_remove(cachePath);
         } else {
             // Clear all versions
             const skillDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cacheDir, parsed.registry, parsed.owner, parsed.repo);
-            remove(skillDir);
+            fs_remove(skillDir);
         }
     }
     /**
    * Clear all cache
    */ clearAll() {
-        remove(this.cacheDir);
+        fs_remove(this.cacheDir);
     }
     /**
    * Get cache statistics
    */ getStats() {
-        if (!exists(this.cacheDir)) return {
+        if (!fs_exists(this.cacheDir)) return {
             totalSkills: 0,
             registries: []
         };
@@ -2151,7 +2426,7 @@ ${CURSOR_BRIDGE_MARKER}
     /**
    * Check if configuration file exists
    */ exists() {
-        return exists(this.configPath);
+        return fs_exists(this.configPath);
     }
     /**
    * Load configuration from file
@@ -3073,7 +3348,7 @@ ${CURSOR_BRIDGE_MARKER}
     /**
    * Check if lock file exists
    */ exists() {
-        return exists(this.lockPath);
+        return fs_exists(this.lockPath);
     }
     /**
    * Load lock file
@@ -4033,6 +4308,16 @@ class RegistryResolver {
         return this.isGlobal;
     }
     /**
+   * Determine if the installation is effectively global.
+   *
+   * Claude Cowork 3P always installs to a global app-managed directory regardless
+   * of the isGlobal flag. When all target agents are claude-cowork-3p, the
+   * installation should be treated as global (skip skills.json/skills.lock writes).
+   */ isEffectivelyGlobal(targetAgents) {
+        if (this.isGlobal) return true;
+        return targetAgents.length > 0 && targetAgents.every((a)=>a === claude_3p_installer_CLAUDE_COWORK_3P_AGENT);
+    }
+    /**
    * Get project root directory
    */ getProjectRoot() {
         return this.projectRoot;
@@ -4064,11 +4349,11 @@ class RegistryResolver {
    */ getSkillPath(name) {
         // Check canonical location first (.agents/skills/)
         const canonicalPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.getCanonicalSkillsDir(), name);
-        if (exists(canonicalPath)) return canonicalPath;
+        if (fs_exists(canonicalPath)) return canonicalPath;
         // Check configured installation directory (.skills/ or custom)
         const installDir = this.getInstallDir();
         const installPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(installDir, name);
-        if (exists(installPath)) return installPath;
+        if (fs_exists(installPath)) return installPath;
         // Default to configured installation directory for new installations
         // if it's not the default .skills, otherwise use canonical location.
         // This respects "installDir" in skills.json.
@@ -4148,7 +4433,7 @@ class RegistryResolver {
         const semanticVersion = metadata?.version ?? gitRef;
         const skillPath = this.getSkillPath(skillName);
         // Check if already installed (using the real name from SKILL.md)
-        if (exists(skillPath) && !force) {
+        if (fs_exists(skillPath) && !force) {
             const locked = this.lockManager.get(skillName);
             // Compare ref if available, fallback to version for backward compatibility
             const lockedRef = locked?.ref || locked?.version;
@@ -4165,10 +4450,10 @@ class RegistryResolver {
         }
         logger_logger["package"](`Installing ${skillName}@${gitRef}...`);
         // Copy to installation directory
-        ensureDir(this.getInstallDir());
-        if (exists(skillPath)) remove(skillPath);
+        fs_ensureDir(this.getInstallDir());
+        if (fs_exists(skillPath)) fs_remove(skillPath);
         copyDir(sourcePath, skillPath, {
-            exclude: DEFAULT_EXCLUDE_FILES
+            exclude: installer_DEFAULT_EXCLUDE_FILES
         });
         // Update lock file (project mode only)
         if (!this.isGlobal) this.lockManager.lockSkill(skillName, {
@@ -4215,7 +4500,7 @@ class RegistryResolver {
         const semanticVersion = metadata?.version ?? version;
         const skillPath = this.getSkillPath(skillName);
         // Check if already installed (using the real name from SKILL.md)
-        if (exists(skillPath) && !force) {
+        if (fs_exists(skillPath) && !force) {
             const locked = this.lockManager.get(skillName);
             const lockedRef = locked?.ref || locked?.version;
             if (locked && lockedRef === version) {
@@ -4231,8 +4516,8 @@ class RegistryResolver {
         }
         logger_logger["package"](`Installing ${skillName}@${version} from ${httpInfo.host}...`);
         // Copy to installation directory
-        ensureDir(this.getInstallDir());
-        if (exists(skillPath)) remove(skillPath);
+        fs_ensureDir(this.getInstallDir());
+        if (fs_exists(skillPath)) fs_remove(skillPath);
         await this.cache.copyTo(parsed, version, skillPath);
         // Update lock file (project mode only)
         if (!this.isGlobal) this.lockManager.lockSkill(skillName, {
@@ -4277,13 +4562,13 @@ class RegistryResolver {
    * Uninstall skill
    */ uninstall(name) {
         const skillPath = this.getSkillPath(name);
-        if (!exists(skillPath)) {
+        if (!fs_exists(skillPath)) {
             const location = this.isGlobal ? '(global)' : '';
             logger_logger.warn(`Skill ${name} is not installed ${location}`.trim());
             return false;
         }
         // Remove installation directory
-        remove(skillPath);
+        fs_remove(skillPath);
         // Remove from lock file (project mode only)
         if (!this.isGlobal) this.lockManager.remove(name);
         // Remove from skills.json (project mode only)
@@ -4442,13 +4727,15 @@ class RegistryResolver {
     /**
    * List installed skills
    *
-   * Checks both canonical (.agents/skills/) and legacy (.skills/) locations.
-   */ list() {
+   * When `agent` is specified, lists skills installed to that specific agent.
+   * Otherwise checks both canonical (.agents/skills/) and legacy (.skills/) locations.
+   */ list(options) {
+        if (options?.agent) return this.listByAgent(options.agent);
         const skills = [];
         const seenNames = new Set();
         // Check canonical location first (.agents/skills/)
         const canonicalDir = this.getCanonicalSkillsDir();
-        if (exists(canonicalDir)) for (const name of listDir(canonicalDir)){
+        if (fs_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);
@@ -4459,7 +4746,7 @@ class RegistryResolver {
         }
         // Check legacy location (.skills/)
         const legacyDir = this.getInstallDir();
-        if (exists(legacyDir) && legacyDir !== canonicalDir) for (const name of listDir(legacyDir)){
+        if (fs_exists(legacyDir) && legacyDir !== canonicalDir) for (const name of listDir(legacyDir)){
             // Skip if already found in canonical location
             if (seenNames.has(name)) continue;
             const skillPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(legacyDir, name);
@@ -4477,6 +4764,38 @@ class RegistryResolver {
                 seenNames.add(name);
             }
         }
+        // In global mode, also include claude-cowork-3p skills (always global)
+        if (this.isGlobal) try {
+            for (const name of listClaude3pSkills()){
+                if (seenNames.has(name)) continue;
+                const skillPath = getClaude3pSkillPath(name);
+                const skill = this.getInstalledSkillFromPath(name, skillPath);
+                if (skill) {
+                    skills.push(skill);
+                    seenNames.add(name);
+                }
+            }
+        } catch  {
+        // Claude Cowork 3P not configured or accessible — skip silently
+        }
+        return skills;
+    }
+    /**
+   * List skills installed to a specific agent
+   */ listByAgent(agent) {
+        const installer = new Installer({
+            cwd: this.projectRoot,
+            global: this.isGlobal
+        });
+        const skillNames = installer.listInstalledSkills(agent);
+        const skills = [];
+        for (const name of skillNames)try {
+            const skillPath = installer.getAgentSkillPath(name, agent);
+            const skill = this.getInstalledSkillFromPath(name, skillPath);
+            if (skill) skills.push(skill);
+        } catch  {
+        // Skip skills whose paths cannot be resolved (e.g. claude-3p not configured)
+        }
         return skills;
     }
     /**
@@ -4489,18 +4808,26 @@ class RegistryResolver {
         const canonicalDir = this.getCanonicalSkillsDir();
         const installed = [];
         for (const [type, config] of Object.entries(agents)){
+            if (type === claude_3p_installer_CLAUDE_COWORK_3P_AGENT) {
+                try {
+                    if (fs_exists(getClaude3pSkillPath(skillName))) installed.push(type);
+                } catch  {
+                // Claude Cowork 3P keeps skills under an app-managed account directory.
+                }
+                continue;
+            }
             const agentBase = this.isGlobal ? config.globalSkillsDir : __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.projectRoot, config.skillsDir);
             // Skip agents whose skillsDir is the canonical directory itself
             if (__WEBPACK_EXTERNAL_MODULE_node_path__.resolve(agentBase) === __WEBPACK_EXTERNAL_MODULE_node_path__.resolve(canonicalDir)) continue;
             const agentSkillDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(agentBase, skillName);
-            if (exists(agentSkillDir)) installed.push(type);
+            if (fs_exists(agentSkillDir)) installed.push(type);
         }
         return installed;
     }
     /**
    * Get installed skill information from a specific path
    */ getInstalledSkillFromPath(name, skillPath) {
-        if (!exists(skillPath)) return null;
+        if (!fs_exists(skillPath)) return null;
         const isLinked = isSymlink(skillPath);
         const locked = this.lockManager.get(name);
         // Read metadata from SKILL.md (sole source per agentskills.io spec)
@@ -4523,10 +4850,10 @@ class RegistryResolver {
    */ getInstalledSkill(name) {
         // Check canonical location first (.agents/skills/)
         const canonicalPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.getCanonicalSkillsDir(), name);
-        if (exists(canonicalPath)) return this.getInstalledSkillFromPath(name, canonicalPath);
+        if (fs_exists(canonicalPath)) return this.getInstalledSkillFromPath(name, canonicalPath);
         // Check legacy location (.skills/)
         const legacyPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.getInstallDir(), name);
-        if (exists(legacyPath)) return this.getInstalledSkillFromPath(name, legacyPath);
+        if (fs_exists(legacyPath)) return this.getInstalledSkillFromPath(name, legacyPath);
         return null;
     }
     /**
@@ -4722,14 +5049,15 @@ class RegistryResolver {
             const results = await installer.installToAgents(skillInfo.dirPath, skillInfo.name, targetAgents, {
                 mode: mode
             });
-            if (!this.isGlobal) this.lockManager.lockSkill(skillInfo.name, {
+            const effectivelyGlobal = this.isEffectivelyGlobal(targetAgents);
+            if (!effectivelyGlobal) this.lockManager.lockSkill(skillInfo.name, {
                 source: skillSource,
                 version: semanticVersion,
                 ref: gitRef,
                 resolved: repoUrl,
                 commit: cacheResult.commit
             });
-            if (!this.isGlobal && save) {
+            if (!effectivelyGlobal && save) {
                 this.config.ensureExists();
                 this.config.addSkill(skillInfo.name, `${baseRefForSave}#${skillInfo.name}`);
             }
@@ -4787,8 +5115,9 @@ class RegistryResolver {
         const results = await installer.installToAgents(sourcePath, skillName, targetAgents, {
             mode: mode
         });
-        // Update lock file (project mode only)
-        if (!this.isGlobal) {
+        // Update lock file (project mode only, skip for effectively-global installs)
+        const effectivelyGlobal = this.isEffectivelyGlobal(targetAgents);
+        if (!effectivelyGlobal) {
             const lockSource = registryContext?.lockSource ?? `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? `/${parsed.subPath}` : ''}`;
             this.lockManager.lockSkill(skillName, {
                 source: lockSource,
@@ -4799,8 +5128,8 @@ class RegistryResolver {
                 registry: registryContext?.registryUrl
             });
         }
-        // Update skills.json (project mode only)
-        if (!this.isGlobal && save) {
+        // Update skills.json (project mode only, skip for effectively-global installs)
+        if (!effectivelyGlobal && save) {
             this.config.ensureExists();
             const configRef = registryContext?.configRef ?? this.config.normalizeSkillRef(ref);
             this.config.addSkill(skillName, configRef);
@@ -4858,8 +5187,9 @@ class RegistryResolver {
         const results = await installer.installToAgents(sourcePath, skillName, targetAgents, {
             mode: mode
         });
-        // Update lock file (project mode only)
-        if (!this.isGlobal) {
+        // Update lock file (project mode only, skip for effectively-global installs)
+        const effectivelyGlobal = this.isEffectivelyGlobal(targetAgents);
+        if (!effectivelyGlobal) {
             const lockSource = registryContext?.lockSource ?? `http:${httpInfo.host}/${skillName}`;
             this.lockManager.lockSkill(skillName, {
                 source: lockSource,
@@ -4870,8 +5200,8 @@ class RegistryResolver {
                 registry: registryContext?.registryUrl
             });
         }
-        // Update skills.json (project mode only)
-        if (!this.isGlobal && save) {
+        // Update skills.json (project mode only, skip for effectively-global installs)
+        if (!effectivelyGlobal && save) {
             this.config.ensureExists();
             const configRef = registryContext?.configRef ?? ref;
             this.config.addSkill(skillName, configRef);
@@ -4937,7 +5267,7 @@ class RegistryResolver {
         const { shortName, version, registryUrl: resolvedRegistryUrl, tarball, parsed: resolvedParsed } = resolved;
         // 2. Check if already installed (skip if --force)
         const skillPath = this.getSkillPath(shortName);
-        if (exists(skillPath) && !force) {
+        if (fs_exists(skillPath) && !force) {
             const locked = this.lockManager.get(shortName);
             const lockedVersion = locked?.version;
             // Same version already installed
@@ -4974,8 +5304,8 @@ class RegistryResolver {
         logger_logger["package"](`Installing ${shortName}@${version} from ${resolvedRegistryUrl} to ${targetAgents.length} agent(s)...`);
         // 3. Create temp directory for extraction (clean stale files first)
         const tempDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cache.getCacheDir(), 'registry-temp', `${shortName}-${version}`);
-        await remove(tempDir);
-        await ensureDir(tempDir);
+        await fs_remove(tempDir);
+        await fs_ensureDir(tempDir);
         try {
             // 4. Extract tarball
             const extractedPath = await this.registryResolver.extract(tarball, tempDir);
@@ -4991,8 +5321,9 @@ class RegistryResolver {
             const results = await installer.installToAgents(extractedPath, shortName, targetAgents, {
                 mode: mode
             });
-            // 7. Update lock file (project mode only)
-            if (!this.isGlobal) this.lockManager.lockSkill(shortName, {
+            // 7. Update lock file (project mode only, skip for effectively-global installs)
+            const effectivelyGlobal = this.isEffectivelyGlobal(targetAgents);
+            if (!effectivelyGlobal) this.lockManager.lockSkill(shortName, {
                 source: `registry:${resolvedParsed.fullName}`,
                 version,
                 ref: version,
@@ -5000,8 +5331,8 @@ class RegistryResolver {
                 commit: resolved.integrity,
                 registry: resolvedRegistryUrl
             });
-            // 8. Update skills.json (project mode only)
-            if (!this.isGlobal && save) {
+            // 8. Update skills.json (project mode only, skip for effectively-global installs)
+            if (!effectivelyGlobal && save) {
                 this.config.ensureExists();
                 // Save with full name for registry skills
                 this.config.addSkill(shortName, ref);
@@ -5032,7 +5363,7 @@ class RegistryResolver {
             };
         } finally{
             // Clean up temp directory after installation
-            await remove(tempDir);
+            await fs_remove(tempDir);
         }
     }
     // ============================================================================
@@ -5067,7 +5398,8 @@ class RegistryResolver {
             registryContext
         };
         // Save custom registry to skills.json.registries (for reinstall without lock file)
-        if (!this.isGlobal && options.registry) {
+        const effectivelyGlobal = this.isEffectivelyGlobal(targetAgents);
+        if (!effectivelyGlobal && options.registry) {
             const registryName = this.deriveRegistryName(options.registry);
             if (registryName) {
                 this.config.ensureExists();
@@ -5151,8 +5483,8 @@ class RegistryResolver {
         logger_logger["package"](`Installing ${shortName} from ${registryUrl} to ${targetAgents.length} agent(s)...`);
         // Extract tarball to temp directory (clean stale files first)
         const tempDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cache.getCacheDir(), 'registry-temp', `${shortName}-${version}`);
-        await remove(tempDir);
-        await ensureDir(tempDir);
+        await fs_remove(tempDir);
+        await fs_ensureDir(tempDir);
         try {
             const extractedPath = await this.registryResolver.extract(tarball, tempDir);
             logger_logger.debug(`Extracted to ${extractedPath}`);
@@ -5170,8 +5502,9 @@ class RegistryResolver {
             const metadata = this.getSkillMetadataFromDir(extractedPath);
             const skillName = metadata?.name ?? shortName;
             const semanticVersion = metadata?.version ?? version;
-            // Update lock file (project mode only)
-            if (!this.isGlobal) this.lockManager.lockSkill(skillName, {
+            // Update lock file (project mode only, skip for effectively-global installs)
+            const effectivelyGlobal = this.isEffectivelyGlobal(targetAgents);
+            if (!effectivelyGlobal) this.lockManager.lockSkill(skillName, {
                 source: `registry:${parsed.fullName}`,
                 version: semanticVersion,
                 ref: version,
@@ -5179,8 +5512,8 @@ class RegistryResolver {
                 commit: '',
                 registry: registryUrl
             });
-            // Update skills.json (project mode only)
-            if (!this.isGlobal && save) {
+            // Update skills.json (project mode only, skip for effectively-global installs)
+            if (!effectivelyGlobal && save) {
                 this.config.ensureExists();
                 this.config.addSkill(skillName, parsed.fullName);
                 // Save custom registry to skills.json.registries (for reinstall without lock file)
@@ -5203,7 +5536,7 @@ class RegistryResolver {
             };
         } finally{
             // Clean up temp directory after installation
-            await remove(tempDir);
+            await fs_remove(tempDir);
         }
     }
     /**
@@ -5254,10 +5587,11 @@ class RegistryResolver {
             installDir: defaults.installDir
         });
         const results = installer.uninstallFromAgents(name, targetAgents);
-        // Remove from lock file (project mode only)
-        if (!this.isGlobal) this.lockManager.remove(name);
-        // Remove from skills.json (project mode only)
-        if (!this.isGlobal && this.config.exists()) this.config.removeSkill(name);
+        // Remove from lock file (project mode only, skip for effectively-global installs)
+        const effectivelyGlobal = this.isEffectivelyGlobal(targetAgents);
+        if (!effectivelyGlobal) this.lockManager.remove(name);
+        // Remove from skills.json (project mode only, skip for effectively-global installs)
+        if (!effectivelyGlobal && this.config.exists()) this.config.removeSkill(name);
         const successCount = Array.from(results.values()).filter((r)=>r).length;
         logger_logger.success(`Uninstalled ${name} from ${successCount} agent(s)`);
         return results;
@@ -7326,12 +7660,19 @@ const DEFAULT_INSTALL_DIR = '.skills';
 // ============================================================================
 /**
  * Resolve installation scope (global vs project)
- */ async function resolveInstallScope(ctx) {
+ */ async function resolveInstallScope(ctx, targetAgents) {
     const { options, isReinstallAll, skipConfirm } = ctx;
     // Explicit --global flag
     if (void 0 !== options.global) return options.global;
-    // Skip prompt for reinstall-all (always project scope)
+    // Skip prompt for reinstall-all (always project scope).
+    // Must be checked before the claude-cowork-3p override to avoid
+    // "Cannot install all skills globally" when 3p is the only detected agent.
     if (isReinstallAll) return false;
+    // claude-cowork-3p always installs globally — skip prompt
+    if (targetAgents.length > 0 && targetAgents.every((a)=>a === claude_3p_installer_CLAUDE_COWORK_3P_AGENT)) {
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info('Using global scope (claude-cowork-3p is always global)');
+        return true;
+    }
     // Skip prompt if --yes
     if (skipConfirm) return false;
     // Prompt user
@@ -7361,10 +7702,12 @@ const DEFAULT_INSTALL_DIR = '.skills';
 // ============================================================================
 /**
  * Resolve installation mode (symlink vs copy)
- */ async function resolveInstallMode(ctx) {
+ */ async function resolveInstallMode(ctx, targetAgents) {
     const { options, storedMode, isReinstallAll, skipConfirm } = ctx;
     // Priority 1: CLI --mode option
     if (options.mode) return options.mode;
+    // claude-cowork-3p always uses copy mode — skip prompt
+    if (targetAgents.length > 0 && targetAgents.every((a)=>a === claude_3p_installer_CLAUDE_COWORK_3P_AGENT)) return 'copy';
     // Priority 2: Reinstall all with stored mode
     if (isReinstallAll && storedMode) {
         __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info(`Using saved install mode: ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(storedMode)}`);
@@ -7846,14 +8189,14 @@ const DEFAULT_INSTALL_DIR = '.skills';
             // Step 1: Resolve target agents
             targetAgents = await resolveTargetAgents(ctx, spinner);
             // Step 2: Resolve installation scope
-            installGlobally = await resolveInstallScope(ctx);
+            installGlobally = await resolveInstallScope(ctx, targetAgents);
             // Validate: Cannot install all skills globally
             if (ctx.isReinstallAll && installGlobally) {
                 __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.error('Cannot install all skills globally. Please specify a skill to install.');
                 process.exit(1);
             }
             // Step 3: Resolve installation mode
-            installMode = await resolveInstallMode(ctx);
+            installMode = await resolveInstallMode(ctx, targetAgents);
         }
         // Step 4: Execute installation
         if (ctx.isReinstallAll) await installAllSkills(ctx, targetAgents, installMode, spinner);
@@ -7871,14 +8214,23 @@ const DEFAULT_INSTALL_DIR = '.skills';
 });
 /**
  * list command - List installed skills
- */ 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 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').option('-a, --agent <agent>', 'List skills installed to a specific agent').action((options)=>{
+    const agentInput = options.agent;
+    if (void 0 !== agentInput && !isValidAgentType(agentInput)) {
+        logger_logger.error(`Invalid agent: ${agentInput}`);
+        process.exit(1);
+    }
+    const agent = agentInput;
+    // claude-cowork-3p is always global
+    const isGlobal = options.global || agent === claude_3p_installer_CLAUDE_COWORK_3P_AGENT;
     const skillManager = new SkillManager(void 0, {
         global: isGlobal
     });
-    const skills = skillManager.list();
+    const skills = skillManager.list(agent ? {
+        agent
+    } : void 0);
     if (0 === skills.length) {
-        const location = isGlobal ? 'globally' : 'in this project';
+        const location = agent ? `for ${getAgentConfig(agent).displayName}` : isGlobal ? 'globally' : 'in this project';
         logger_logger.info(`No skills installed ${location}`);
         return;
     }
@@ -7886,7 +8238,7 @@ const DEFAULT_INSTALL_DIR = '.skills';
         console.log(JSON.stringify(skills, null, 2));
         return;
     }
-    const scopeLabel = isGlobal ? 'global' : 'project';
+    const scopeLabel = agent ? getAgentConfig(agent).displayName : isGlobal ? 'global' : 'project';
     logger_logger.log(`Installed Skills (${scopeLabel}):`);
     logger_logger.newline();
     const headers = [
@@ -9504,7 +9856,7 @@ async function publishAction(skillPath, options) {
         const validation = validator.validate(absolutePath);
         // 3.5. Content security scan
         const skillMdPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(absolutePath, 'SKILL.md');
-        if (exists(skillMdPath)) {
+        if (fs_exists(skillMdPath)) {
             const scanner = new ContentScanner();
             const scanResult = scanner.scanFile(skillMdPath);
             displayScanFindings(scanResult);