skills 1.5.21 → 1.5.22

package/README.md

@@ -3,7 +3,7 @@
 The CLI for the open agent skills ecosystem.
 
 <!-- agent-list:start -->
-Supports **OpenCode**, **Claude Code**, **Codex**, **Cursor**, and [70 more](#supported-agents).
+Supports **OpenCode**, **Claude Code**, **Codex**, **Cursor**, and [72 more](#supported-agents).
 <!-- agent-list:end -->
 
 [![skills.sh](https://skills.sh/b/vercel-labs/skills)](https://skills.sh/vercel-labs/skills)
@@ -289,6 +289,7 @@ Skills can be installed to any of these agents:
 | Kode | `kode` | `.kode/skills/` | `~/.kode/skills/` |
 | Lingma | `lingma` | `.lingma/skills/` | `~/.lingma/skills/` |
 | MCPJam | `mcpjam` | `.mcpjam/skills/` | `~/.mcpjam/skills/` |
+| MiniMax Code | `minimax-code` | `.minimax/skills/` | `~/.minimax/skills/` |
 | Mistral Vibe | `mistral-vibe` | `.vibe/skills/` | `~/.vibe/skills/` |
 | Moxby | `moxby` | `.moxby/skills/` | `~/.moxby/skills/` |
 | Mux | `mux` | `.mux/skills/` | `~/.mux/skills/` |
@@ -376,12 +377,13 @@ metadata:
 ### Skill Discovery
 
 The CLI searches for skills in these locations within a repository. Each
-skill container directory is walked one level deep for the common flat
-layout (`skills/<name>/SKILL.md`) and one extra level deep for catalog
-layouts (`skills/<category>/<name>/SKILL.md`). A `SKILL.md` discovered at
-the shallower level shadows anything nested below it. Use `--full-depth`
-to also discover `SKILL.md` files outside these container directories
-(e.g. under `examples/` or `tests/`).
+skill container directory is walked up to three levels deep, covering flat
+layouts (`skills/<name>/SKILL.md`) and catalog layouts with one or two category
+levels (`skills/<category>/<name>/SKILL.md` or
+`skills/<category>/<category>/<name>/SKILL.md`). A `SKILL.md` discovered at a
+shallower level shadows anything nested below it. Use `--full-depth` to also
+discover `SKILL.md` files outside these container directories (e.g. under
+`examples/` or `tests/`).
 
 <!-- skill-discovery:start -->
 - Root directory (if it contains `SKILL.md`)
@@ -421,6 +423,7 @@ to also discover `SKILL.md` files outside these container directories
 - `.kode/skills/`
 - `.lingma/skills/`
 - `.mcpjam/skills/`
+- `.minimax/skills/`
 - `.vibe/skills/`
 - `.moxby/skills/`
 - `.mux/skills/`
@@ -462,7 +465,7 @@ If `.claude-plugin/marketplace.json` or `.claude-plugin/plugin.json` exists, ski
 }
 ```
 
-This enables compatibility with the [Claude Code plugin marketplace](https://code.claude.com/docs/en/plugin-marketplaces) ecosystem. Skill paths declared in a manifest are searched at their declared depth and are not subject to the depth-2 catalog walk described above.
+This enables compatibility with the [Claude Code plugin marketplace](https://code.claude.com/docs/en/plugin-marketplaces) ecosystem. Skill paths declared in a manifest are searched at their declared depth and are not subject to the bounded depth-3 catalog walk described above.
 
 If no skills are found in standard locations, a recursive search is performed.
 

package/dist/cli.mjs

@@ -902,27 +902,45 @@ function getLocalLockPath(cwd) {
 	return join(cwd || process.cwd(), LOCAL_LOCK_FILE);
 }
 async function readLocalLock(cwd) {
-	const lockPath = getLocalLockPath(cwd);
+	const lockDir = cwd || process.cwd();
+	const lockPath = getLocalLockPath(lockDir);
 	try {
 		const content = await readFile(lockPath, "utf-8");
 		const parsed = JSON.parse(content);
 		if (typeof parsed.version !== "number" || !parsed.skills) return createEmptyLocalLock();
 		if (parsed.version < CURRENT_VERSION$1) return createEmptyLocalLock();
+		for (const entry of Object.values(parsed.skills)) if (entry.sourceType === "local" && !isAbsolute(entry.source)) entry.source = resolve(lockDir, entry.source);
 		return parsed;
 	} catch {
 		return createEmptyLocalLock();
 	}
 }
 async function writeLocalLock(lock, cwd) {
-	const lockPath = getLocalLockPath(cwd);
+	const lockDir = cwd || process.cwd();
+	const lockPath = getLocalLockPath(lockDir);
 	const sortedSkills = {};
-	for (const key of Object.keys(lock.skills).sort()) sortedSkills[key] = lock.skills[key];
+	for (const key of Object.keys(lock.skills).sort()) {
+		const entry = lock.skills[key];
+		sortedSkills[key] = entry.sourceType === "local" ? {
+			...entry,
+			source: getPortableLocalSource(entry.source, lockDir)
+		} : entry;
+	}
 	const sorted = {
 		version: lock.version,
 		skills: sortedSkills
 	};
 	await writeFile(lockPath, JSON.stringify(sorted, null, 2) + "\n", "utf-8");
 }
+function getPortableLocalSource(source, lockDir) {
+	const absoluteSource = isAbsolute(source) ? source : resolve(lockDir, source);
+	const relativeSource = relative(lockDir, absoluteSource);
+	if (isAbsolute(relativeSource)) return absoluteSource.split(sep).join("/");
+	const portableSource = relativeSource.split(sep).join("/");
+	if (!portableSource) return ".";
+	if (portableSource === ".." || portableSource.startsWith("../")) return portableSource;
+	return `./${portableSource}`;
+}
 async function computeSkillFolderHash(skillDir) {
 	const files = [];
 	await collectFiles(skillDir, skillDir, files);
@@ -969,6 +987,8 @@ function createEmptyLocalLock() {
 		skills: {}
 	};
 }
+const AGENTS_DIR$1 = ".agents";
+const SKILLS_SUBDIR = "skills";
 const SKIP_DIRS = [
 	"node_modules",
 	".git",
@@ -992,6 +1012,7 @@ const AGENT_PROJECT_SKILL_DIRS = [
 	".kilocode/skills",
 	".kimchi/skills",
 	".kiro/skills",
+	".minimax/skills",
 	".mux/skills",
 	".neovate/skills",
 	".opencode/skills",
@@ -1138,25 +1159,18 @@ async function discoverSkills(basePath, subpath, options) {
 		seenNames.add(skill.name);
 		return true;
 	};
-	for (const dir of prioritySearchDirs) {
-		const walkDeep = deepContainerDirs.has(dir);
+	const walkSkillDirs = async (dir, maxDepth, depth = 1) => {
 		try {
 			const entries = await readdir(dir, { withFileTypes: true });
 			for (const entry of entries) {
 				if (!entry.isDirectory()) continue;
 				const childDir = join(dir, entry.name);
-				if (await tryAddSkillAt(childDir) || !walkDeep) continue;
-				if (SKIP_DIRS.includes(entry.name)) continue;
-				try {
-					const grandEntries = await readdir(childDir, { withFileTypes: true });
-					for (const grand of grandEntries) {
-						if (!grand.isDirectory() || SKIP_DIRS.includes(grand.name)) continue;
-						await tryAddSkillAt(join(childDir, grand.name));
-					}
-				} catch {}
+				if (await tryAddSkillAt(childDir) || depth >= maxDepth || SKIP_DIRS.includes(entry.name)) continue;
+				await walkSkillDirs(childDir, maxDepth, depth + 1);
 			}
 		} catch {}
-	}
+	};
+	for (const dir of prioritySearchDirs) await walkSkillDirs(dir, deepContainerDirs.has(dir) ? 3 : 1);
 	if (skills.length === 0 || options?.fullDepth) {
 		const allSkillDirs = await findSkillDirs(searchPath);
 		for (const skillDir of allSkillDirs) {
@@ -1211,6 +1225,9 @@ function isZCodeInstalled(homeDir = home, pathExists = existsSync) {
 function isKimchiInstalled(homeDir = home, pathExists = existsSync) {
 	return pathExists(join(homeDir, ".config", "kimchi"));
 }
+function isMiniMaxCodeInstalled(homeDir = home, pathExists = existsSync) {
+	return pathExists(join(homeDir, ".minimax")) || pathExists("/Applications/MiniMax Code.app");
+}
 const agents = {
 	"aider-desk": {
 		name: "aider-desk",
@@ -1621,6 +1638,15 @@ const agents = {
 			return existsSync(join(home, ".mcpjam"));
 		}
 	},
+	"minimax-code": {
+		name: "minimax-code",
+		displayName: "MiniMax Code",
+		skillsDir: ".minimax/skills",
+		globalSkillsDir: join(home, ".minimax/skills"),
+		detectInstalled: async () => {
+			return isMiniMaxCodeInstalled();
+		}
+	},
 	"mistral-vibe": {
 		name: "mistral-vibe",
 		displayName: "Mistral Vibe",
@@ -1921,8 +1947,6 @@ function getNonUniversalAgents() {
 function isUniversalAgent(type) {
 	return agents[type].skillsDir === ".agents/skills";
 }
-const AGENTS_DIR$1 = ".agents";
-const SKILLS_SUBDIR = "skills";
 function sanitizeName(name) {
 	return name.toLowerCase().replace(/[^a-z0-9._]+/g, "-").replace(/^[.\-]+|[.\-]+$/g, "").substring(0, 255) || "unnamed-skill";
 }
@@ -2873,10 +2897,10 @@ var WellKnownProvider = class {
 			return { matches: false };
 		}
 	}
-	async fetchIndex(baseUrl) {
-		return (await this.fetchIndexCandidates(baseUrl))[0] ?? null;
+	async fetchIndex(baseUrl, options) {
+		return (await this.fetchIndexCandidates(baseUrl, options))[0] ?? null;
 	}
-	async fetchIndexCandidates(baseUrl) {
+	async fetchIndexCandidates(baseUrl, options) {
 		try {
 			const parsed = new URL(baseUrl);
 			const basePath = parsed.pathname.replace(/\/$/, "");
@@ -2896,7 +2920,10 @@ var WellKnownProvider = class {
 			}
 			const candidates = [];
 			for (const { indexUrl, baseUrl: resolvedBase, wellKnownPath } of urlsToTry) try {
-				const response = await fetch(indexUrl, { signal });
+				const response = await fetch(indexUrl, {
+					signal,
+					...options?.updateCheck ? { headers: { "X-Skills-Update-Check": "1" } } : {}
+				});
 				if (!response.ok) continue;
 				const rawIndex = await response.json();
 				const normalized = this.normalizeIndex(rawIndex, indexUrl, wellKnownPath);
@@ -3253,6 +3280,17 @@ var WellKnownProvider = class {
 		return await this.fetchIndex(url) !== null;
 	}
 };
+function computeWellKnownSkillDigest(skill) {
+	if ("digest" in skill.indexEntry && skill.indexEntry.digest) return skill.indexEntry.digest;
+	const hash = createHash$1("sha256");
+	for (const path of Array.from(skill.files.keys()).sort()) {
+		hash.update(path);
+		hash.update("\0");
+		hash.update(skill.files.get(path));
+		hash.update("\0");
+	}
+	return `sha256:${hash.digest("hex")}`;
+}
 const wellKnownProvider = new WellKnownProvider();
 const DEFAULT_DOWNLOAD_MAX_BYTES = 10 * 1024 * 1024;
 const DEFAULT_EXTRACT_MAX_BYTES = 25 * 1024 * 1024;
@@ -3636,6 +3674,7 @@ const PRIORITY_PREFIXES = [
 	".kilocode/skills/",
 	".kimchi/skills/",
 	".kiro/skills/",
+	".minimax/skills/",
 	".mux/skills/",
 	".neovate/skills/",
 	".opencode/skills/",
@@ -3684,9 +3723,13 @@ function findSkillMdPaths(tree, subpath) {
 				}
 				continue;
 			}
-			if (isContainer && parts.length === 3 && parts[2].toLowerCase() === "skill.md" && !SKIP_DIRS.has(parts[0]) && !SKIP_DIRS.has(parts[1])) {
-				const parentSkillMd = `${fullPrefix}${parts[0]}/SKILL.md`.toLowerCase();
-				if (!lowerSkillMdSet.has(parentSkillMd) && !seen.has(skillMd)) {
+			const skillDirs = parts.slice(0, -1);
+			const hasAncestorSkill = skillDirs.slice(0, -1).some((_, index) => {
+				const ancestorPath = skillDirs.slice(0, index + 1).join("/");
+				return lowerSkillMdSet.has(`${fullPrefix}${ancestorPath}/SKILL.md`.toLowerCase());
+			});
+			if (isContainer && parts.length >= 3 && parts.length <= 4 && parts.at(-1).toLowerCase() === "skill.md" && skillDirs.every((part) => !SKIP_DIRS.has(part)) && !hasAncestorSkill) {
+				if (!seen.has(skillMd)) {
 					priorityResults.push(skillMd);
 					seen.add(skillMd);
 				}
@@ -3801,7 +3844,7 @@ async function tryBlobInstall(ownerRepo, options = {}) {
 		tree
 	};
 }
-var version$1 = "1.5.21";
+var version$1 = "1.5.22";
 const isCancelled$1 = (value) => typeof value === "symbol";
 const EVE_AGENT_LABEL = "eve agent";
 async function isSourcePrivate(source) {
@@ -4020,6 +4063,14 @@ async function selectAgentsInteractive(options) {
 	return selected;
 }
 setVersion(version$1);
+function isSkillsShPackUrl(url) {
+	try {
+		const parsed = new URL(url);
+		return parsed.hostname.replace(/^www\./, "") === "skills.sh" && /^\/p\/[^/]+/.test(parsed.pathname);
+	} catch {
+		return false;
+	}
+}
 async function handleWellKnownSkills(source, url, options, spinner) {
 	spinner.start("Discovering skills from well-known endpoint...");
 	const skills = await wellKnownProvider.fetchAllSkills(url).catch(() => []);
@@ -4072,6 +4123,7 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 				label: s.installName,
 				hint: s.description.length > 60 ? s.description.slice(0, 57) + "…" : s.description
 			})),
+			initialValues: isSkillsShPackUrl(url) ? skills : void 0,
 			required: true
 		});
 		if (isCancel(selected)) {
@@ -4241,7 +4293,9 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 				source: sourceIdentifier,
 				sourceType: "well-known",
 				sourceUrl: skill.sourceUrl,
-				skillFolderHash: ""
+				skillFolderHash: "",
+				sourceBaseUrl: url,
+				wellKnownDigest: computeWellKnownSkillDigest(skill)
 			});
 		} catch {}
 	}
@@ -4254,8 +4308,10 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 				const computedHash = await computeSkillFolderHash(installDir);
 				await addSkillToLocalLock(skill.installName, {
 					source: sourceIdentifier,
+					sourceUrl: url,
 					sourceType: "well-known",
-					computedHash
+					computedHash,
+					wellKnownDigest: computeWellKnownSkillDigest(skill)
 				}, cwd);
 			}
 		} catch {}
@@ -5051,6 +5107,7 @@ const DIM$3 = "\x1B[38;5;102m";
 const TEXT$2 = "\x1B[38;5;145m";
 const CYAN$1 = "\x1B[36m";
 const SEARCH_API_BASE = process.env.SKILLS_API_URL || "https://skills.sh";
+const SEARCH_RESULT_LIMIT = "20";
 function formatInstalls(count) {
 	if (!count || count <= 0) return "";
 	if (count >= 1e6) return `${(count / 1e6).toFixed(1).replace(/\.0$/, "")}M installs`;
@@ -5101,7 +5158,7 @@ async function searchSkillsAPI(query, owner) {
 	try {
 		const params = new URLSearchParams({
 			q: query,
-			limit: "10"
+			limit: SEARCH_RESULT_LIMIT
 		});
 		if (owner) params.set("owner", owner);
 		const url = `${SEARCH_API_BASE}/api/search?${params.toString()}`;
@@ -5277,7 +5334,7 @@ ${DIM$3}  2) npx skills add <owner/repo@skill>${RESET$3}`;
 		}
 		console.log(`${DIM$3}Install with${RESET$3} npx skills add <owner/repo@skill>`);
 		console.log();
-		for (const skill of results.slice(0, 6)) {
+		for (const skill of results) {
 			const pkg = skill.source || skill.slug;
 			const installs = formatInstalls(skill.installs);
 			console.log(`${TEXT$2}${pkg}@${skill.name}${RESET$3}${installs ? ` ${CYAN$1}${installs}${RESET$3}` : ""}`);
@@ -5653,6 +5710,12 @@ function getLocalSource(entry) {
 	if ((entry.sourceType === "git" || entry.sourceType === "gitlab") && isBareShorthand(entry.source)) return null;
 	return entry.source;
 }
+function buildLocalCloneSource(entry) {
+	const source = getLocalSource(entry);
+	if (!source) return null;
+	if (entry.sourceType === "github" && isBareShorthand(source)) return `https://github.com/${source.replace(/\.git$/, "")}.git`;
+	return source;
+}
 function shouldUseFullDepthForUpdate(entry) {
 	if (!entry.skillPath) return false;
 	const source = entry.sourceType && entry.sourceType !== "github" ? getLocalSource(entry) : entry.source;
@@ -6029,12 +6092,12 @@ async function removeCommand(skillNames, options) {
 			const lockEntry = await getSkillFromLock(skillName);
 			effectiveSource = lockEntry?.source || "local";
 			effectiveSourceType = lockEntry?.sourceType || "local";
-			await removeSkillFromLock(skillName);
+			if (!isStillUsed) await removeSkillFromLock(skillName);
 		} else {
 			const lockEntry = (await readLocalLock(cwd)).skills[skillName];
 			effectiveSource = lockEntry?.source || "local";
 			effectiveSourceType = lockEntry?.sourceType || "local";
-			await removeSkillFromLocalLock(skillName, cwd);
+			if (!isStillUsed) await removeSkillFromLocalLock(skillName, cwd);
 		}
 		results.push({
 			skill: skillName,
@@ -6108,6 +6171,13 @@ const RESET$1 = "\x1B[0m";
 const BOLD$1 = "\x1B[1m";
 const DIM$1 = "\x1B[38;5;102m";
 const TEXT$1 = "\x1B[38;5;145m";
+function getUpdateChildEnv(sourceType) {
+	if (sourceType !== "github") return;
+	return {
+		...process.env,
+		GH_HOST: "github.com"
+	};
+}
 function parseUpdateOptions(args) {
 	const options = {};
 	const positional = [];
@@ -6224,29 +6294,143 @@ async function getProjectSkillsForUpdate(skillFilter) {
 	}
 	return skills;
 }
+async function promptDeletions(source, deletedSkills, isGlobal, options) {
+	if (deletedSkills.length === 0) return;
+	console.log();
+	console.log(`${DIM$1}Warning:${RESET$1} The following skills from ${DIM$1}${source}${RESET$1} appear to have been deleted upstream:`);
+	for (const s of deletedSkills) console.log(`  ${DIM$1}•${RESET$1} ${s}`);
+	if (options.yes || !process.stdin.isTTY) {
+		console.log(`${DIM$1}Skipping deletion in non-interactive mode.${RESET$1}`);
+		return;
+	}
+	const confirmed = await confirm({ message: `Would you like to remove the local copies of these deleted skills?` });
+	if (confirmed && !isCancel(confirmed)) for (const s of deletedSkills) {
+		console.log(`${DIM$1}Removing${RESET$1} ${s}…`);
+		await removeCommand([s], {
+			yes: true,
+			global: isGlobal
+		});
+	}
+}
 async function checkAndPromptForDeletions(source, allLockedForSource, lockSkills, isGlobal, options, discoveredPaths) {
 	const deletedSkills = allLockedForSource.filter((name) => {
 		const entry = lockSkills[name];
 		if (!entry?.skillPath) return false;
 		return !discoveredPaths.includes(entry.skillPath);
 	});
-	if (deletedSkills.length > 0) {
-		console.log();
-		console.log(`${DIM$1}Warning:${RESET$1} The following skills from ${DIM$1}${source}${RESET$1} appear to have been deleted upstream:`);
-		for (const s of deletedSkills) console.log(`  ${DIM$1}•${RESET$1} ${s}`);
-		if (options.yes || !process.stdin.isTTY) console.log(`${DIM$1}Skipping deletion in non-interactive mode.${RESET$1}`);
-		else {
-			const confirmed = await confirm({ message: `Would you like to remove the local copies of these deleted skills?` });
-			if (confirmed && !isCancel(confirmed)) for (const s of deletedSkills) {
-				console.log(`${DIM$1}Removing${RESET$1} ${s}…`);
-				await removeCommand([s], {
-					yes: true,
-					global: isGlobal
-				});
+	await promptDeletions(source, deletedSkills, isGlobal, options);
+	return deletedSkills;
+}
+async function checkWellKnownForUpdates(baseUrl, items) {
+	let indexResult;
+	try {
+		indexResult = await wellKnownProvider.fetchIndex(baseUrl, { updateCheck: true });
+	} catch {
+		return { status: "error" };
+	}
+	if (!indexResult) return { status: "error" };
+	const byName = new Map(indexResult.entries.map((entry) => [entry.name, entry]));
+	const removedSkills = items.filter((item) => !byName.has(item.name)).map((item) => item.name);
+	const localNames = new Set(items.map((item) => item.name));
+	const newSkills = indexResult.entries.map((entry) => entry.name).filter((name) => !localNames.has(name));
+	const changedSkills = [];
+	const needsContentCheck = [];
+	for (const item of items) {
+		const entry = byName.get(item.name);
+		if (!entry) continue;
+		if (entry.version === "0.2.0") {
+			if (!item.digest || entry.digest !== item.digest) changedSkills.push(item.name);
+		} else needsContentCheck.push(item);
+	}
+	if (needsContentCheck.length > 0) {
+		const tracked = new Set(needsContentCheck.map((item) => item.name));
+		const skills = (await Promise.all(indexResult.entries.filter((entry) => tracked.has(entry.name)).map((entry) => wellKnownProvider.fetchSkillByEntry(entry).catch(() => null)))).filter((skill) => skill !== null);
+		if (skills.length === 0) return { status: "error" };
+		const digests = new Map(skills.map((skill) => [skill.installName, computeWellKnownSkillDigest(skill)]));
+		for (const item of needsContentCheck) {
+			const digest = digests.get(item.name);
+			if (!digest || !item.digest || digest !== item.digest) changedSkills.push(item.name);
+		}
+	}
+	if (changedSkills.length === 0 && removedSkills.length === 0) return {
+		status: "current",
+		newSkills
+	};
+	return {
+		status: "changed",
+		changedSkills,
+		removedSkills,
+		newSkills
+	};
+}
+function printNewSkills(baseUrl, newSkills, isGlobal) {
+	if (newSkills.length === 0) return;
+	const names = newSkills.map(sanitizeMetadata);
+	console.log(`  ${DIM$1}${newSkills.length} new skill(s) available from this source:${RESET$1} ${names.join(", ")}`);
+	console.log(`    ${DIM$1}To install: ${TEXT$1}npx skills add ${baseUrl} --skill ${names.join(" ")}${isGlobal ? " -g" : ""}${RESET$1}`);
+}
+async function processWellKnownUpdates(groups, isGlobal, options) {
+	let successCount = 0;
+	let failCount = 0;
+	let changed = false;
+	for (const [baseUrl, items] of groups) {
+		process.stdout.write(`\r${DIM$1}Checking skills from source: ${baseUrl}${RESET$1}\x1b[K\n`);
+		const result = await checkWellKnownForUpdates(baseUrl, items);
+		if (result.status === "error") {
+			console.log(`  ${DIM$1}✗ Failed to check skills from ${baseUrl}${RESET$1}`);
+			continue;
+		}
+		if (result.status === "current") {
+			printNewSkills(baseUrl, result.newSkills, isGlobal);
+			continue;
+		}
+		changed = true;
+		await promptDeletions(baseUrl, result.removedSkills, isGlobal, options);
+		printNewSkills(baseUrl, result.newSkills, isGlobal);
+		if (result.changedSkills.length === 0) continue;
+		const cliEntry = join(__dirname$1, "..", "bin", "cli.mjs");
+		if (!existsSync(cliEntry)) {
+			failCount += result.changedSkills.length;
+			console.log(`  ${DIM$1}✗ CLI entrypoint not found at ${cliEntry}${RESET$1}`);
+			continue;
+		}
+		const itemByName = new Map(items.map((item) => [item.name, item]));
+		for (const name of result.changedSkills) {
+			const safeName = sanitizeMetadata(name);
+			console.log(`${TEXT$1}Updating ${safeName}…${RESET$1}`);
+			const subagents = itemByName.get(name)?.subagents;
+			const subagentArgs = !isGlobal && subagents?.length ? ["--subagent", ...subagents.map((s) => s === "" ? "root" : s)] : [];
+			if (spawnSync(process.execPath, [
+				cliEntry,
+				"add",
+				baseUrl,
+				"--skill",
+				name,
+				...subagentArgs,
+				...isGlobal ? ["-g"] : [],
+				"-y"
+			], {
+				stdio: [
+					"inherit",
+					"pipe",
+					"pipe"
+				],
+				encoding: "utf-8",
+				shell: false
+			}).status === 0) {
+				successCount++;
+				console.log(`  ${TEXT$1}✓${RESET$1} Updated ${safeName}`);
+			} else {
+				failCount++;
+				console.log(`  ${DIM$1}✗ Failed to update ${safeName}${RESET$1}`);
 			}
 		}
 	}
-	return deletedSkills;
+	return {
+		successCount,
+		failCount,
+		changed
+	};
 }
 async function updateGlobalSkills(options = {}) {
 	const lock = await readSkillLock();
@@ -6267,10 +6451,20 @@ async function updateGlobalSkills(options = {}) {
 	const updates = [];
 	const skipped = [];
 	const checkable = [];
+	const wellKnownGroups = /* @__PURE__ */ new Map();
 	for (const skillName of skillNames) {
 		if (!matchesSkillFilter(skillName, options.skills)) continue;
 		const entry = lock.skills[skillName];
 		if (!entry) continue;
+		if (entry.sourceType === "well-known" && entry.sourceBaseUrl && entry.wellKnownDigest) {
+			const group = wellKnownGroups.get(entry.sourceBaseUrl) || [];
+			group.push({
+				name: skillName,
+				digest: entry.wellKnownDigest
+			});
+			wellKnownGroups.set(entry.sourceBaseUrl, group);
+			continue;
+		}
 		if (!entry.skillFolderHash || !entry.skillPath) {
 			skipped.push({
 				name: skillName,
@@ -6286,6 +6480,10 @@ async function updateGlobalSkills(options = {}) {
 			entry
 		});
 	}
+	const wellKnownCount = Array.from(wellKnownGroups.values()).reduce((sum, items) => sum + items.length, 0);
+	const { successCount: wkSuccessCount, failCount: wkFailCount, changed: wkChanged } = await processWellKnownUpdates(wellKnownGroups, true, options);
+	successCount += wkSuccessCount;
+	failCount += wkFailCount;
 	const bySource = /* @__PURE__ */ new Map();
 	for (const item of checkable) {
 		const source = item.entry.source;
@@ -6343,8 +6541,8 @@ async function updateGlobalSkills(options = {}) {
 		}
 	}
 	if (checkable.length > 0) process.stdout.write("\r\x1B[K");
-	const checkedCount = checkable.length + skipped.length;
-	if (checkable.length === 0 && skipped.length === 0) {
+	const checkedCount = checkable.length + skipped.length + wellKnownCount;
+	if (checkable.length === 0 && skipped.length === 0 && wellKnownCount === 0) {
 		if (!options.skills) console.log(`${DIM$1}No global skills to check.${RESET$1}`);
 		return {
 			successCount,
@@ -6352,6 +6550,14 @@ async function updateGlobalSkills(options = {}) {
 			checkedCount: 0
 		};
 	}
+	if (checkable.length === 0 && skipped.length === 0) {
+		if (!wkChanged) console.log(`${TEXT$1}✓ All global skills are up to date${RESET$1}`);
+		return {
+			successCount,
+			failCount,
+			checkedCount
+		};
+	}
 	if (checkable.length === 0 && skipped.length > 0) {
 		printSkippedSkills(skipped);
 		return {
@@ -6361,7 +6567,7 @@ async function updateGlobalSkills(options = {}) {
 		};
 	}
 	if (updates.length === 0) {
-		console.log(`${TEXT$1}✓ All global skills are up to date${RESET$1}`);
+		if (!wkChanged) console.log(`${TEXT$1}✓ All global skills are up to date${RESET$1}`);
 		return {
 			successCount,
 			failCount,
@@ -6390,6 +6596,8 @@ async function updateGlobalSkills(options = {}) {
 			cliEntry,
 			"add",
 			installUrl,
+			"--skill",
+			update.name,
 			...fullDepthArgs,
 			"-g",
 			"-y"
@@ -6400,6 +6608,7 @@ async function updateGlobalSkills(options = {}) {
 				"pipe"
 			],
 			encoding: "utf-8",
+			env: getUpdateChildEnv(update.entry.sourceType),
 			shell: false
 		}).status === 0) {
 			successCount++;
@@ -6431,9 +6640,24 @@ async function updateProjectSkills(options = {}) {
 			foundCount: 0
 		};
 	}
-	const updatable = projectSkills.filter((s) => s.entry.skillPath);
-	const legacy = projectSkills.filter((s) => !s.entry.skillPath);
-	if (updatable.length === 0) {
+	const wellKnownGroups = /* @__PURE__ */ new Map();
+	const nonWellKnown = [];
+	for (const skill of projectSkills) {
+		const { entry } = skill;
+		if (entry.sourceType === "well-known" && entry.sourceUrl && entry.wellKnownDigest) {
+			const group = wellKnownGroups.get(entry.sourceUrl) || [];
+			group.push({
+				name: skill.name,
+				digest: entry.wellKnownDigest,
+				subagents: entry.subagents
+			});
+			wellKnownGroups.set(entry.sourceUrl, group);
+		} else nonWellKnown.push(skill);
+	}
+	const wellKnownCount = Array.from(wellKnownGroups.values()).reduce((sum, items) => sum + items.length, 0);
+	const updatable = nonWellKnown.filter((s) => s.entry.skillPath);
+	const legacy = nonWellKnown.filter((s) => !s.entry.skillPath);
+	if (updatable.length === 0 && wellKnownCount === 0) {
 		console.log(`${DIM$1}No project skills can be updated in place.${RESET$1}`);
 		printLegacyProjectSkills(legacy);
 		return {
@@ -6455,8 +6679,11 @@ async function updateProjectSkills(options = {}) {
 	if (hasUniversal) targetParts.push("Universal");
 	targetParts.push(...targetAgentNames);
 	if (targetParts.length > 0) console.log(`${TEXT$1}Updating for: ${targetParts.join(", ")}${RESET$1}`);
-	console.log(`${TEXT$1}Refreshing ${updatable.length} skill(s)…${RESET$1}`);
+	console.log(`${TEXT$1}Refreshing ${updatable.length + wellKnownCount} skill(s)…${RESET$1}`);
 	console.log();
+	const { successCount: wkSuccessCount, failCount: wkFailCount } = await processWellKnownUpdates(wellKnownGroups, false, options);
+	successCount += wkSuccessCount;
+	failCount += wkFailCount;
 	const bySource = /* @__PURE__ */ new Map();
 	for (const skill of updatable) {
 		const source = skill.entry.sourceUrl || skill.entry.source;
@@ -6466,28 +6693,28 @@ async function updateProjectSkills(options = {}) {
 	}
 	const localLock = await readLocalLock();
 	const cliEntry = join(__dirname$1, "..", "bin", "cli.mjs");
-	if (!existsSync(cliEntry)) {
+	if (updatable.length > 0 && !existsSync(cliEntry)) {
 		console.log(`${DIM$1}✗ CLI entrypoint not found at ${cliEntry}${RESET$1}`);
 		return {
 			successCount,
-			failCount: updatable.length,
+			failCount: failCount + updatable.length,
 			foundCount: projectSkills.length
 		};
 	}
 	for (const [source, skillsForSource] of bySource) {
 		const firstEntry = skillsForSource[0].entry;
-		const sourceUrl = firstEntry.sourceUrl || firstEntry.source;
+		const cloneSource = buildLocalCloneSource(firstEntry);
 		const ref = firstEntry.ref;
 		const allLockedForSource = Object.entries(localLock.skills).filter(([_, entry]) => (entry.sourceUrl || entry.source) === source).map(([name, _]) => name);
 		let tempDir = null;
 		let deletedSkills = [];
-		if (buildLocalUpdateSource(firstEntry) === null) {
+		if (cloneSource === null) {
 			failCount += skillsForSource.length;
 			console.log(`${DIM$1}✗ Cannot update ${source}: skills-lock.json is missing sourceUrl for this generic Git source${RESET$1}`);
 			continue;
 		}
 		try {
-			tempDir = await cloneRepo(sourceUrl, ref);
+			tempDir = await cloneRepo(cloneSource, ref);
 			const discoveredPaths = (await discoverSkills(tempDir, void 0, { fullDepth: true })).map((s) => {
 				return join(relative(tempDir, s.path), "SKILL.md").split(sep).join("/");
 			});
@@ -6525,6 +6752,7 @@ async function updateProjectSkills(options = {}) {
 					"pipe"
 				],
 				encoding: "utf-8",
+				env: getUpdateChildEnv(skill.entry.sourceType),
 				shell: false
 			}).status === 0) {
 				successCount++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skills",
-  "version": "1.5.21",
+  "version": "1.5.22",
   "description": "The open agent skills ecosystem",
   "type": "module",
   "bin": {
@@ -81,6 +81,7 @@
     "lingma",
     "loaf",
     "mcpjam",
+    "minimax-code",
     "mistral-vibe",
     "moxby",
     "mux",