skills 1.5.19 → 1.5.21

package/dist/cli.mjs

@@ -10,6 +10,8 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from
 import { basename, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from "path";
 import { fileURLToPath } from "url";
 import { stripVTControlCharacters } from "node:util";
+import { createWriteStream } from "node:fs";
+import { dirname as dirname$1, join as join$1, normalize as normalize$1, resolve as resolve$1, sep as sep$1 } from "node:path";
 import { homedir, platform, tmpdir } from "os";
 import * as readline from "readline";
 import { Writable } from "stream";
@@ -18,11 +20,31 @@ import { execFile, execSync, spawn, spawnSync } from "child_process";
 import { access, chmod, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, realpath, rm, stat, symlink, writeFile } from "fs/promises";
 import { parse } from "yaml";
 import { createHash } from "crypto";
+import { mkdir as mkdir$1, mkdtemp as mkdtemp$1, readFile as readFile$1, rm as rm$1, stat as stat$1, writeFile as writeFile$1 } from "node:fs/promises";
 import { createHash as createHash$1 } from "node:crypto";
-import { gunzipSync, inflateRawSync } from "node:zlib";
+import { crc32, gunzipSync, inflateRawSync } from "node:zlib";
+import { tmpdir as tmpdir$1 } from "node:os";
+import { pipeline } from "node:stream/promises";
+import * as tar from "tar";
 var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const DEFAULT_GITHUB_HOST = "github.com";
+function getGitHubHost() {
+	const configuredHost = process.env.GH_HOST?.trim();
+	if (!configuredHost) return DEFAULT_GITHUB_HOST;
+	try {
+		const parsed = new URL(`https://${configuredHost}`);
+		if (parsed.username || parsed.password || parsed.port || parsed.pathname !== "/" || parsed.search || parsed.hash) return DEFAULT_GITHUB_HOST;
+		return parsed.hostname;
+	} catch {
+		return DEFAULT_GITHUB_HOST;
+	}
+}
+function isGitHubHost(host) {
+	const normalizedHost = host.toLowerCase();
+	return normalizedHost === DEFAULT_GITHUB_HOST || normalizedHost === getGitHubHost().toLowerCase();
+}
 function getOwnerRepo(parsed) {
-	if (parsed.type === "local") return null;
+	if (parsed.type === "local" || parsed.type === "download") return null;
 	const sshMatch = parsed.url.match(/^git@[^:]+:(.+)$/);
 	if (sshMatch) {
 		let path = sshMatch[1];
@@ -88,7 +110,7 @@ function looksLikeGitSource(input) {
 	if (input.startsWith("http://") || input.startsWith("https://")) try {
 		const parsed = new URL(input);
 		const pathname = parsed.pathname;
-		if (parsed.hostname === "github.com") return /^\/[^/]+\/[^/]+(?:\.git)?(?:\/tree\/[^/]+(?:\/.*)?)?\/?$/.test(pathname);
+		if (isGitHubHost(parsed.host)) return /^\/[^/]+\/[^/]+(?:\.git)?(?:\/tree\/[^/]+(?:\/.*)?)?\/?$/.test(pathname);
 		if (parsed.hostname === "gitlab.com") return /^\/.+?\/[^/]+(?:\.git)?(?:\/-\/tree\/[^/]+(?:\/.*)?)?\/?$/.test(pathname);
 	} catch {}
 	if (/^https?:\/\/.+\.git(?:$|[/?])/i.test(input)) return true;
@@ -117,6 +139,18 @@ function appendFragmentRef(input, ref, skillFilter) {
 	if (!ref) return input;
 	return `${input}#${ref}${skillFilter ? `@${skillFilter}` : ""}`;
 }
+function isHostedArtifactUrl(input) {
+	try {
+		const parsed = new URL(input);
+		const host = parsed.hostname.toLowerCase();
+		if (host === "raw.githubusercontent.com" || host === "codeload.github.com" || host === "objects.githubusercontent.com") return true;
+		if (host === "github.com") return /^\/[^/]+\/[^/]+\/(?:archive\/|raw\/|releases\/(?:download\/|latest\/download\/))/.test(parsed.pathname);
+		if (host === "gitlab.com") return /\/-\/(?:archive|raw)\//.test(parsed.pathname);
+		return false;
+	} catch {
+		return false;
+	}
+}
 function parseSource(input) {
 	if (isLocalPath(input)) {
 		const resolvedPath = resolve(input);
@@ -134,6 +168,26 @@ function parseSource(input) {
 	if (githubPrefixMatch) return parseSource(appendFragmentRef(githubPrefixMatch[1], fragmentRef, fragmentSkillFilter));
 	const gitlabPrefixMatch = input.match(/^gitlab:(.+)$/);
 	if (gitlabPrefixMatch) return parseSource(appendFragmentRef(`https://gitlab.com/${gitlabPrefixMatch[1]}`, fragmentRef, fragmentSkillFilter));
+	if (isHostedArtifactUrl(input)) return {
+		type: "download",
+		url: input
+	};
+	if (getGitHubHost() !== "github.com" && /^https?:\/\//.test(input)) try {
+		const parsedUrl = new URL(input);
+		if (isGitHubHost(parsedUrl.host) && parsedUrl.host !== "github.com") {
+			const [owner, rawRepo, marker, ref, ...subpathSegments] = parsedUrl.pathname.split("/").filter(Boolean);
+			if (owner && rawRepo) {
+				const repo = rawRepo.replace(/\.git$/, "");
+				const isTreeUrl = marker === "tree" && ref;
+				return {
+					type: "git",
+					url: `${parsedUrl.protocol}//${parsedUrl.host}/${owner}/${repo}.git`,
+					...isTreeUrl ? { ref } : fragmentRef ? { ref: fragmentRef } : {},
+					...isTreeUrl && subpathSegments.length > 0 ? { subpath: sanitizeSubpath(subpathSegments.join("/")) } : {}
+				};
+			}
+		}
+	} catch {}
 	const githubTreeWithPathMatch = input.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/);
 	if (githubTreeWithPathMatch) {
 		const [, owner, repo, ref, subpath] = githubTreeWithPathMatch;
@@ -190,12 +244,14 @@ function parseSource(input) {
 			...fragmentRef ? { ref: fragmentRef } : {}
 		};
 	}
+	const githubHost = getGitHubHost();
+	const shorthandSourceType = githubHost === "github.com" ? "github" : "git";
 	const atSkillMatch = input.match(/^([^/]+)\/([^/@]+)@(.+)$/);
 	if (atSkillMatch && !input.includes(":") && !input.startsWith(".") && !input.startsWith("/")) {
 		const [, owner, repo, skillFilter] = atSkillMatch;
 		return {
-			type: "github",
-			url: `https://github.com/${owner}/${repo}.git`,
+			type: shorthandSourceType,
+			url: `https://${githubHost}/${owner}/${repo}.git`,
 			...fragmentRef ? { ref: fragmentRef } : {},
 			skillFilter: fragmentSkillFilter || skillFilter
 		};
@@ -204,8 +260,8 @@ function parseSource(input) {
 	if (shorthandMatch && !input.includes(":") && !input.startsWith(".") && !input.startsWith("/")) {
 		const [, owner, repo, subpath] = shorthandMatch;
 		return {
-			type: "github",
-			url: `https://github.com/${owner}/${repo}.git`,
+			type: shorthandSourceType,
+			url: `https://${githubHost}/${owner}/${repo}.git`,
 			...fragmentRef ? { ref: fragmentRef } : {},
 			subpath: subpath ? sanitizeSubpath(subpath) : subpath,
 			...fragmentSkillFilter ? { skillFilter: fragmentSkillFilter } : {}
@@ -573,20 +629,21 @@ var GitCloneError = class extends Error {
 	}
 };
 function parseGitHubRepoUrl(url) {
-	const sshMatch = url.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/i);
-	if (sshMatch) {
-		const owner = sshMatch[1];
-		const repo = sshMatch[2];
+	const sshMatch = url.match(/^git@([^:]+):([^/]+)\/([^/]+?)(?:\.git)?$/i);
+	if (sshMatch && isGitHubHost(sshMatch[1])) {
+		const host = sshMatch[1];
+		const owner = sshMatch[2];
+		const repo = sshMatch[3];
 		return {
 			owner,
 			repo,
 			slug: `${owner}/${repo}`,
-			sshUrl: `git@github.com:${owner}/${repo}.git`
+			sshUrl: `git@${host}:${owner}/${repo}.git`
 		};
 	}
 	try {
 		const parsed = new URL(url);
-		if (parsed.hostname !== "github.com") return null;
+		if (!isGitHubHost(parsed.host)) return null;
 		const match = parsed.pathname.match(/^\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
 		if (!match) return null;
 		const owner = match[1];
@@ -595,7 +652,7 @@ function parseGitHubRepoUrl(url) {
 			owner,
 			repo,
 			slug: `${owner}/${repo}`,
-			sshUrl: `git@github.com:${owner}/${repo}.git`
+			sshUrl: `git@${parsed.host}:${owner}/${repo}.git`
 		};
 	} catch {
 		return null;
@@ -604,7 +661,7 @@ function parseGitHubRepoUrl(url) {
 function isGitHubHttpsCloneUrl(url) {
 	try {
 		const parsed = new URL(url);
-		return parsed.protocol === "https:" && parsed.hostname === "github.com";
+		return parsed.protocol === "https:" && isGitHubHost(parsed.host);
 	} catch {
 		return false;
 	}
@@ -665,12 +722,13 @@ async function resetTempDir(dir) {
 }
 async function tryGhClone(repo, tempDir, ref) {
 	let cloneTarget = repo.slug;
+	const host = repo.sshUrl.match(/^git@([^:]+):/)?.[1] || "github.com";
 	try {
 		const { stdout, stderr } = await execFileAsync("gh", [
 			"auth",
 			"status",
 			"-h",
-			"github.com"
+			host
 		], {
 			timeout: 5e3,
 			env: {
@@ -705,8 +763,9 @@ async function tryGhClone(repo, tempDir, ref) {
 	return true;
 }
 function buildGitHubAuthError(url, repo, message) {
-	if (repo && isGitHubSsoAuthError(message)) return `GitHub blocked HTTPS access to ${url} because the organization enforces SAML SSO.\n  skills tried your existing git credentials and available fallbacks, but none succeeded.\n  - Re-authorize your GitHub credentials/app for that org's SSO policy\n  - Or rerun with SSH: npx skills add ${repo.sshUrl}\n  - Verify access with: gh auth status -h github.com or ssh -T git@github.com`;
-	if (repo) return `Authentication failed for ${url}.\n  - For private repos, ensure you have access\n  - Retry with SSH: npx skills add ${repo.sshUrl}\n  - Check access with: gh auth status -h github.com or ssh -T git@github.com`;
+	const host = repo?.sshUrl.match(/^git@([^:]+):/)?.[1] || "github.com";
+	if (repo && isGitHubSsoAuthError(message)) return `GitHub blocked HTTPS access to ${url} because the organization enforces SAML SSO.\n  skills tried your existing git credentials and available fallbacks, but none succeeded.\n  - Re-authorize your GitHub credentials/app for that org's SSO policy\n  - Or rerun with SSH: npx skills add ${repo.sshUrl}\n  - Verify access with: gh auth status -h ${host} or ssh -T git@${host}`;
+	if (repo) return `Authentication failed for ${url}.\n  - For private repos, ensure you have access\n  - Retry with SSH: npx skills add ${repo.sshUrl}\n  - Check access with: gh auth status -h ${host} or ssh -T git@${host}`;
 	return `Authentication failed for ${url}.\n  - For private repos, ensure you have access\n  - For SSH: Check your keys with 'ssh -T git@github.com'\n  - For HTTPS: Run 'gh auth login' or configure git credentials`;
 }
 async function cloneRepo(url, ref) {
@@ -897,6 +956,13 @@ async function addSkillToLocalLock(skillName, entry, cwd) {
 	lock.skills[skillName] = entry;
 	await writeLocalLock(lock, cwd);
 }
+async function removeSkillFromLocalLock(skillName, cwd) {
+	const lock = await readLocalLock(cwd);
+	if (!(skillName in lock.skills)) return false;
+	delete lock.skills[skillName];
+	await writeLocalLock(lock, cwd);
+	return true;
+}
 function createEmptyLocalLock() {
 	return {
 		version: CURRENT_VERSION$1,
@@ -920,9 +986,11 @@ const AGENT_PROJECT_SKILL_DIRS = [
 	".continue/skills",
 	".github/skills",
 	".goose/skills",
+	".grok/skills",
 	".iflow/skills",
 	".junie/skills",
 	".kilocode/skills",
+	".kimchi/skills",
 	".kiro/skills",
 	".mux/skills",
 	".neovate/skills",
@@ -956,24 +1024,44 @@ async function hasSkillMd(dir) {
 		return false;
 	}
 }
+function warnSkippedSkill(skillMdPath, reason) {
+	console.warn(`⚠ Skipped ${sanitizeMetadata(skillMdPath)} — ${stripTerminalEscapes(reason)}`);
+}
 async function parseSkillMd(skillMdPath, options) {
+	let content;
 	try {
-		const content = await readFile(skillMdPath, "utf-8");
-		const { data } = parseFrontmatter(content);
-		if (!data.name || !data.description) return null;
-		if (typeof data.name !== "string" || typeof data.description !== "string") return null;
-		const metadata = isRecord(data.metadata) ? data.metadata : void 0;
-		if (metadata?.internal === true && !shouldInstallInternalSkills() && !options?.includeInternal) return null;
-		return {
-			name: sanitizeMetadata(data.name),
-			description: sanitizeMetadata(data.description),
-			path: dirname(skillMdPath),
-			rawContent: content,
-			metadata
-		};
-	} catch {
+		content = await readFile(skillMdPath, "utf-8");
+	} catch (err) {
+		warnSkippedSkill(skillMdPath, `failed to read file: ${err.message}`);
+		return null;
+	}
+	let data;
+	try {
+		({data} = parseFrontmatter(content));
+	} catch (err) {
+		warnSkippedSkill(skillMdPath, `YAML parse error: ${err.message}`);
+		return null;
+	}
+	if (!data.name || !data.description) {
+		const missing = [];
+		if (!data.name) missing.push("name");
+		if (!data.description) missing.push("description");
+		warnSkippedSkill(skillMdPath, `missing required frontmatter field(s): ${missing.join(", ")}`);
 		return null;
 	}
+	if (typeof data.name !== "string" || typeof data.description !== "string") {
+		warnSkippedSkill(skillMdPath, `frontmatter "name" and "description" must be strings (got ${typeof data.name} and ${typeof data.description})`);
+		return null;
+	}
+	const metadata = isRecord(data.metadata) ? data.metadata : void 0;
+	if (metadata?.internal === true && !shouldInstallInternalSkills() && !options?.includeInternal) return null;
+	return {
+		name: sanitizeMetadata(data.name),
+		description: sanitizeMetadata(data.description),
+		path: dirname(skillMdPath),
+		rawContent: content,
+		metadata
+	};
 }
 async function findSkillDirs(dir, depth = 0, maxDepth = 5) {
 	if (depth > maxDepth) return [];
@@ -994,6 +1082,7 @@ function isSubpathSafe(basePath, subpath) {
 async function discoverSkills(basePath, subpath, options) {
 	const skills = [];
 	const seenNames = /* @__PURE__ */ new Set();
+	const parsedSkillPaths = /* @__PURE__ */ new Set();
 	const localLock = await readLocalLock(basePath);
 	const lockedSkillNames = new Set(Object.keys(localLock.skills).map(normalizeSkillName));
 	if (subpath && !isSubpathSafe(basePath, subpath)) throw new Error(`Invalid subpath: "${subpath}" resolves outside the repository directory. Subpath must not contain ".." segments that escape the base path.`);
@@ -1012,8 +1101,14 @@ async function discoverSkills(basePath, subpath, options) {
 		const directoryName = normalizeSkillName(basename(skill.path));
 		return lockedSkillNames.has(skillName) || lockedSkillNames.has(directoryName);
 	};
+	const parseSkillAt = async (skillDir) => {
+		const skillMdPath = resolve(skillDir, "SKILL.md");
+		if (parsedSkillPaths.has(skillMdPath)) return null;
+		parsedSkillPaths.add(skillMdPath);
+		return parseSkillMd(skillMdPath, options);
+	};
 	if (await hasSkillMd(searchPath)) {
-		let skill = await parseSkillMd(join(searchPath, "SKILL.md"), options);
+		let skill = await parseSkillAt(searchPath);
 		if (skill) {
 			if (!isInstalledProjectSkill(skill)) {
 				skill = enhanceSkill(skill);
@@ -1035,7 +1130,7 @@ async function discoverSkills(basePath, subpath, options) {
 	prioritySearchDirs.push(...await getPluginSkillPaths(searchPath));
 	const tryAddSkillAt = async (skillDir) => {
 		if (!await hasSkillMd(skillDir)) return false;
-		let skill = await parseSkillMd(join(skillDir, "SKILL.md"), options);
+		let skill = await parseSkillAt(skillDir);
 		if (!skill || seenNames.has(skill.name)) return true;
 		if (isInstalledProjectSkill(skill)) return true;
 		skill = enhanceSkill(skill);
@@ -1065,7 +1160,7 @@ async function discoverSkills(basePath, subpath, options) {
 	if (skills.length === 0 || options?.fullDepth) {
 		const allSkillDirs = await findSkillDirs(searchPath);
 		for (const skillDir of allSkillDirs) {
-			let skill = await parseSkillMd(join(skillDir, "SKILL.md"), options);
+			let skill = await parseSkillAt(skillDir);
 			if (skill && !seenNames.has(skill.name) && !isInstalledProjectSkill(skill)) {
 				skill = enhanceSkill(skill);
 				skills.push(skill);
@@ -1093,6 +1188,7 @@ const claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join(home, ".claude"
 const vibeHome = process.env.VIBE_HOME?.trim() || join(home, ".vibe");
 const hermesHome = process.env.HERMES_HOME?.trim() || join(home, ".hermes");
 const autohandHome = process.env.AUTOHAND_HOME?.trim() || join(home, ".autohand");
+const grokHome = process.env.GROK_HOME?.trim() || join(home, ".grok");
 const zedAppDataHome = process.env.APPDATA?.trim();
 const zedFlatpakConfigHome = process.env.FLATPAK_XDG_CONFIG_HOME?.trim();
 function packageJsonHasDependency(packageJsonPath, dependencyName) {
@@ -1112,6 +1208,9 @@ function getOpenClawGlobalSkillsDir(homeDir = home, pathExists = existsSync) {
 function isZCodeInstalled(homeDir = home, pathExists = existsSync) {
 	return pathExists(join(homeDir, ".zcode")) || pathExists("/Applications/ZCode.app");
 }
+function isKimchiInstalled(homeDir = home, pathExists = existsSync) {
+	return pathExists(join(homeDir, ".config", "kimchi"));
+}
 const agents = {
 	"aider-desk": {
 		name: "aider-desk",
@@ -1395,6 +1494,15 @@ const agents = {
 			return existsSync(join(configHome, "goose"));
 		}
 	},
+	grok: {
+		name: "grok",
+		displayName: "Grok Build",
+		skillsDir: ".grok/skills",
+		globalSkillsDir: join(grokHome, "skills"),
+		detectInstalled: async () => {
+			return existsSync(grokHome);
+		}
+	},
 	"hermes-agent": {
 		name: "hermes-agent",
 		displayName: "Hermes Agent",
@@ -1449,6 +1557,15 @@ const agents = {
 			return existsSync(join(home, ".kilocode"));
 		}
 	},
+	kimchi: {
+		name: "kimchi",
+		displayName: "Kimchi",
+		skillsDir: ".kimchi/skills",
+		globalSkillsDir: join(home, ".config", "kimchi", "harness", "skills"),
+		detectInstalled: async () => {
+			return isKimchiInstalled();
+		}
+	},
 	"kimi-code-cli": {
 		name: "kimi-code-cli",
 		displayName: "Kimi Code CLI",
@@ -1809,13 +1926,13 @@ const SKILLS_SUBDIR = "skills";
 function sanitizeName(name) {
 	return name.toLowerCase().replace(/[^a-z0-9._]+/g, "-").replace(/^[.\-]+|[.\-]+$/g, "").substring(0, 255) || "unnamed-skill";
 }
-function isPathSafe$1(basePath, targetPath) {
+function isPathSafe$2(basePath, targetPath) {
 	const normalizedBase = normalize(resolve(basePath));
 	const normalizedTarget = normalize(resolve(targetPath));
 	return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
 }
 function pathsOverlap(pathA, pathB) {
-	return isPathSafe$1(pathA, pathB) || isPathSafe$1(pathB, pathA);
+	return isPathSafe$2(pathA, pathB) || isPathSafe$2(pathB, pathA);
 }
 async function isDirEntryOrSymlinkToDir(entry, entryPath) {
 	if (entry.isDirectory()) return true;
@@ -1909,13 +2026,13 @@ async function installSkillForAgent(skill, agentType, options = {}) {
 	const canonicalDir = join(canonicalBase, skillName);
 	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd, eveSubagent);
 	const agentDir = join(agentBase, skillName);
-	if (!isPathSafe$1(canonicalBase, canonicalDir)) return {
+	if (!isPathSafe$2(canonicalBase, canonicalDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
-	if (!isPathSafe$1(agentBase, agentDir)) return {
+	if (!isPathSafe$2(agentBase, agentDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
@@ -2052,7 +2169,7 @@ async function isSkillInstalled(skillName, agentType, options = {}) {
 	if (options.global && agent.globalSkillsDir === void 0) return false;
 	const targetBase = options.global ? agent.globalSkillsDir : agentType === "eve" && options.eveSubagent ? getEveSubagentSkillsDir(options.eveSubagent, options.cwd) : join(options.cwd || process.cwd(), agent.skillsDir);
 	const skillDir = join(targetBase, sanitized);
-	if (!isPathSafe$1(targetBase, skillDir)) return false;
+	if (!isPathSafe$2(targetBase, skillDir)) return false;
 	try {
 		await access(skillDir);
 		return true;
@@ -2066,14 +2183,14 @@ function getInstallPath(skillName, agentType, options = {}) {
 	const sanitized = sanitizeName(skillName);
 	const targetBase = getAgentBaseDir(agentType, options.global ?? false, options.cwd, options.eveSubagent);
 	const installPath = join(targetBase, sanitized);
-	if (!isPathSafe$1(targetBase, installPath)) throw new Error("Invalid skill name: potential path traversal detected");
+	if (!isPathSafe$2(targetBase, installPath)) throw new Error("Invalid skill name: potential path traversal detected");
 	return installPath;
 }
 function getCanonicalPath(skillName, options = {}) {
 	const sanitized = sanitizeName(skillName);
 	const canonicalBase = options.agent === "eve" ? getAgentBaseDir("eve", options.global ?? false, options.cwd, options.eveSubagent) : getCanonicalSkillsDir(options.global ?? false, options.cwd);
 	const canonicalPath = join(canonicalBase, sanitized);
-	if (!isPathSafe$1(canonicalBase, canonicalPath)) throw new Error("Invalid skill name: potential path traversal detected");
+	if (!isPathSafe$2(canonicalBase, canonicalPath)) throw new Error("Invalid skill name: potential path traversal detected");
 	return canonicalPath;
 }
 async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
@@ -2093,13 +2210,13 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 	const canonicalDir = join(canonicalBase, skillName);
 	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd, eveSubagent);
 	const agentDir = join(agentBase, skillName);
-	if (!isPathSafe$1(canonicalBase, canonicalDir)) return {
+	if (!isPathSafe$2(canonicalBase, canonicalDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
-	if (!isPathSafe$1(agentBase, agentDir)) return {
+	if (!isPathSafe$2(agentBase, agentDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
@@ -2108,7 +2225,7 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 	async function writeSkillFiles(targetDir) {
 		for (const [filePath, content] of skill.files) {
 			const fullPath = join(targetDir, filePath);
-			if (!isPathSafe$1(targetDir, fullPath)) continue;
+			if (!isPathSafe$2(targetDir, fullPath)) continue;
 			const parentDir = dirname(fullPath);
 			if (parentDir !== targetDir) await mkdir(parentDir, { recursive: true });
 			await writeFile(fullPath, agentType === "eve" && basename(filePath).toLowerCase() === "skill.md" && typeof content === "string" ? stripIgnoredEveFrontmatter(content) : content);
@@ -2174,7 +2291,7 @@ async function installBlobSkillForAgent(skill, agentType, options = {}) {
 	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd, eveSubagent);
 	if (agentType === "eve" && !isEvePackagedSkill(skill.files)) {
 		const flatSkillPath = join(agentBase, toEveFlatSkillFileName(skill.installName));
-		if (!isPathSafe$1(agentBase, flatSkillPath)) return {
+		if (!isPathSafe$2(agentBase, flatSkillPath)) return {
 			success: false,
 			path: flatSkillPath,
 			mode: installMode,
@@ -2204,13 +2321,13 @@ async function installBlobSkillForAgent(skill, agentType, options = {}) {
 	const canonicalBase = agentType === "eve" && installMode === "symlink" ? getAgentBaseDir(agentType, isGlobal, cwd, eveSubagent) : getCanonicalSkillsDir(isGlobal, cwd);
 	const canonicalDir = join(canonicalBase, skillName);
 	const agentDir = join(agentBase, skillName);
-	if (!isPathSafe$1(canonicalBase, canonicalDir)) return {
+	if (!isPathSafe$2(canonicalBase, canonicalDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
-	if (!isPathSafe$1(agentBase, agentDir)) return {
+	if (!isPathSafe$2(agentBase, agentDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
@@ -2219,7 +2336,7 @@ async function installBlobSkillForAgent(skill, agentType, options = {}) {
 	async function writeSkillFiles(targetDir) {
 		for (const file of skill.files) {
 			const fullPath = join(targetDir, file.path);
-			if (!isPathSafe$1(targetDir, fullPath)) continue;
+			if (!isPathSafe$2(targetDir, fullPath)) continue;
 			const parentDir = dirname(fullPath);
 			if (parentDir !== targetDir) await mkdir(parentDir, { recursive: true });
 			await writeFile(fullPath, agentType === "eve" && basename(file.path).toLowerCase() === "skill.md" ? stripIgnoredEveFrontmatter(file.contents) : file.contents, "utf-8");
@@ -2244,7 +2361,7 @@ async function installBlobSkillForAgent(skill, agentType, options = {}) {
 			mode: "symlink"
 		};
 		if (!isGlobal && !isUniversalAgent(agentType)) {
-			if (!existsSync(join(cwd, agents[agentType].skillsDir.split("/")[0]))) return {
+			if (!existsSync(join(cwd, agents[agentType].skillsDir.split("/")[0])) && agentType !== "claude-code") return {
 				success: true,
 				path: canonicalDir,
 				canonicalPath: canonicalDir,
@@ -2368,7 +2485,7 @@ async function listInstalledSkills(options = {}) {
 				]));
 				for (const possibleName of possibleNames) {
 					const agentSkillDir = join(agentBase, possibleName);
-					if (!isPathSafe$1(agentBase, agentSkillDir)) continue;
+					if (!isPathSafe$2(agentBase, agentSkillDir)) continue;
 					try {
 						await access(agentSkillDir);
 						found = true;
@@ -2380,7 +2497,7 @@ async function listInstalledSkills(options = {}) {
 					for (const agentEntry of agentEntries) {
 						const candidateDir = join(agentBase, agentEntry.name);
 						if (!await isDirEntryOrSymlinkToDir(agentEntry, candidateDir)) continue;
-						if (!isPathSafe$1(agentBase, candidateDir)) continue;
+						if (!isPathSafe$2(agentBase, candidateDir)) continue;
 						try {
 							const candidateSkillMd = join(candidateDir, "SKILL.md");
 							await stat(candidateSkillMd);
@@ -2520,9 +2637,220 @@ var ProviderRegistryImpl = class {
 	}
 };
 new ProviderRegistryImpl();
+const ZIP_LOCAL_FILE_HEADER = 67324752;
+const ZIP_CENTRAL_DIRECTORY_HEADER = 33639248;
+const ZIP_END_OF_CENTRAL_DIRECTORY = 101010256;
+const ZIP64_END_OF_CENTRAL_DIRECTORY = 101075792;
+const ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR = 117853008;
+const ZIP_END_MIN_SIZE = 22;
+const ZIP_MAX_COMMENT_SIZE = 65535;
+const CP437_HIGH_BYTES = [
+	"ÇüéâäàåçêëèïîìÄÅ",
+	"ÉæÆôöòûùÿÖÜ¢£¥₧ƒ",
+	"áíóúñѪº¿⌐¬½¼¡«»",
+	"░▒▓│┤╡╢╖╕╣║╗╝╜╛┐",
+	"└┴┬├─┼╞╟╚╔╩╦╠═╬╧",
+	"╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀",
+	"αßΓπΣσµτΦΘΩδ∞φε∩",
+	"≡±≥≤⌠⌡÷≈°∙·√ⁿ²■\xA0"
+].join("");
+var ArchiveValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ArchiveValidationError";
+	}
+};
+function ensureRange(buffer, offset, length, label) {
+	if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset + length > buffer.length) throw new Error(`Invalid zip archive: ${label} is out of bounds`);
+}
+function findEndOfCentralDirectory(buffer) {
+	const minOffset = Math.max(0, buffer.length - ZIP_MAX_COMMENT_SIZE - ZIP_END_MIN_SIZE);
+	for (let offset = buffer.length - ZIP_END_MIN_SIZE; offset >= minOffset; offset--) {
+		if (buffer.readUInt32LE(offset) !== ZIP_END_OF_CENTRAL_DIRECTORY) continue;
+		const commentLength = buffer.readUInt16LE(offset + 20);
+		if (offset + ZIP_END_MIN_SIZE + commentLength === buffer.length) return offset;
+	}
+	return -1;
+}
+function readUInt64AsNumber(buffer, offset, label) {
+	ensureRange(buffer, offset, 8, label);
+	const value = buffer.readBigUInt64LE(offset);
+	if (value > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error(`Invalid zip archive: ${label} exceeds the safe integer range`);
+	return Number(value);
+}
+function readCentralDirectory(buffer, endOffset) {
+	const diskNumber = buffer.readUInt16LE(endOffset + 4);
+	const centralDirectoryDisk = buffer.readUInt16LE(endOffset + 6);
+	const entriesOnDisk = buffer.readUInt16LE(endOffset + 8);
+	const totalEntries = buffer.readUInt16LE(endOffset + 10);
+	const size = buffer.readUInt32LE(endOffset + 12);
+	const offset = buffer.readUInt32LE(endOffset + 16);
+	if (!(entriesOnDisk === 65535 || totalEntries === 65535 || size === 4294967295 || offset === 4294967295)) {
+		if (diskNumber !== 0 || centralDirectoryDisk !== 0 || entriesOnDisk !== totalEntries) throw new Error("Multi-disk zip archives are not supported");
+		return {
+			entries: totalEntries,
+			offset,
+			size,
+			trailerOffset: endOffset
+		};
+	}
+	if (diskNumber !== 0 || centralDirectoryDisk !== 0) throw new Error("Multi-disk zip archives are not supported");
+	const locatorOffset = endOffset - 20;
+	ensureRange(buffer, locatorOffset, 20, "zip64 locator");
+	if (buffer.readUInt32LE(locatorOffset) !== ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR) throw new Error("Invalid zip64 locator");
+	if (buffer.readUInt32LE(locatorOffset + 4) !== 0 || buffer.readUInt32LE(locatorOffset + 16) !== 1) throw new Error("Multi-disk zip archives are not supported");
+	const zip64EndOffset = readUInt64AsNumber(buffer, locatorOffset + 8, "zip64 end offset");
+	ensureRange(buffer, zip64EndOffset, 56, "zip64 end of central directory");
+	if (buffer.readUInt32LE(zip64EndOffset) !== ZIP64_END_OF_CENTRAL_DIRECTORY) throw new Error("Invalid zip64 end of central directory");
+	const recordSize = readUInt64AsNumber(buffer, zip64EndOffset + 4, "zip64 end size");
+	if (recordSize < 44) throw new Error("Invalid zip64 end of central directory");
+	ensureRange(buffer, zip64EndOffset, recordSize + 12, "zip64 end of central directory");
+	if (zip64EndOffset + recordSize + 12 !== locatorOffset) throw new Error("Invalid zip64 end of central directory");
+	if (buffer.readUInt32LE(zip64EndOffset + 16) !== 0 || buffer.readUInt32LE(zip64EndOffset + 20) !== 0) throw new Error("Multi-disk zip archives are not supported");
+	const zip64EntriesOnDisk = readUInt64AsNumber(buffer, zip64EndOffset + 24, "zip64 entries on disk");
+	const zip64TotalEntries = readUInt64AsNumber(buffer, zip64EndOffset + 32, "zip64 total entries");
+	if (zip64EntriesOnDisk !== zip64TotalEntries) throw new Error("Multi-disk zip archives are not supported");
+	return {
+		entries: zip64TotalEntries,
+		size: readUInt64AsNumber(buffer, zip64EndOffset + 40, "zip64 central directory size"),
+		offset: readUInt64AsNumber(buffer, zip64EndOffset + 48, "zip64 central directory offset"),
+		trailerOffset: zip64EndOffset
+	};
+}
+function normalizeArchivePath(rawPath) {
+	if (!rawPath || rawPath.includes("\0")) return null;
+	const path = rawPath.replace(/\\/g, "/");
+	if (path.startsWith("/") || /^[A-Za-z]:/.test(path)) return null;
+	const parts = path.split("/");
+	if (parts.some((part) => part === "..")) return null;
+	const normalized = parts.filter((part) => part && part !== ".").join("/");
+	if (!normalized && !path.endsWith("/")) return null;
+	return path.endsWith("/") && normalized ? `${normalized}/` : normalized;
+}
+function findExtraField(buffer, extraOffset, extraLength, targetId) {
+	const extraEnd = extraOffset + extraLength;
+	let offset = extraOffset;
+	while (offset < extraEnd) {
+		if (offset + 4 > extraEnd) throw new Error("Invalid zip extra field");
+		const id = buffer.readUInt16LE(offset);
+		const size = buffer.readUInt16LE(offset + 2);
+		const dataOffset = offset + 4;
+		ensureRange(buffer, dataOffset, size, "zip extra field");
+		if (dataOffset + size > extraEnd) throw new Error("Invalid zip extra field");
+		if (id === targetId) return buffer.subarray(dataOffset, dataOffset + size);
+		offset = dataOffset + size;
+	}
+	return null;
+}
+function decodeFileName(bytes, isUtf8, unicodePathExtra) {
+	if (isUtf8) return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	if (unicodePathExtra && unicodePathExtra.length >= 5 && unicodePathExtra[0] === 1 && unicodePathExtra.readUInt32LE(1) === crc32(bytes)) return new TextDecoder("utf-8", { fatal: true }).decode(unicodePathExtra.subarray(5));
+	let result = "";
+	for (const byte of bytes) result += byte < 128 ? String.fromCharCode(byte) : CP437_HIGH_BYTES[byte - 128];
+	return result;
+}
+function readZip64EntryValues(buffer, extraOffset, extraLength, values) {
+	if (!(values.uncompressedSize === 4294967295 || values.compressedSize === 4294967295 || values.localHeaderOffset === 4294967295 || values.diskStart === 65535)) {
+		if (values.diskStart !== 0) throw new Error("Multi-disk zip archives are not supported");
+		return values;
+	}
+	const zip64Extra = findExtraField(buffer, extraOffset, extraLength, 1);
+	if (!zip64Extra) throw new Error("Invalid zip64 extra field");
+	let valueOffset = 0;
+	const readNextUInt64 = (label) => {
+		if (valueOffset + 8 > zip64Extra.length) throw new Error(`Invalid zip64 extra field: missing ${label}`);
+		const value = readUInt64AsNumber(zip64Extra, valueOffset, `zip64 ${label}`);
+		valueOffset += 8;
+		return value;
+	};
+	const resolved = { ...values };
+	if (resolved.uncompressedSize === 4294967295) resolved.uncompressedSize = readNextUInt64("uncompressed size");
+	if (resolved.compressedSize === 4294967295) resolved.compressedSize = readNextUInt64("compressed size");
+	if (resolved.localHeaderOffset === 4294967295) resolved.localHeaderOffset = readNextUInt64("local header offset");
+	if (resolved.diskStart === 65535) {
+		if (valueOffset + 4 > zip64Extra.length) throw new Error("Invalid zip64 extra field: missing disk start");
+		resolved.diskStart = zip64Extra.readUInt32LE(valueOffset);
+	}
+	if (resolved.diskStart !== 0) throw new Error("Multi-disk zip archives are not supported");
+	return resolved;
+}
+function readZipArchive(bytes, limits) {
+	const buffer = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const endOffset = findEndOfCentralDirectory(buffer);
+	if (endOffset < 0) throw new Error("Invalid zip archive");
+	const centralDirectory = readCentralDirectory(buffer, endOffset);
+	const totalEntries = centralDirectory.entries;
+	if (totalEntries > limits.maxEntries) throw new ArchiveValidationError(`Archive contains too many files (${totalEntries}). Maximum is ${limits.maxEntries}.`);
+	ensureRange(buffer, centralDirectory.offset, centralDirectory.size, "central directory");
+	if (centralDirectory.offset + centralDirectory.size > centralDirectory.trailerOffset) throw new Error("Invalid zip archive: central directory overlaps archive trailer");
+	const files = /* @__PURE__ */ new Map();
+	let extractedBytes = 0;
+	let offset = centralDirectory.offset;
+	for (let index = 0; index < totalEntries; index++) {
+		ensureRange(buffer, offset, 46, "central directory entry");
+		if (buffer.readUInt32LE(offset) !== ZIP_CENTRAL_DIRECTORY_HEADER) throw new Error("Invalid zip central directory entry");
+		const flags = buffer.readUInt16LE(offset + 8);
+		const method = buffer.readUInt16LE(offset + 10);
+		const expectedChecksum = buffer.readUInt32LE(offset + 16);
+		let compressedSize = buffer.readUInt32LE(offset + 20);
+		let uncompressedSize = buffer.readUInt32LE(offset + 24);
+		const fileNameLength = buffer.readUInt16LE(offset + 28);
+		const extraLength = buffer.readUInt16LE(offset + 30);
+		const commentLength = buffer.readUInt16LE(offset + 32);
+		let diskStart = buffer.readUInt16LE(offset + 34);
+		const externalAttributes = buffer.readUInt32LE(offset + 38);
+		let localHeaderOffset = buffer.readUInt32LE(offset + 42);
+		const variableSize = fileNameLength + extraLength + commentLength;
+		ensureRange(buffer, offset + 46, variableSize, "central directory entry data");
+		const nameStart = offset + 46;
+		const extraOffset = nameStart + fileNameLength;
+		({compressedSize, diskStart, localHeaderOffset, uncompressedSize} = readZip64EntryValues(buffer, extraOffset, extraLength, {
+			compressedSize,
+			diskStart,
+			localHeaderOffset,
+			uncompressedSize
+		}));
+		const centralFileName = buffer.subarray(nameStart, nameStart + fileNameLength);
+		const rawFileName = decodeFileName(centralFileName, Boolean(flags & 2048), findExtraField(buffer, extraOffset, extraLength, 28789));
+		const fileName = normalizeArchivePath(rawFileName);
+		if (fileName === null) throw new ArchiveValidationError(`Archive contains unsafe path: ${rawFileName}`);
+		if (flags & 1) throw new ArchiveValidationError("Encrypted zip entries are not supported");
+		const fileType = externalAttributes >>> 16 & 61440;
+		if (fileType !== 0 && fileType !== 32768 && fileType !== 16384) throw new ArchiveValidationError("Archive links are not supported");
+		const isDirectory = rawFileName.replace(/\\/g, "/").endsWith("/") || fileType === 16384;
+		offset += 46 + variableSize;
+		extractedBytes += uncompressedSize;
+		if (extractedBytes > limits.maxExtractedBytes) throw new ArchiveValidationError(`Archive extracts to more than ${limits.maxExtractedBytes} bytes.`);
+		if (isDirectory) continue;
+		ensureRange(buffer, localHeaderOffset, 30, "local file header");
+		if (buffer.readUInt32LE(localHeaderOffset) !== ZIP_LOCAL_FILE_HEADER) throw new Error("Invalid zip local file header");
+		const localFlags = buffer.readUInt16LE(localHeaderOffset + 6);
+		const localMethod = buffer.readUInt16LE(localHeaderOffset + 8);
+		const localFileNameLength = buffer.readUInt16LE(localHeaderOffset + 26);
+		const localExtraLength = buffer.readUInt16LE(localHeaderOffset + 28);
+		const localNameOffset = localHeaderOffset + 30;
+		ensureRange(buffer, localNameOffset, localFileNameLength + localExtraLength, "local file header data");
+		const localFileName = buffer.subarray(localNameOffset, localNameOffset + localFileNameLength);
+		if (localFlags !== flags || localMethod !== method || !localFileName.equals(centralFileName)) throw new Error("Zip local header does not match central directory");
+		const dataOffset = localHeaderOffset + 30 + localFileNameLength + localExtraLength;
+		ensureRange(buffer, dataOffset, compressedSize, "file data");
+		if (dataOffset + compressedSize > centralDirectory.offset) throw new Error("Invalid zip archive: file data overlaps central directory");
+		const compressed = buffer.subarray(dataOffset, dataOffset + compressedSize);
+		let contents;
+		if (method === 0) contents = compressed;
+		else if (method === 8) contents = inflateRawSync(compressed, { maxOutputLength: uncompressedSize + 1 });
+		else throw new Error(`Unsupported zip compression method: ${method}`);
+		if (contents.byteLength !== uncompressedSize) throw new Error("Zip entry size mismatch");
+		if (crc32(contents) !== expectedChecksum) throw new Error("Zip entry checksum mismatch");
+		files.set(fileName, new Uint8Array(contents));
+	}
+	if (offset !== centralDirectory.offset + centralDirectory.size) throw new Error("Invalid zip central directory size");
+	return files;
+}
 const DISCOVERY_SCHEMA_V2 = "https://schemas.agentskills.io/discovery/0.2.0/schema.json";
 const MAX_ARCHIVE_UNPACKED_BYTES = 50 * 1024 * 1024;
 const MAX_ARCHIVE_FILES = 1e3;
+const DISCOVERY_TIMEOUT_MS = 1e4;
 var WellKnownProvider = class {
 	id = "well-known";
 	displayName = "Well-Known Skills";
@@ -2552,6 +2880,7 @@ var WellKnownProvider = class {
 		try {
 			const parsed = new URL(baseUrl);
 			const basePath = parsed.pathname.replace(/\/$/, "");
+			const signal = AbortSignal.timeout(DISCOVERY_TIMEOUT_MS);
 			const urlsToTry = [];
 			for (const wellKnownPath of this.WELL_KNOWN_PATHS) {
 				urlsToTry.push({
@@ -2567,7 +2896,7 @@ var WellKnownProvider = class {
 			}
 			const candidates = [];
 			for (const { indexUrl, baseUrl: resolvedBase, wellKnownPath } of urlsToTry) try {
-				const response = await fetch(indexUrl);
+				const response = await fetch(indexUrl, { signal });
 				if (!response.ok) continue;
 				const rawIndex = await response.json();
 				const normalized = this.normalizeIndex(rawIndex, indexUrl, wellKnownPath);
@@ -2834,7 +3163,10 @@ var WellKnownProvider = class {
 		return `sha256:${createHash$1("sha256").update(bytes).digest("hex")}`;
 	}
 	extractArchive(bytes, artifactUrl, contentType) {
-		if (this.isZipArchive(bytes, artifactUrl, contentType)) return this.extractZip(bytes);
+		if (this.isZipArchive(bytes, artifactUrl, contentType)) return new Map(readZipArchive(bytes, {
+			maxExtractedBytes: MAX_ARCHIVE_UNPACKED_BYTES,
+			maxEntries: MAX_ARCHIVE_FILES
+		}));
 		if (this.isTarGzArchive(bytes, artifactUrl, contentType)) return this.extractTarGz(bytes);
 		throw new Error("Unsupported archive format");
 	}
@@ -2894,54 +3226,6 @@ var WellKnownProvider = class {
 		const nul = slice.indexOf(0);
 		return new TextDecoder().decode(nul >= 0 ? slice.subarray(0, nul) : slice);
 	}
-	extractZip(bytes) {
-		const buffer = Buffer.from(bytes);
-		const eocdOffset = this.findZipEndOfCentralDirectory(buffer);
-		if (eocdOffset < 0) throw new Error("Invalid zip archive");
-		const totalEntries = buffer.readUInt16LE(eocdOffset + 10);
-		const centralDirectoryOffset = buffer.readUInt32LE(eocdOffset + 16);
-		const files = /* @__PURE__ */ new Map();
-		const runningTotal = { bytes: 0 };
-		let offset = centralDirectoryOffset;
-		for (let i = 0; i < totalEntries; i++) {
-			if (buffer.readUInt32LE(offset) !== 33639248) throw new Error("Invalid zip directory");
-			const flags = buffer.readUInt16LE(offset + 8);
-			const method = buffer.readUInt16LE(offset + 10);
-			const compressedSize = buffer.readUInt32LE(offset + 20);
-			const uncompressedSize = buffer.readUInt32LE(offset + 24);
-			const fileNameLength = buffer.readUInt16LE(offset + 28);
-			const extraLength = buffer.readUInt16LE(offset + 30);
-			const commentLength = buffer.readUInt16LE(offset + 32);
-			const externalAttributes = buffer.readUInt32LE(offset + 38);
-			const localHeaderOffset = buffer.readUInt32LE(offset + 42);
-			const nameStart = offset + 46;
-			const rawName = buffer.subarray(nameStart, nameStart + fileNameLength);
-			const fileName = new TextDecoder(flags & 2048 ? "utf-8" : void 0).decode(rawName);
-			offset = nameStart + fileNameLength + extraLength + commentLength;
-			if (fileName.endsWith("/")) continue;
-			if (flags & 1) throw new Error("Encrypted zip entries are not supported");
-			const fileType = externalAttributes >>> 16 & 61440;
-			if (fileType === 40960 || fileType === 4096) throw new Error("Archive links are not supported");
-			if (buffer.readUInt32LE(localHeaderOffset) !== 67324752) throw new Error("Invalid zip local header");
-			const localFileNameLength = buffer.readUInt16LE(localHeaderOffset + 26);
-			const localExtraLength = buffer.readUInt16LE(localHeaderOffset + 28);
-			const dataStart = localHeaderOffset + 30 + localFileNameLength + localExtraLength;
-			const compressed = buffer.subarray(dataStart, dataStart + compressedSize);
-			let content;
-			if (method === 0) content = compressed;
-			else if (method === 8) content = inflateRawSync(compressed);
-			else throw new Error(`Unsupported zip compression method: ${method}`);
-			if (content.byteLength !== uncompressedSize) throw new Error("Zip entry size mismatch");
-			this.addArchiveFile(files, fileName, new Uint8Array(content), runningTotal);
-		}
-		if (!files.has("SKILL.md")) throw new Error("Archive missing root SKILL.md");
-		return files;
-	}
-	findZipEndOfCentralDirectory(buffer) {
-		const minOffset = Math.max(0, buffer.length - 65535 - 22);
-		for (let offset = buffer.length - 22; offset >= minOffset; offset--) if (buffer.readUInt32LE(offset) === 101010256) return offset;
-		return -1;
-	}
 	toRawUrl(url) {
 		try {
 			const parsed = new URL(url);
@@ -2970,6 +3254,187 @@ var WellKnownProvider = class {
 	}
 };
 const wellKnownProvider = new WellKnownProvider();
+const DEFAULT_DOWNLOAD_MAX_BYTES = 10 * 1024 * 1024;
+const DEFAULT_EXTRACT_MAX_BYTES = 25 * 1024 * 1024;
+const DEFAULT_EXTRACT_MAX_FILES = 1e3;
+const FETCH_TIMEOUT_MS = 3e4;
+function getPositiveIntegerEnv(name, fallback) {
+	const raw = process.env[name];
+	if (!raw) return fallback;
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function getDownloadLimits() {
+	return {
+		downloadMaxBytes: getPositiveIntegerEnv("SKILLS_DOWNLOAD_MAX_BYTES", DEFAULT_DOWNLOAD_MAX_BYTES),
+		extractMaxBytes: getPositiveIntegerEnv("SKILLS_EXTRACT_MAX_BYTES", DEFAULT_EXTRACT_MAX_BYTES),
+		extractMaxFiles: getPositiveIntegerEnv("SKILLS_EXTRACT_MAX_FILES", DEFAULT_EXTRACT_MAX_FILES)
+	};
+}
+function isPathSafe$1(basePath, targetPath) {
+	const normalizedBase = normalize$1(resolve$1(basePath));
+	const normalizedTarget = normalize$1(resolve$1(targetPath));
+	return normalizedTarget.startsWith(normalizedBase + sep$1) || normalizedTarget === normalizedBase;
+}
+function validateArchivePath(path) {
+	const normalized = path.replace(/\\/g, "/").replace(/^\.\//, "");
+	if (!normalized || normalized.endsWith("/")) return normalized;
+	if (normalized.startsWith("/") || /^[a-zA-Z]:\//.test(normalized)) return null;
+	if (normalized.split("/").includes("..")) return null;
+	return normalized;
+}
+function incrementEntry(state, size, limits) {
+	state.entries += 1;
+	if (state.entries > limits.extractMaxFiles) throw new ArchiveValidationError(`Archive contains too many files (${state.entries}). Maximum is ${limits.extractMaxFiles}. Set SKILLS_EXTRACT_MAX_FILES to override.`);
+	state.bytes += size;
+	if (state.bytes > limits.extractMaxBytes) throw new ArchiveValidationError(`Archive extracts to more than ${limits.extractMaxBytes} bytes. Set SKILLS_EXTRACT_MAX_BYTES to override.`);
+}
+async function downloadToFile(url, targetFile, limits) {
+	const response = await fetch(url, {
+		signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+		redirect: "follow"
+	});
+	if (!response.ok) throw new Error(`Download failed with HTTP ${response.status}`);
+	const contentLength = response.headers.get("content-length");
+	if (contentLength) {
+		const parsed = Number.parseInt(contentLength, 10);
+		if (Number.isFinite(parsed) && parsed > limits.downloadMaxBytes) throw new Error(`Download is larger than ${limits.downloadMaxBytes} bytes. Set SKILLS_DOWNLOAD_MAX_BYTES to override.`);
+	}
+	if (!response.body) throw new Error("Download response has no body");
+	let downloaded = 0;
+	const limitStream = new TransformStream({ transform(chunk, controller) {
+		downloaded += chunk.byteLength;
+		if (downloaded > limits.downloadMaxBytes) throw new Error(`Download is larger than ${limits.downloadMaxBytes} bytes. Set SKILLS_DOWNLOAD_MAX_BYTES to override.`);
+		controller.enqueue(chunk);
+	} });
+	await pipeline(response.body.pipeThrough(limitStream), createWriteStream(targetFile));
+}
+async function isValidSkillMarkdown(filePath) {
+	try {
+		const { data } = parseFrontmatter(await readFile$1(filePath, "utf-8"));
+		return typeof data.name === "string" && typeof data.description === "string";
+	} catch {
+		return false;
+	}
+}
+async function extractZip(filePath, extractDir, limits) {
+	const files = readZipArchive(await readFile$1(filePath), {
+		maxExtractedBytes: limits.extractMaxBytes,
+		maxEntries: limits.extractMaxFiles
+	});
+	for (const [path, contents] of files) {
+		const targetPath = join$1(extractDir, path);
+		if (!isPathSafe$1(extractDir, targetPath)) throw new ArchiveValidationError(`Archive contains unsafe path: ${path}`);
+		await mkdir$1(dirname$1(targetPath), { recursive: true });
+		await writeFile$1(targetPath, contents);
+	}
+}
+function getTarEntryType(entry) {
+	if (entry instanceof tar.ReadEntry) return entry.type;
+	if (entry.isFile()) return "File";
+	if (entry.isDirectory()) return "Directory";
+	return "";
+}
+function isTarEntryFile(entry) {
+	const type = getTarEntryType(entry);
+	return type === "File" || type === "OldFile" || type === "ContiguousFile";
+}
+async function extractTar(filePath, extractDir, limits) {
+	const state = {
+		bytes: 0,
+		entries: 0
+	};
+	let validationError;
+	await tar.x({
+		strict: true,
+		filter(entryPath, entry) {
+			if (validationError) return false;
+			try {
+				const safePath = validateArchivePath(entryPath);
+				if (safePath === null) throw new ArchiveValidationError(`Archive contains unsafe path: ${entryPath}`);
+				if (!isPathSafe$1(extractDir, join$1(extractDir, safePath))) throw new ArchiveValidationError(`Archive contains unsafe path: ${entryPath}`);
+				incrementEntry(state, entry.size, limits);
+				if (isTarEntryFile(entry)) return true;
+				return getTarEntryType(entry) === "Directory";
+			} catch (error) {
+				if (error instanceof ArchiveValidationError) {
+					validationError = error;
+					return false;
+				}
+				throw error;
+			}
+		},
+		cwd: extractDir,
+		preservePaths: false,
+		noChmod: true,
+		file: filePath
+	});
+	if (validationError) throw validationError;
+}
+async function tryExtractArchive(filePath, extractDir, limits) {
+	const header = await readFile$1(filePath).then((buffer) => buffer.subarray(0, 512));
+	const isZip = header[0] === 80 && header[1] === 75;
+	const isGzip = header[0] === 31 && header[1] === 139;
+	try {
+		if (isZip) {
+			await extractZip(filePath, extractDir, limits);
+			return true;
+		}
+		if (isGzip) {
+			await extractTar(filePath, extractDir, limits);
+			return true;
+		}
+		await extractTar(filePath, extractDir, limits);
+		return true;
+	} catch (error) {
+		await rm$1(extractDir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		await mkdir$1(extractDir, { recursive: true });
+		if (error instanceof ArchiveValidationError) throw error;
+		return false;
+	}
+}
+async function getSingleTopLevelDirectory(dir) {
+	const { readdir } = await import("node:fs/promises");
+	const visibleEntries = (await readdir(dir, { withFileTypes: true })).filter((entry) => entry.name !== "__MACOSX");
+	if (visibleEntries.length !== 1 || !visibleEntries[0].isDirectory()) return null;
+	return join$1(dir, visibleEntries[0].name);
+}
+async function downloadSource(url) {
+	const limits = getDownloadLimits();
+	const tempDir = await mkdtemp$1(join$1(tmpdir$1(), "skills-download-"));
+	const downloadedFile = join$1(tempDir, "source.download");
+	const extractDir = join$1(tempDir, "extract");
+	try {
+		await downloadToFile(url, downloadedFile, limits);
+		if ((await stat$1(downloadedFile)).size === 0) throw new Error("Downloaded URL is empty");
+		if (await isValidSkillMarkdown(downloadedFile)) {
+			const skillDir = join$1(tempDir, "skill");
+			await mkdir$1(skillDir, { recursive: true });
+			await writeFile$1(join$1(skillDir, "SKILL.md"), await readFile$1(downloadedFile));
+			return {
+				rootDir: skillDir,
+				tempDir,
+				kind: "skill-md"
+			};
+		}
+		await mkdir$1(extractDir, { recursive: true });
+		if (await tryExtractArchive(downloadedFile, extractDir, limits)) return {
+			rootDir: await getSingleTopLevelDirectory(extractDir) ?? extractDir,
+			tempDir,
+			kind: "archive"
+		};
+		throw new Error("Downloaded URL is not a valid SKILL.md file or supported archive");
+	} catch (error) {
+		await rm$1(tempDir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		throw error;
+	}
+}
 const AGENTS_DIR = ".agents";
 const LOCK_FILE = ".skill-lock.json";
 const CURRENT_VERSION = 3;
@@ -3165,9 +3630,11 @@ const PRIORITY_PREFIXES = [
 	".continue/skills/",
 	".github/skills/",
 	".goose/skills/",
+	".grok/skills/",
 	".iflow/skills/",
 	".junie/skills/",
 	".kilocode/skills/",
+	".kimchi/skills/",
 	".kiro/skills/",
 	".mux/skills/",
 	".neovate/skills/",
@@ -3334,7 +3801,7 @@ async function tryBlobInstall(ownerRepo, options = {}) {
 		tree
 	};
 }
-var version$1 = "1.5.19";
+var version$1 = "1.5.21";
 const isCancelled$1 = (value) => typeof value === "symbol";
 const EVE_AGENT_LABEL = "eve agent";
 async function isSourcePrivate(source) {
@@ -3554,12 +4021,11 @@ async function selectAgentsInteractive(options) {
 }
 setVersion(version$1);
 async function handleWellKnownSkills(source, url, options, spinner) {
-	spinner.start("Discovering skills from well-known endpoint…");
-	const skills = await wellKnownProvider.fetchAllSkills(url);
+	spinner.start("Discovering skills from well-known endpoint...");
+	const skills = await wellKnownProvider.fetchAllSkills(url).catch(() => []);
 	if (skills.length === 0) {
-		spinner.stop(import_picocolors.default.red("No skills found"));
-		outro(import_picocolors.default.red("No skills found at this URL. Make sure the server has a /.well-known/agent-skills/index.json or /.well-known/skills/index.json file."));
-		process.exit(1);
+		spinner.stop(import_picocolors.default.dim("No well-known skills found; trying direct download..."));
+		return false;
 	}
 	spinner.stop(`Found ${import_picocolors.default.green(skills.length)} skill${skills.length > 1 ? "s" : ""}`);
 	for (const skill of skills) {
@@ -3764,6 +4230,7 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 		agents: targetAgents.join(","),
 		...installGlobally && { global: "1" },
 		skillFiles: JSON.stringify(skillFiles),
+		installUrl: url,
 		metadata: options.metadata,
 		sourceType: "well-known"
 	});
@@ -3839,6 +4306,7 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 	console.log();
 	outro(import_picocolors.default.green("Done!") + import_picocolors.default.dim("  Review skills before use; they run with full agent permissions."));
 	await promptForFindSkills(options, targetAgents);
+	return true;
 }
 async function runAdd(args, options = {}) {
 	const source = args[0];
@@ -3882,17 +4350,19 @@ async function runAdd(args, options = {}) {
 		const spinner$3 = spinner();
 		spinner$3.start("Parsing source…");
 		const parsed = parseSource(source);
+		let directDownload = parsed.type === "download";
 		spinner$3.stop(`Source: ${parsed.type === "local" ? parsed.localPath : parsed.url}${parsed.ref ? ` @ ${import_picocolors.default.yellow(parsed.ref)}` : ""}${parsed.subpath ? ` (${parsed.subpath})` : ""}${parsed.skillFilter ? ` ${import_picocolors.default.dim("@")}${import_picocolors.default.cyan(parsed.skillFilter)}` : ""}`);
-		const ownerRepoRaw = getOwnerRepo(parsed);
+		const ownerRepoRaw = parsed.type === "well-known" || parsed.type === "download" ? null : getOwnerRepo(parsed);
 		const repoPrivacyPromise = (() => {
+			if (parsed.type !== "github") return Promise.resolve(null);
 			if (!ownerRepoRaw) return Promise.resolve(null);
 			const ownerRepo = parseOwnerRepo(ownerRepoRaw);
 			if (!ownerRepo) return Promise.resolve(null);
 			return isRepoPrivate(ownerRepo.owner, ownerRepo.repo).catch(() => null);
 		})();
 		if (parsed.type === "well-known") {
-			await handleWellKnownSkills(source, parsed.url, options, spinner$3);
-			return;
+			if (await handleWellKnownSkills(source, parsed.url, options, spinner$3)) return;
+			directDownload = true;
 		}
 		if (parsed.skillFilter) {
 			options.skill = options.skill || [];
@@ -3914,6 +4384,16 @@ async function runAdd(args, options = {}) {
 				includeInternal,
 				fullDepth: options.fullDepth
 			});
+		} else if (parsed.type === "well-known" || parsed.type === "download") {
+			spinner$3.start("Downloading source...");
+			const downloaded = await downloadSource(parsed.url);
+			tempDir = downloaded.tempDir;
+			spinner$3.stop(`Downloaded ${downloaded.kind === "skill-md" ? "SKILL.md file" : "archive"}`);
+			spinner$3.start("Discovering skills...");
+			skills = await discoverSkills(downloaded.rootDir, parsed.subpath, {
+				includeInternal,
+				fullDepth: options.fullDepth
+			});
 		} else if (parsed.type === "github" && !options.fullDepth) {
 			const BLOB_ALLOWED_OWNERS = [
 				"vercel",
@@ -4306,9 +4786,9 @@ async function runAdd(args, options = {}) {
 		else if (tempDir && skill.path === tempDir) skillFiles[skill.name] = "SKILL.md";
 		else if (tempDir && skill.path.startsWith(tempDir + sep)) skillFiles[skill.name] = skill.path.slice(tempDir.length + 1).split(sep).join("/") + "/SKILL.md";
 		else continue;
-		const normalizedSource = getOwnerRepo(parsed);
-		const lockSource = getLockSource(parsed.url, normalizedSource);
-		const projectLockSourceUrl = getProjectLockSourceUrl(parsed.type, parsed.url);
+		const normalizedSource = directDownload ? null : getOwnerRepo(parsed);
+		const lockSource = directDownload ? null : getLockSource(parsed.url, normalizedSource);
+		const projectLockSourceUrl = directDownload ? void 0 : getProjectLockSourceUrl(parsed.type, parsed.url);
 		if (normalizedSource) if (parseOwnerRepo(normalizedSource)) {
 			if (await repoPrivacyPromise === false) track({
 				event: "install",
@@ -4359,7 +4839,7 @@ async function runAdd(args, options = {}) {
 				} catch {}
 			}
 		}
-		if (successful.length > 0 && !installGlobally) {
+		if (successful.length > 0 && !installGlobally && !directDownload) {
 			const successfulSkillNames = new Set(successful.map((r) => r.skill));
 			const eveSubagents = targetAgents.includes("eve") ? eveSubagentTargets.map((s) => s ?? "") : void 0;
 			const recordSubagents = eveSubagents && (eveSubagents.length > 1 || eveSubagents.some((s) => s !== ""));
@@ -5155,7 +5635,7 @@ function deriveSkillFolder(skillPath) {
 	return folder;
 }
 function supportsAppendedSubpath(source) {
-	if (source.startsWith("git@")) return false;
+	if (source.startsWith("git@") || source.startsWith("ssh://")) return false;
 	if (source.endsWith(".git")) return false;
 	if (source.startsWith("http://") || source.startsWith("https://")) try {
 		const host = new URL(source).hostname;
@@ -5173,6 +5653,11 @@ function getLocalSource(entry) {
 	if ((entry.sourceType === "git" || entry.sourceType === "gitlab") && isBareShorthand(entry.source)) return null;
 	return entry.source;
 }
+function shouldUseFullDepthForUpdate(entry) {
+	if (!entry.skillPath) return false;
+	const source = entry.sourceType && entry.sourceType !== "github" ? getLocalSource(entry) : entry.source;
+	return source !== null && !supportsAppendedSubpath(source);
+}
 function appendFolderAndRef(source, skillPath, ref) {
 	if (!supportsAppendedSubpath(source)) return formatSourceInput(source, ref);
 	const folder = deriveSkillFolder(skillPath);
@@ -5296,18 +5781,26 @@ async function runList(args) {
 		global: scope,
 		agentFilter
 	});
+	const cwd = process.cwd();
+	const lockedSkills = scope ? await getAllLockedSkills() : (await readLocalLock(cwd)).skills;
+	const lockEntriesBySanitizedName = new Map(Object.entries(lockedSkills).map(([name, entry]) => [sanitizeName(name), entry]));
+	const getLockEntry = (skillName) => lockedSkills[skillName] ?? lockEntriesBySanitizedName.get(sanitizeName(skillName));
 	if (options.json) {
-		const jsonOutput = installedSkills.map((skill) => ({
-			name: skill.name,
-			path: skill.canonicalPath,
-			scope: skill.scope,
-			agents: skill.agents.map((a) => agents[a].displayName)
-		}));
+		const jsonOutput = installedSkills.map((skill) => {
+			const lockEntry = getLockEntry(skill.name);
+			return {
+				name: skill.name,
+				path: skill.canonicalPath,
+				scope: skill.scope,
+				agents: skill.agents.map((a) => agents[a].displayName),
+				source: lockEntry?.source ?? null,
+				sourceUrl: lockEntry?.sourceUrl ?? null,
+				sourceType: lockEntry?.sourceType ?? null
+			};
+		});
 		console.log(JSON.stringify(jsonOutput, null, 2));
 		return;
 	}
-	const lockedSkills = await getAllLockedSkills();
-	const cwd = process.cwd();
 	const scopeLabel = scope ? "Global" : "Project";
 	if (installedSkills.length === 0) {
 		if (options.json) {
@@ -5326,14 +5819,17 @@ async function runList(args) {
 		const agentInfo = skill.agents.length > 0 ? formatList(agentNames) : `${YELLOW}not linked${RESET$2}`;
 		const paddedName = sanitizeMetadata(skill.name).padEnd(maxNameLength);
 		const paddedPath = shortPath.padEnd(maxPathLength);
-		console.log(`${prefix}${CYAN}${paddedName}${RESET$2} ${DIM$2}${paddedPath}${RESET$2} ${DIM$2}Agents:${RESET$2} ${agentInfo}`);
+		const source = getLockEntry(skill.name)?.source ?? null;
+		const sourceLabel = source ? sanitizeMetadata(source) : "local";
+		console.log(`${prefix}${CYAN}${paddedName}${RESET$2} ${DIM$2}${paddedPath}${RESET$2}`);
+		console.log(`${prefix}  ${DIM$2}Agents:${RESET$2} ${agentInfo}  ${DIM$2}Source:${RESET$2} ${sourceLabel}`);
 	}
 	console.log(`${BOLD$2}${scopeLabel} Skills${RESET$2}`);
 	console.log();
 	const groupedSkills = {};
 	const ungroupedSkills = [];
 	for (const skill of installedSkills) {
-		const lockEntry = lockedSkills[skill.name];
+		const lockEntry = getLockEntry(skill.name);
 		if (lockEntry?.pluginName) {
 			const group = lockEntry.pluginName;
 			if (!groupedSkills[group]) groupedSkills[group] = [];
@@ -5385,6 +5881,17 @@ async function runList(args) {
 		console.log();
 	}
 }
+function resolveSkillsToRemove(requested, folderNames, lockKeys = []) {
+	const identityBySanitized = /* @__PURE__ */ new Map();
+	for (const folder of folderNames) identityBySanitized.set(sanitizeName(folder), folder);
+	for (const key of lockKeys) identityBySanitized.set(sanitizeName(key), key);
+	const matched = /* @__PURE__ */ new Set();
+	for (const name of requested) {
+		const hit = identityBySanitized.get(sanitizeName(name));
+		if (hit) matched.add(hit);
+	}
+	return Array.from(matched);
+}
 async function removeCommand(skillNames, options) {
 	const agentResult = await detectAgent();
 	if (agentResult.isAgent) {
@@ -5414,7 +5921,10 @@ async function removeCommand(skillNames, options) {
 	}
 	const installedSkills = Array.from(skillNamesSet).sort();
 	spinner$1.stop(`Found ${installedSkills.length} unique installed skill(s)`);
-	if (installedSkills.length === 0) {
+	const lockSkillsKeys = isGlobal ? Object.keys((await readSkillLock()).skills) : Object.keys((await readLocalLock(cwd)).skills);
+	const requestedSkills = options.all ? [...installedSkills, ...lockSkillsKeys] : skillNames;
+	const resolvedRequestedSkills = options.all || skillNames.length > 0 ? resolveSkillsToRemove(requestedSkills, installedSkills, lockSkillsKeys) : [];
+	if (installedSkills.length === 0 && resolvedRequestedSkills.length === 0) {
 		outro(import_picocolors.default.yellow("No skills found to remove."));
 		return;
 	}
@@ -5428,9 +5938,9 @@ async function removeCommand(skillNames, options) {
 		}
 	}
 	let selectedSkills = [];
-	if (options.all) selectedSkills = installedSkills;
+	if (options.all) selectedSkills = resolvedRequestedSkills;
 	else if (skillNames.length > 0) {
-		selectedSkills = installedSkills.filter((s) => skillNames.some((name) => name.toLowerCase() === s.toLowerCase()));
+		selectedSkills = resolvedRequestedSkills;
 		if (selectedSkills.length === 0) {
 			log.error(`No matching skills found for: ${skillNames.join(", ")}`);
 			return;
@@ -5449,7 +5959,7 @@ async function removeCommand(skillNames, options) {
 			cancel("Removal cancelled");
 			process.exit(0);
 		}
-		selectedSkills = selected;
+		selectedSkills = resolveSkillsToRemove(selected, installedSkills, lockSkillsKeys);
 	}
 	let targetAgents;
 	if (options.agent && options.agent.length > 0) targetAgents = options.agent;
@@ -5513,10 +6023,19 @@ async function removeCommand(skillNames, options) {
 			recursive: true,
 			force: true
 		});
-		const lockEntry = isGlobal ? await getSkillFromLock(skillName) : null;
-		const effectiveSource = lockEntry?.source || "local";
-		const effectiveSourceType = lockEntry?.sourceType || "local";
-		if (isGlobal) await removeSkillFromLock(skillName);
+		let effectiveSource = "local";
+		let effectiveSourceType = "local";
+		if (isGlobal) {
+			const lockEntry = await getSkillFromLock(skillName);
+			effectiveSource = lockEntry?.source || "local";
+			effectiveSourceType = lockEntry?.sourceType || "local";
+			await removeSkillFromLock(skillName);
+		} else {
+			const lockEntry = (await readLocalLock(cwd)).skills[skillName];
+			effectiveSource = lockEntry?.source || "local";
+			effectiveSourceType = lockEntry?.sourceType || "local";
+			await removeSkillFromLocalLock(skillName, cwd);
+		}
 		results.push({
 			skill: skillName,
 			success: true,
@@ -5786,7 +6305,7 @@ async function updateGlobalSkills(options = {}) {
 					console.log(`  ${DIM$1}✗ Failed to fetch tree for ${source}${RESET$1}`);
 					continue;
 				}
-				const discoveredPaths = findSkillMdPaths(tree);
+				const discoveredPaths = tree.tree.filter((entry) => entry.type === "blob").map((entry) => entry.path);
 				const deletedSkills = await checkAndPromptForDeletions(source, Object.entries(lock.skills).filter(([_, entry]) => entry.source === source).map(([name, _]) => name), lock.skills, true, options, discoveredPaths);
 				const deletedSkillSet = new Set(deletedSkills);
 				for (const { name: skillName, entry } of itemsForSource) {
@@ -5801,7 +6320,7 @@ async function updateGlobalSkills(options = {}) {
 				continue;
 			}
 			tempDir = await cloneRepo(sourceUrl, firstEntry.ref);
-			const discoveredPaths = (await discoverSkills(tempDir)).map((skill) => {
+			const discoveredPaths = (await discoverSkills(tempDir, void 0, { fullDepth: true })).map((skill) => {
 				return join(relative(tempDir, skill.path), "SKILL.md").split(sep).join("/");
 			});
 			const deletedSkills = await checkAndPromptForDeletions(source, Object.entries(lock.skills).filter(([_, entry]) => entry.source === source).map(([name, _]) => name), lock.skills, true, options, discoveredPaths);
@@ -5866,10 +6385,12 @@ async function updateGlobalSkills(options = {}) {
 			console.log(`  ${DIM$1}✗ Failed to update ${safeName}: CLI entrypoint not found at ${cliEntry}${RESET$1}`);
 			continue;
 		}
+		const fullDepthArgs = shouldUseFullDepthForUpdate(update.entry) ? ["--full-depth"] : [];
 		if (spawnSync(process.execPath, [
 			cliEntry,
 			"add",
 			installUrl,
+			...fullDepthArgs,
 			"-g",
 			"-y"
 		], {
@@ -5967,7 +6488,7 @@ async function updateProjectSkills(options = {}) {
 		}
 		try {
 			tempDir = await cloneRepo(sourceUrl, ref);
-			const discoveredPaths = (await discoverSkills(tempDir)).map((s) => {
+			const discoveredPaths = (await discoverSkills(tempDir, void 0, { fullDepth: true })).map((s) => {
 				return join(relative(tempDir, s.path), "SKILL.md").split(sep).join("/");
 			});
 			deletedSkills = await checkAndPromptForDeletions(source, allLockedForSource, localLock.skills, false, options, discoveredPaths);
@@ -5987,6 +6508,7 @@ async function updateProjectSkills(options = {}) {
 				continue;
 			}
 			const subagentArgs = skill.entry.subagents?.length ? ["--subagent", ...skill.entry.subagents.map((s) => s === "" ? "root" : s)] : [];
+			const fullDepthArgs = shouldUseFullDepthForUpdate(skill.entry) ? ["--full-depth"] : [];
 			if (spawnSync(process.execPath, [
 				cliEntry,
 				"add",
@@ -5994,6 +6516,7 @@ async function updateProjectSkills(options = {}) {
 				"--skill",
 				skill.name,
 				...subagentArgs,
+				...fullDepthArgs,
 				"-y"
 			], {
 				stdio: [
@@ -6180,11 +6703,35 @@ async function runUse(sourceArgs, options = {}, parseErrors = []) {
 		const selector = resolveSelector(parsed.skillFilter, options.skill);
 		const includeInternal = selector !== void 0;
 		let selectedSkill;
-		if (parsed.type === "well-known") selectedSkill = selectWellKnownSkill(await wellKnownProvider.fetchAllSkills(parsed.url), selector, source);
-		else {
+		if (parsed.type === "well-known") {
+			const skills = await wellKnownProvider.fetchAllSkills(parsed.url);
+			if (skills.length > 0) selectedSkill = selectWellKnownSkill(skills, selector, source);
+			else {
+				const downloaded = await downloadSource(parsed.url);
+				cloneTempDir = downloaded.tempDir;
+				const selected = selectSkill(await discoverSkills(downloaded.rootDir, void 0, {
+					includeInternal,
+					fullDepth: options.fullDepth
+				}), selector, source);
+				selectedSkill = {
+					kind: "disk",
+					name: selected.name,
+					directoryName: selected.name,
+					rawContent: selected.rawContent,
+					path: selected.path
+				};
+			}
+		} else {
 			let skills;
 			let blobResult = null;
-			if (parsed.type === "local") {
+			if (parsed.type === "download") {
+				const downloaded = await downloadSource(parsed.url);
+				cloneTempDir = downloaded.tempDir;
+				skills = await discoverSkills(downloaded.rootDir, void 0, {
+					includeInternal,
+					fullDepth: options.fullDepth
+				});
+			} else if (parsed.type === "local") {
 				if (!existsSync(parsed.localPath)) fail(`Local path does not exist: ${parsed.localPath}`);
 				skills = await discoverSkills(parsed.localPath, parsed.subpath, {
 					includeInternal,
@@ -6674,6 +7221,11 @@ async function main() {
 	}
 	const command = args[0];
 	const restArgs = args.slice(1);
+	if (command !== "--help" && command !== "-h" && command !== "--version" && command !== "-v" && (restArgs.includes("--help") || restArgs.includes("-h"))) {
+		if (command === "remove" || command === "rm" || command === "r") showRemoveHelp();
+		else showHelp();
+		return;
+	}
 	switch (command) {
 		case "find":
 		case "search":
@@ -6713,14 +7265,11 @@ async function main() {
 		}
 		case "remove":
 		case "rm":
-		case "r":
-			if (restArgs.includes("--help") || restArgs.includes("-h")) {
-				showRemoveHelp();
-				break;
-			}
+		case "r": {
 			const { skills, options: removeOptions } = parseRemoveOptions(restArgs);
 			await removeCommand(skills, removeOptions);
 			break;
+		}
 		case "experimental_sync": {
 			if (!inAgent) showLogo();
 			const { options: syncOptions } = parseSyncOptions(restArgs);
@@ -6747,6 +7296,7 @@ async function main() {
 		default:
 			console.log(`Unknown command: ${command}`);
 			console.log(`Run ${BOLD}skills --help${RESET} for usage.`);
+			process.exitCode = 1;
 	}
 }
 main().finally(() => flushTelemetry().then(() => process.exit(process.exitCode ?? 0)));