reskill 1.11.0 → 1.11.1

package/dist/cli/index.js

@@ -417,215 +417,6 @@ var external_node_fs_ = __webpack_require__("node:fs");
     if (fullPath.startsWith(currentDir)) return `.${fullPath.slice(currentDir.length)}`;
     return fullPath;
 }
-/**
- * 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;
-}
-/**
- * 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 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;
-}
-/**
- * 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
-    };
-    return {
-        scope: null,
-        name: skillName,
-        fullName: skillName
-    };
-}
-/**
- * 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}`;
-}
-/**
- * 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;
-}
-/**
- * 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}`
-        };
-    }
-    // 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
-    };
-}
 const git_execAsync = (0, __WEBPACK_EXTERNAL_MODULE_node_util__.promisify)(__WEBPACK_EXTERNAL_MODULE_node_child_process__.exec);
 /**
  * Git utilities
@@ -891,6 +682,215 @@ const git_execAsync = (0, __WEBPACK_EXTERNAL_MODULE_node_util__.promisify)(__WEB
     }
     return null;
 }
+/**
+ * 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;
+}
+/**
+ * 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 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;
+}
+/**
+ * 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
+    };
+    return {
+        scope: null,
+        name: skillName,
+        fullName: skillName
+    };
+}
+/**
+ * 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}`;
+}
+/**
+ * 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;
+}
+/**
+ * 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}`
+        };
+    }
+    // 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
  */ /**
@@ -2250,6 +2250,15 @@ ${CURSOR_BRIDGE_MARKER}
     // Registry Management
     // ==========================================================================
     /**
+   * Get all configured registries (custom + default).
+   */ getRegistries() {
+        const config = this.getConfigOrDefault();
+        return {
+            ...DEFAULT_REGISTRIES,
+            ...config.registries
+        };
+    }
+    /**
    * Get registry URL by name
    *
    * Resolution order:
@@ -3091,6 +3100,8 @@ ${CURSOR_BRIDGE_MARKER}
             commit: options.commit,
             installedAt: new Date().toISOString()
         };
+        // Only persist registry URL for registry-sourced skills
+        if (options.registry) lockedSkill.registry = options.registry;
         this.set(name, lockedSkill);
         return lockedSkill;
     }
@@ -4005,8 +4016,11 @@ class RegistryResolver {
    */ async installAll(options = {}) {
         const skills = this.config.getSkills();
         const installed = [];
+        const targetAgents = await detectInstalledAgents();
         for (const [name, ref] of Object.entries(skills))try {
-            const skill = await this.install(ref, {
+            // Use installToAgents (not install) to correctly route registry refs
+            // resolveRegistryUrl inside handles lock file / registries probe fallback
+            const { skill } = await this.installToAgents(ref, targetAgents, {
                 ...options,
                 save: false
             });
@@ -4052,6 +4066,7 @@ class RegistryResolver {
    * Update skill
    */ async update(name) {
         const updated = [];
+        const targetAgents = await detectInstalledAgents();
         if (name) {
             // Update single skill
             const ref = this.config.getSkillRef(name);
@@ -4059,9 +4074,10 @@ class RegistryResolver {
                 logger_logger.error(`Skill ${name} not found in skills.json`);
                 return [];
             }
-            // Check if update is needed (skip check for HTTP sources - always re-download)
-            if (this.isHttpSource(ref)) // For HTTP sources, log that we're re-downloading
-            logger_logger.info(`${name} is from HTTP source, re-downloading...`);
+            // Check if update is needed (skip for HTTP and Registry - always re-download/reinstall)
+            const isRegistry = this.isRegistrySource(ref);
+            if (isRegistry) logger_logger.info(`${name} is from registry, re-installing...`);
+            else if (this.isHttpSource(ref)) logger_logger.info(`${name} is from HTTP source, re-downloading...`);
             else {
                 const resolved = await this.resolver.resolve(ref);
                 const remoteCommit = await this.cache.getRemoteCommit(resolved.repoUrl, resolved.ref);
@@ -4070,7 +4086,7 @@ class RegistryResolver {
                     return [];
                 }
             }
-            const skill = await this.install(ref, {
+            const skill = await this.installForUpdate(ref, targetAgents, {
                 force: true,
                 save: false
             });
@@ -4079,8 +4095,9 @@ class RegistryResolver {
             // Update all
             const skills = this.config.getSkills();
             for (const [skillName, ref] of Object.entries(skills))try {
-                // Check if update is needed (skip check for HTTP sources)
-                if (this.isHttpSource(ref)) logger_logger.info(`${skillName} is from HTTP source, re-downloading...`);
+                // Check if update is needed (skip for HTTP and Registry)
+                if (this.isRegistrySource(ref)) logger_logger.info(`${skillName} is from registry, re-installing...`);
+                else if (this.isHttpSource(ref)) logger_logger.info(`${skillName} is from HTTP source, re-downloading...`);
                 else {
                     const resolved = await this.resolver.resolve(ref);
                     const remoteCommit = await this.cache.getRemoteCommit(resolved.repoUrl, resolved.ref);
@@ -4089,7 +4106,7 @@ class RegistryResolver {
                         continue;
                     }
                 }
-                const skill = await this.install(ref, {
+                const skill = await this.installForUpdate(ref, targetAgents, {
                     force: true,
                     save: false
                 });
@@ -4101,6 +4118,70 @@ class RegistryResolver {
         return updated;
     }
     /**
+   * Resolve registry URL for a skill reference.
+   *
+   * Resolution order:
+   * 1. Explicit CLI override (options.registry)
+   * 2. Scoped skills → getRegistryUrl(scope)
+   * 3. Unscoped skills → lock file registry (O(1), no network)
+   * 4. Unscoped skills → probe skills.json registries (non-git-host, network)
+   * 5. Default → PUBLIC_REGISTRY
+   */ async resolveRegistryUrl(ref, explicitRegistry) {
+        if (explicitRegistry) return explicitRegistry;
+        const parsed = parseSkillIdentifier(ref);
+        if (parsed.scope) return getRegistryUrl(parsed.scope);
+        // Fast path: lock file has registry URL
+        const locked = this.lockManager.get(parsed.name);
+        if (locked?.registry) return locked.registry;
+        // Slow path: probe configured registries (skip git hosts)
+        const registries = this.config.getRegistries();
+        for (const [name, url] of Object.entries(registries))if (!this.isGitHostRegistry(name, url)) try {
+            const client = new RegistryClient({
+                registry: url
+            });
+            await client.getSkillInfo(parsed.fullName);
+            return url; // Found it
+        } catch  {}
+        return getRegistryUrl(null); // PUBLIC_REGISTRY
+    }
+    /**
+   * Check if a registry entry is a git host (github, gitlab, etc.)
+   * Git hosts are not skill registries and should be skipped during probe.
+   */ isGitHostRegistry(name, url) {
+        const gitHostNames = new Set(Object.keys(DEFAULT_REGISTRIES));
+        if (gitHostNames.has(name)) return true;
+        const gitHostPatterns = [
+            'github.com',
+            'gitlab.com'
+        ];
+        const normalizedUrl = url.toLowerCase();
+        return gitHostPatterns.some((pattern)=>normalizedUrl.includes(pattern));
+    }
+    /**
+   * Derive a registry name from a URL for storing in skills.json.registries.
+   * Returns null for git hosts (already in DEFAULT_REGISTRIES).
+   */ deriveRegistryName(registryUrl) {
+        // Skip git hosts
+        if (this.isGitHostRegistry('', registryUrl)) return null;
+        // Try known scope mapping first (e.g., kanyun registries)
+        const scope = getScopeForRegistry(registryUrl);
+        if (scope) return scope;
+        // Use hostname as registry name
+        try {
+            const url = new URL(registryUrl);
+            return url.hostname;
+        } catch  {
+            return null;
+        }
+    }
+    /**
+   * Install skill for update flow. Uses installToAgents so registry refs are
+   * routed correctly (Registry > HTTP > Git).
+   */ async installForUpdate(ref, targetAgents, options) {
+        const { skill } = await this.installToAgents(ref, targetAgents, options);
+        return skill;
+    }
+    /**
    * List installed skills
    *
    * Checks both canonical (.agents/skills/) and legacy (.skills/) locations.
@@ -4367,7 +4448,7 @@ class RegistryResolver {
     /**
    * Install skill from Git to multiple agents
    */ async installToAgentsFromGit(ref, targetAgents, options = {}) {
-        const { save = true, mode = 'symlink' } = options;
+        const { save = true, mode = 'symlink', registryContext } = options;
         // Parse reference
         const resolved = await this.resolver.resolve(ref);
         const { parsed, repoUrl } = resolved;
@@ -4385,7 +4466,8 @@ class RegistryResolver {
         const sourcePath = this.resolveSourcePath(cachePath, parsed);
         // Get the real skill name from SKILL.md in cache
         const metadata = this.getSkillMetadataFromDir(sourcePath);
-        const skillName = metadata?.name ?? fallbackName;
+        // Priority: registryContext name > SKILL.md name > fallback from Git URL
+        const skillName = registryContext?.skillName ?? metadata?.name ?? fallbackName;
         const semanticVersion = metadata?.version ?? gitRef;
         logger_logger["package"](`Installing ${skillName}@${gitRef} to ${targetAgents.length} agent(s)...`);
         // Create Installer with custom installDir from config
@@ -4400,19 +4482,22 @@ class RegistryResolver {
             mode: mode
         });
         // Update lock file (project mode only)
-        if (!this.isGlobal) this.lockManager.lockSkill(skillName, {
-            source: `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? `/${parsed.subPath}` : ''}`,
-            version: semanticVersion,
-            ref: gitRef,
-            resolved: repoUrl,
-            commit: cacheResult.commit
-        });
+        if (!this.isGlobal) {
+            const lockSource = registryContext?.lockSource ?? `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? `/${parsed.subPath}` : ''}`;
+            this.lockManager.lockSkill(skillName, {
+                source: lockSource,
+                version: semanticVersion,
+                ref: gitRef,
+                resolved: repoUrl,
+                commit: cacheResult.commit,
+                registry: registryContext?.registryUrl
+            });
+        }
         // Update skills.json (project mode only)
         if (!this.isGlobal && save) {
             this.config.ensureExists();
-            // Normalize the reference to use registry shorthand if possible
-            const normalizedRef = this.config.normalizeSkillRef(ref);
-            this.config.addSkill(skillName, normalizedRef);
+            const configRef = registryContext?.configRef ?? this.config.normalizeSkillRef(ref);
+            this.config.addSkill(skillName, configRef);
         }
         // Count results
         const successCount = Array.from(results.values()).filter((r)=>r.success).length;
@@ -4435,7 +4520,7 @@ class RegistryResolver {
     /**
    * Install skill from HTTP/OSS to multiple agents
    */ async installToAgentsFromHttp(ref, targetAgents, options = {}) {
-        const { save = true, mode = 'symlink' } = options;
+        const { save = true, mode = 'symlink', registryContext } = options;
         // Parse HTTP reference
         const resolved = await this.httpResolver.resolve(ref);
         const { parsed, repoUrl, httpInfo } = resolved;
@@ -4452,7 +4537,8 @@ class RegistryResolver {
         const sourcePath = this.cache.getCachePath(parsed, version);
         // Get the real skill name from SKILL.md in cache
         const metadata = this.getSkillMetadataFromDir(sourcePath);
-        const skillName = metadata?.name ?? fallbackName;
+        // Priority: registryContext name > SKILL.md name > fallback from URL
+        const skillName = registryContext?.skillName ?? metadata?.name ?? fallbackName;
         const semanticVersion = metadata?.version ?? version;
         logger_logger["package"](`Installing ${skillName}@${version} from ${httpInfo.host} to ${targetAgents.length} agent(s)...`);
         // Create Installer with custom installDir from config
@@ -4467,17 +4553,22 @@ class RegistryResolver {
             mode: mode
         });
         // Update lock file (project mode only)
-        if (!this.isGlobal) this.lockManager.lockSkill(skillName, {
-            source: `http:${httpInfo.host}/${skillName}`,
-            version: semanticVersion,
-            ref: version,
-            resolved: repoUrl,
-            commit: cacheResult.commit
-        });
+        if (!this.isGlobal) {
+            const lockSource = registryContext?.lockSource ?? `http:${httpInfo.host}/${skillName}`;
+            this.lockManager.lockSkill(skillName, {
+                source: lockSource,
+                version: semanticVersion,
+                ref: version,
+                resolved: repoUrl,
+                commit: cacheResult.commit,
+                registry: registryContext?.registryUrl
+            });
+        }
         // Update skills.json (project mode only)
         if (!this.isGlobal && save) {
             this.config.ensureExists();
-            this.config.addSkill(skillName, ref);
+            const configRef = registryContext?.configRef ?? ref;
+            this.config.addSkill(skillName, configRef);
         }
         // Count results
         const successCount = Array.from(results.values()).filter((r)=>r.success).length;
@@ -4508,7 +4599,7 @@ class RegistryResolver {
         const { force = false, save = true, mode = 'symlink' } = options;
         // Parse skill identifier and resolve registry URL once (single source of truth)
         const parsed = parseSkillIdentifier(ref);
-        const registryUrl = options.registry || getRegistryUrl(parsed.scope);
+        const registryUrl = await this.resolveRegistryUrl(ref, options.registry);
         const client = new RegistryClient({
             registry: registryUrl
         });
@@ -4595,13 +4686,22 @@ class RegistryResolver {
                 version,
                 ref: version,
                 resolved: resolvedRegistryUrl,
-                commit: resolved.integrity
+                commit: resolved.integrity,
+                registry: resolvedRegistryUrl
             });
             // 8. Update skills.json (project mode only)
             if (!this.isGlobal && save) {
                 this.config.ensureExists();
                 // Save with full name for registry skills
                 this.config.addSkill(shortName, ref);
+                // Save custom registry to skills.json.registries (for reinstall without lock file)
+                if (options.registry) {
+                    const registryName = this.deriveRegistryName(options.registry);
+                    if (registryName) {
+                        this.config.addRegistry(registryName, options.registry);
+                        this.config.save();
+                    }
+                }
             }
             // 9. Count results and log
             const successCount = Array.from(results.values()).filter((r)=>r.success).length;
@@ -4641,16 +4741,41 @@ class RegistryResolver {
         if (parsed.version && 'latest' !== parsed.version) throw new Error(`Version specifier not supported for web-published skills.\n'${parsed.fullName}' was published via web and does not support versioning.\nUse: reskill install ${parsed.fullName}`);
         if (!source_url) throw new Error(`Missing source_url for web-published skill: ${parsed.fullName}`);
         logger_logger["package"](`Installing ${parsed.fullName} from ${source_type} source...`);
+        // Build registry context so downstream methods use the registry name
+        // instead of deriving from the source URL (e.g., Git repo name)
+        const shortName = getShortName(parsed.fullName);
+        const registryUrl = await this.resolveRegistryUrl(parsed.fullName, options.registry);
+        const registryContext = {
+            skillName: shortName,
+            configRef: parsed.fullName,
+            lockSource: `registry:${parsed.fullName}`,
+            registryUrl
+        };
+        const optionsWithContext = {
+            ...options,
+            registryContext
+        };
+        // Save custom registry to skills.json.registries (for reinstall without lock file)
+        if (!this.isGlobal && options.registry) {
+            const registryName = this.deriveRegistryName(options.registry);
+            if (registryName) {
+                this.config.ensureExists();
+                this.config.load();
+                this.config.addRegistry(registryName, options.registry);
+                this.config.save();
+            }
+        }
         switch(source_type){
             case 'github':
             case 'gitlab':
-                // source_url is a full Git URL (includes ref and path)
-                // Reuse existing Git installation logic
-                return this.installToAgentsFromGit(source_url, targetAgents, options);
+                {
+                    const gitRef = this.buildGitRefForWebPublished(source_type, source_url, skillInfo.skill_path, parsed);
+                    return this.installToAgentsFromGit(gitRef, targetAgents, optionsWithContext);
+                }
             case 'oss_url':
             case 'custom_url':
                 // Direct download URL
-                return this.installToAgentsFromHttp(source_url, targetAgents, options);
+                return this.installToAgentsFromHttp(source_url, targetAgents, optionsWithContext);
             case 'local':
                 // Download tarball via Registry API
                 return this.installFromRegistryLocal(parsed, targetAgents, options);
@@ -4659,13 +4784,36 @@ class RegistryResolver {
         }
     }
     /**
+   * Build a Git ref for web-published github/gitlab skills.
+   *
+   * When `skillPath` is provided (multi-skill repo), constructs a shorthand ref
+   * like `github:owner/repo/skills/my-skill` so that only the sub-directory is
+   * cached and installed.
+   *
+   * Fallback: if `parseGitUrl` fails (non-standard URL), appends `#shortName`
+   * as a skill-name selector. The `#` fragment is extracted by
+   * `GitResolver.parseRef()` as `parsed.skillName`, then matched against
+   * SKILL.md `name` fields via `resolveSourcePath` / `discoverSkillsInDir`.
+   * This differs from the subPath approach (directory-based) but works because
+   * skill names typically match their directory basenames.
+   *
+   * Returns the raw `sourceUrl` when no `skillPath` is available.
+   */ buildGitRefForWebPublished(sourceType, sourceUrl, skillPath, parsed) {
+        if (!skillPath) return sourceUrl;
+        const urlParsed = parseGitUrl(sourceUrl);
+        if (urlParsed) return `${sourceType}:${urlParsed.owner}/${urlParsed.repo}/${skillPath}`;
+        const shortName = getShortName(parsed.fullName);
+        if (shortName) return `${sourceUrl}#${shortName}`;
+        return sourceUrl;
+    }
+    /**
    * Install a skill published via "local folder" mode.
    *
    * Downloads tarball via RegistryClient (handles 302 redirects to signed OSS URLs),
    * then extracts and installs using the same flow as registry source_type.
    */ async installFromRegistryLocal(parsed, targetAgents, options = {}) {
         const { save = true, mode = 'symlink' } = options;
-        const registryUrl = options.registry || getRegistryUrl(parsed.scope);
+        const registryUrl = await this.resolveRegistryUrl(parsed.fullName, options.registry);
         const shortName = getShortName(parsed.fullName);
         const version = 'latest';
         // Download tarball via RegistryClient (handles auth + 302 redirect to signed URL)
@@ -4701,12 +4849,21 @@ class RegistryResolver {
                 version: semanticVersion,
                 ref: version,
                 resolved: registryUrl,
-                commit: ''
+                commit: '',
+                registry: registryUrl
             });
             // Update skills.json (project mode only)
             if (!this.isGlobal && save) {
                 this.config.ensureExists();
                 this.config.addSkill(skillName, parsed.fullName);
+                // Save custom registry to skills.json.registries (for reinstall without lock file)
+                if (options.registry) {
+                    const registryName = this.deriveRegistryName(options.registry);
+                    if (registryName) {
+                        this.config.addRegistry(registryName, options.registry);
+                        this.config.save();
+                    }
+                }
             }
             return {
                 skill: {