dimcode-darwin-x64 0.0.78 → 0.0.79-beta.0

package/bin/node_modules/skills/dist/cli.mjs

@@ -14,7 +14,8 @@ import { stripVTControlCharacters } from "node:util";
 import { homedir, platform, tmpdir } from "os";
 import * as readline from "readline";
 import { Writable } from "stream";
-import { execSync, spawnSync } from "child_process";
+import { promisify } from "util";
+import { execFile, execSync, spawn, spawnSync } from "child_process";
 import { access, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, realpath, rm, stat, symlink, writeFile } from "fs/promises";
 import { parse } from "yaml";
 import { createHash } from "crypto";
@@ -319,6 +320,7 @@ async function searchMultiselect(options) {
 					const lockedTitle = `${import_picocolors.default.bold(lockedSection.title)} ${import_picocolors.default.dim("── always included")}`;
 					lines.push(`${S_BAR}  ${S_BAR_H}${S_BAR_H} ${lockedTitle} ${S_BAR_H.repeat(12)}`);
 					for (const item of lockedSection.items) lines.push(`${S_BAR}    ${S_BULLET} ${import_picocolors.default.bold(item.label)}`);
+					if (lockedSection.hiddenCount && lockedSection.hiddenCount > 0) lines.push(`${S_BAR}    ${import_picocolors.default.dim(`...and ${lockedSection.hiddenCount} more`)}`);
 					lines.push(`${S_BAR}`);
 					lines.push(`${S_BAR}  ${S_BAR_H}${S_BAR_H} ${import_picocolors.default.bold("Additional agents")} ${S_BAR_H.repeat(29)}`);
 				}
@@ -434,6 +436,7 @@ const CLONE_TIMEOUT_MS = (() => {
 	const parsed = Number.parseInt(raw, 10);
 	return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_CLONE_TIMEOUT_MS;
 })();
+const execFileAsync = promisify(execFile);
 var GitCloneError = class extends Error {
 	url;
 	isTimeout;
@@ -446,14 +449,58 @@ var GitCloneError = class extends Error {
 		this.isAuthError = isAuthError;
 	}
 };
-async function cloneRepo(url, ref) {
-	const tempDir = await mkdtemp(join(tmpdir(), "skills-"));
-	const git = esm_default({
+function parseGitHubRepoUrl(url) {
+	const sshMatch = url.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/i);
+	if (sshMatch) {
+		const owner = sshMatch[1];
+		const repo = sshMatch[2];
+		return {
+			owner,
+			repo,
+			slug: `${owner}/${repo}`,
+			sshUrl: `git@github.com:${owner}/${repo}.git`
+		};
+	}
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "github.com") return null;
+		const match = parsed.pathname.match(/^\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
+		if (!match) return null;
+		const owner = match[1];
+		const repo = match[2];
+		return {
+			owner,
+			repo,
+			slug: `${owner}/${repo}`,
+			sshUrl: `git@github.com:${owner}/${repo}.git`
+		};
+	} catch {
+		return null;
+	}
+}
+function isGitHubHttpsCloneUrl(url) {
+	try {
+		const parsed = new URL(url);
+		return parsed.protocol === "https:" && parsed.hostname === "github.com";
+	} catch {
+		return false;
+	}
+}
+function isGitHubSsoAuthError(message) {
+	const lower = message.toLowerCase();
+	return lower.includes("saml sso") || lower.includes("enforced sso") || lower.includes("enabled or enforced saml") || lower.includes("re-authorize the oauth application");
+}
+function isAuthFailure(message) {
+	return message.includes("Authentication failed") || message.includes("could not read Username") || message.includes("Permission denied") || message.includes("Repository not found") || message.includes("requested URL returned error: 403") || isGitHubSsoAuthError(message);
+}
+function createGitClient(extraEnv) {
+	return esm_default({
 		timeout: { block: CLONE_TIMEOUT_MS },
 		env: {
 			...process.env,
 			GIT_TERMINAL_PROMPT: "0",
-			GIT_LFS_SKIP_SMUDGE: "1"
+			GIT_LFS_SKIP_SMUDGE: "1",
+			...extraEnv
 		},
 		config: [
 			"filter.lfs.required=false",
@@ -462,25 +509,98 @@ async function cloneRepo(url, ref) {
 			"filter.lfs.process="
 		]
 	});
+}
+async function resetTempDir(dir) {
+	await rm(dir, {
+		recursive: true,
+		force: true
+	}).catch(() => {});
+	await mkdir(dir, { recursive: true });
+}
+async function tryGhClone(repo, tempDir, ref) {
+	let cloneTarget = repo.slug;
+	try {
+		const { stdout, stderr } = await execFileAsync("gh", [
+			"auth",
+			"status",
+			"-h",
+			"github.com"
+		], {
+			timeout: 5e3,
+			env: {
+				...process.env,
+				GIT_TERMINAL_PROMPT: "0"
+			}
+		});
+		const statusOutput = `${stdout}${stderr}`;
+		if (/Git operations protocol:\s+ssh/i.test(statusOutput)) cloneTarget = repo.sshUrl;
+	} catch {
+		return false;
+	}
+	await execFileAsync("gh", [
+		"repo",
+		"clone",
+		cloneTarget,
+		tempDir,
+		"--",
+		...ref ? [
+			"--depth=1",
+			"--branch",
+			ref
+		] : ["--depth=1"]
+	], {
+		timeout: CLONE_TIMEOUT_MS,
+		env: {
+			...process.env,
+			GIT_TERMINAL_PROMPT: "0"
+		}
+	});
+	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`;
+	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) {
+	const tempDir = await mkdtemp(join(tmpdir(), "skills-"));
 	const cloneOptions = ref ? [
 		"--depth",
 		"1",
 		"--branch",
 		ref
 	] : ["--depth", "1"];
+	const repo = parseGitHubRepoUrl(url);
 	try {
-		await git.clone(url, tempDir, cloneOptions);
+		await createGitClient().clone(url, tempDir, cloneOptions);
 		return tempDir;
 	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		const isTimeout = errorMessage.includes("block timeout") || errorMessage.includes("timed out");
+		const isAuthError = isAuthFailure(errorMessage);
+		if (isTimeout) {
+			await rm(tempDir, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+			throw new GitCloneError(`Clone timed out after ${Math.round(CLONE_TIMEOUT_MS / 1e3)}s. Common causes:\n  - Large repository: raise the timeout with SKILLS_CLONE_TIMEOUT_MS=600000 (10m)\n  - Slow network: retry, or clone manually and pass the local path to 'skills add'\n  - Private repo without credentials: ensure auth is configured\n      - For SSH: ssh-add -l (to check loaded keys)\n      - For HTTPS: gh auth status (if using GitHub CLI)`, url, true, false);
+		}
+		if (isAuthError && repo && isGitHubHttpsCloneUrl(url)) {
+			try {
+				await resetTempDir(tempDir);
+				if (await tryGhClone(repo, tempDir, ref)) return tempDir;
+			} catch {}
+			try {
+				await resetTempDir(tempDir);
+				await createGitClient({ GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND ?? "ssh -o BatchMode=yes" }).clone(repo.sshUrl, tempDir, cloneOptions);
+				return tempDir;
+			} catch {}
+		}
 		await rm(tempDir, {
 			recursive: true,
 			force: true
 		}).catch(() => {});
-		const errorMessage = error instanceof Error ? error.message : String(error);
-		const isTimeout = errorMessage.includes("block timeout") || errorMessage.includes("timed out");
-		const isAuthError = errorMessage.includes("Authentication failed") || errorMessage.includes("could not read Username") || errorMessage.includes("Permission denied") || errorMessage.includes("Repository not found");
-		if (isTimeout) throw new GitCloneError(`Clone timed out after ${Math.round(CLONE_TIMEOUT_MS / 1e3)}s. Common causes:\n  - Large repository: raise the timeout with SKILLS_CLONE_TIMEOUT_MS=600000 (10m)\n  - Slow network: retry, or clone manually and pass the local path to 'skills add'\n  - Private repo without credentials: ensure auth is configured\n      - For SSH: ssh-add -l (to check loaded keys)\n      - For HTTPS: gh auth status (if using GitHub CLI)`, url, true, false);
-		if (isAuthError) throw new GitCloneError(`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`, url, false, true);
+		if (isAuthError) throw new GitCloneError(buildGitHubAuthError(url, repo, errorMessage), url, false, true);
 		throw new GitCloneError(`Failed to clone ${url}: ${errorMessage}`, url, false, false);
 	}
 }
@@ -818,6 +938,8 @@ const configHome = xdgConfig ?? join(home, ".config");
 const codexHome = process.env.CODEX_HOME?.trim() || join(home, ".codex");
 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 zedAppDataHome = process.env.APPDATA?.trim();
 const zedFlatpakConfigHome = process.env.FLATPAK_XDG_CONFIG_HOME?.trim();
 function getOpenClawGlobalSkillsDir(homeDir = home, pathExists = existsSync) {
@@ -854,6 +976,33 @@ const agents = {
 			return existsSync(join(home, ".gemini/antigravity"));
 		}
 	},
+	"antigravity-cli": {
+		name: "antigravity-cli",
+		displayName: "Antigravity CLI",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join(home, ".gemini/antigravity-cli/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".gemini/antigravity-cli"));
+		}
+	},
+	astrbot: {
+		name: "astrbot",
+		displayName: "AstrBot",
+		skillsDir: "data/skills",
+		globalSkillsDir: join(home, ".astrbot/data/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(process.cwd(), "data/skills")) || existsSync(join(home, ".astrbot"));
+		}
+	},
+	"autohand-code": {
+		name: "autohand-code",
+		displayName: "Autohand Code CLI",
+		skillsDir: ".autohand/skills",
+		globalSkillsDir: join(autohandHome, "skills"),
+		detectInstalled: async () => {
+			return existsSync(autohandHome);
+		}
+	},
 	augment: {
 		name: "augment",
 		displayName: "Augment",
@@ -1012,6 +1161,7 @@ const agents = {
 		displayName: "Dexto",
 		skillsDir: ".agents/skills",
 		globalSkillsDir: join(home, ".agents/skills"),
+		showInUniversalPrompt: false,
 		detectInstalled: async () => {
 			return existsSync(join(home, ".dexto"));
 		}
@@ -1030,6 +1180,7 @@ const agents = {
 		displayName: "Firebender",
 		skillsDir: ".agents/skills",
 		globalSkillsDir: join(home, ".firebender/skills"),
+		showInUniversalPrompt: false,
 		detectInstalled: async () => {
 			return existsSync(join(home, ".firebender"));
 		}
@@ -1074,9 +1225,27 @@ const agents = {
 		name: "hermes-agent",
 		displayName: "Hermes Agent",
 		skillsDir: ".hermes/skills",
-		globalSkillsDir: join(home, ".hermes/skills"),
+		globalSkillsDir: join(hermesHome, "skills"),
 		detectInstalled: async () => {
-			return existsSync(join(home, ".hermes"));
+			return existsSync(hermesHome);
+		}
+	},
+	"inference-sh": {
+		name: "inference-sh",
+		displayName: "inference.sh",
+		skillsDir: ".inferencesh/skills",
+		globalSkillsDir: join(home, ".inferencesh/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".inferencesh"));
+		}
+	},
+	jazz: {
+		name: "jazz",
+		displayName: "Jazz",
+		skillsDir: ".jazz/skills",
+		globalSkillsDir: join(home, ".jazz/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".jazz")) || existsSync(join(process.cwd(), ".jazz"));
 		}
 	},
 	junie: {
@@ -1106,13 +1275,13 @@ const agents = {
 			return existsSync(join(home, ".kilocode"));
 		}
 	},
-	"kimi-cli": {
-		name: "kimi-cli",
+	"kimi-code-cli": {
+		name: "kimi-code-cli",
 		displayName: "Kimi Code CLI",
 		skillsDir: ".agents/skills",
-		globalSkillsDir: join(home, ".config/agents/skills"),
+		globalSkillsDir: join(home, ".agents/skills"),
 		detectInstalled: async () => {
-			return existsSync(join(home, ".kimi"));
+			return existsSync(join(home, ".kimi-code")) || existsSync(join(home, ".kimi"));
 		}
 	},
 	"kiro-cli": {
@@ -1133,6 +1302,25 @@ const agents = {
 			return existsSync(join(home, ".kode"));
 		}
 	},
+	lingma: {
+		name: "lingma",
+		displayName: "Lingma",
+		skillsDir: ".lingma/skills",
+		globalSkillsDir: join(home, ".lingma/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".lingma"));
+		}
+	},
+	loaf: {
+		name: "loaf",
+		displayName: "Loaf",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join(home, ".agents/skills"),
+		showInUniversalPrompt: false,
+		detectInstalled: async () => {
+			return existsSync(join(home, ".loaf"));
+		}
+	},
 	mcpjam: {
 		name: "mcpjam",
 		displayName: "MCPJam",
@@ -1151,6 +1339,15 @@ const agents = {
 			return existsSync(vibeHome);
 		}
 	},
+	moxby: {
+		name: "moxby",
+		displayName: "Moxby",
+		skillsDir: ".moxby/skills",
+		globalSkillsDir: join(home, ".moxby/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".moxby"));
+		}
+	},
 	mux: {
 		name: "mux",
 		displayName: "Mux",
@@ -1178,6 +1375,15 @@ const agents = {
 			return existsSync(join(home, ".openhands"));
 		}
 	},
+	ona: {
+		name: "ona",
+		displayName: "Ona",
+		skillsDir: ".ona/skills",
+		globalSkillsDir: join(home, ".ona/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".ona"));
+		}
+	},
 	pi: {
 		name: "pi",
 		displayName: "Pi",
@@ -1196,6 +1402,15 @@ const agents = {
 			return existsSync(join(home, ".qoder"));
 		}
 	},
+	"qoder-cn": {
+		name: "qoder-cn",
+		displayName: "Qoder CN",
+		skillsDir: ".qoder/skills",
+		globalSkillsDir: join(home, ".qoder-cn/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".qoder-cn"));
+		}
+	},
 	"qwen-code": {
 		name: "qwen-code",
 		displayName: "Qwen Code",
@@ -1215,6 +1430,15 @@ const agents = {
 			return existsSync(join(process.cwd(), ".replit"));
 		}
 	},
+	reasonix: {
+		name: "reasonix",
+		displayName: "Reasonix",
+		skillsDir: ".reasonix/skills",
+		globalSkillsDir: join(home, ".reasonix/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".reasonix"));
+		}
+	},
 	rovodev: {
 		name: "rovodev",
 		displayName: "Rovo Dev",
@@ -1242,6 +1466,24 @@ const agents = {
 			return existsSync(join(home, ".tabnine"));
 		}
 	},
+	terramind: {
+		name: "terramind",
+		displayName: "Terramind",
+		skillsDir: ".terramind/skills",
+		globalSkillsDir: join(home, ".terramind/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".terramind"));
+		}
+	},
+	tinycloud: {
+		name: "tinycloud",
+		displayName: "Tinycloud",
+		skillsDir: ".tinycloud/skills",
+		globalSkillsDir: join(home, ".tinycloud/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".tinycloud"));
+		}
+	},
 	trae: {
 		name: "trae",
 		displayName: "Trae",
@@ -1296,6 +1538,15 @@ const agents = {
 			return existsSync(join(home, ".zencoder"));
 		}
 	},
+	zenflow: {
+		name: "zenflow",
+		displayName: "Zenflow",
+		skillsDir: ".zencoder/skills",
+		globalSkillsDir: join(home, ".zencoder/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".zencoder"));
+		}
+	},
 	neovate: {
 		name: "neovate",
 		displayName: "Neovate",
@@ -1314,6 +1565,16 @@ const agents = {
 			return existsSync(join(home, ".pochi"));
 		}
 	},
+	promptscript: {
+		name: "promptscript",
+		displayName: "PromptScript",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: void 0,
+		showInUniversalPrompt: false,
+		detectInstalled: async () => {
+			return existsSync(join(process.cwd(), ".promptscript")) || existsSync(join(process.cwd(), "promptscript.yaml"));
+		}
+	},
 	adal: {
 		name: "adal",
 		displayName: "AdaL",
@@ -1341,6 +1602,9 @@ async function detectInstalledAgents() {
 function getUniversalAgents() {
 	return Object.entries(agents).filter(([_, config]) => config.skillsDir === ".agents/skills" && config.showInUniversalList !== false).map(([type]) => type);
 }
+function getVisibleUniversalAgents() {
+	return Object.entries(agents).filter(([_, config]) => config.skillsDir === ".agents/skills" && config.showInUniversalList !== false && config.showInUniversalPrompt !== false).map(([type]) => type);
+}
 function getNonUniversalAgents() {
 	return Object.entries(agents).filter(([_, config]) => config.skillsDir !== ".agents/skills").map(([type]) => type);
 }
@@ -1352,7 +1616,7 @@ const SKILLS_SUBDIR = "skills";
 function sanitizeName(name) {
 	return name.toLowerCase().replace(/[^a-z0-9._]+/g, "-").replace(/^[.\-]+|[.\-]+$/g, "").substring(0, 255) || "unnamed-skill";
 }
-function isPathSafe(basePath, targetPath) {
+function isPathSafe$1(basePath, targetPath) {
 	const normalizedBase = normalize(resolve(basePath));
 	const normalizedTarget = normalize(resolve(targetPath));
 	return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
@@ -1442,13 +1706,13 @@ async function installSkillForAgent(skill, agentType, options = {}) {
 	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd);
 	const agentDir = join(agentBase, skillName);
 	const installMode = options.mode ?? "symlink";
-	if (!isPathSafe(canonicalBase, canonicalDir)) return {
+	if (!isPathSafe$1(canonicalBase, canonicalDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
-	if (!isPathSafe(agentBase, agentDir)) return {
+	if (!isPathSafe$1(agentBase, agentDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
@@ -1507,21 +1771,21 @@ async function installSkillForAgent(skill, agentType, options = {}) {
 		};
 	}
 }
-const EXCLUDE_FILES = new Set(["metadata.json"]);
-const EXCLUDE_DIRS = new Set([
+const EXCLUDE_FILES$1 = new Set(["metadata.json"]);
+const EXCLUDE_DIRS$1 = new Set([
 	".git",
 	"__pycache__",
 	"__pypackages__"
 ]);
-const isExcluded = (name, isDirectory = false) => {
-	if (EXCLUDE_FILES.has(name)) return true;
-	if (isDirectory && EXCLUDE_DIRS.has(name)) return true;
+const isExcluded$1 = (name, isDirectory = false) => {
+	if (EXCLUDE_FILES$1.has(name)) return true;
+	if (isDirectory && EXCLUDE_DIRS$1.has(name)) return true;
 	return false;
 };
 async function copyDirectory(src, dest) {
 	await mkdir(dest, { recursive: true });
 	const entries = await readdir(src, { withFileTypes: true });
-	await Promise.all(entries.filter((entry) => !isExcluded(entry.name, entry.isDirectory())).map(async (entry) => {
+	await Promise.all(entries.filter((entry) => !isExcluded$1(entry.name, entry.isDirectory())).map(async (entry) => {
 		const srcPath = join(src, entry.name);
 		const destPath = join(dest, entry.name);
 		if (entry.isDirectory()) await copyDirectory(srcPath, destPath);
@@ -1542,7 +1806,7 @@ async function isSkillInstalled(skillName, agentType, options = {}) {
 	if (options.global && agent.globalSkillsDir === void 0) return false;
 	const targetBase = options.global ? agent.globalSkillsDir : join(options.cwd || process.cwd(), agent.skillsDir);
 	const skillDir = join(targetBase, sanitized);
-	if (!isPathSafe(targetBase, skillDir)) return false;
+	if (!isPathSafe$1(targetBase, skillDir)) return false;
 	try {
 		await access(skillDir);
 		return true;
@@ -1556,14 +1820,14 @@ function getInstallPath(skillName, agentType, options = {}) {
 	const sanitized = sanitizeName(skillName);
 	const targetBase = getAgentBaseDir(agentType, options.global ?? false, options.cwd);
 	const installPath = join(targetBase, sanitized);
-	if (!isPathSafe(targetBase, installPath)) throw new Error("Invalid skill name: potential path traversal detected");
+	if (!isPathSafe$1(targetBase, installPath)) throw new Error("Invalid skill name: potential path traversal detected");
 	return installPath;
 }
 function getCanonicalPath(skillName, options = {}) {
 	const sanitized = sanitizeName(skillName);
 	const canonicalBase = getCanonicalSkillsDir(options.global ?? false, options.cwd);
 	const canonicalPath = join(canonicalBase, sanitized);
-	if (!isPathSafe(canonicalBase, canonicalPath)) throw new Error("Invalid skill name: potential path traversal detected");
+	if (!isPathSafe$1(canonicalBase, canonicalPath)) throw new Error("Invalid skill name: potential path traversal detected");
 	return canonicalPath;
 }
 async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
@@ -1582,13 +1846,13 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 	const canonicalDir = join(canonicalBase, skillName);
 	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd);
 	const agentDir = join(agentBase, skillName);
-	if (!isPathSafe(canonicalBase, canonicalDir)) return {
+	if (!isPathSafe$1(canonicalBase, canonicalDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
-	if (!isPathSafe(agentBase, agentDir)) return {
+	if (!isPathSafe$1(agentBase, agentDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
@@ -1597,7 +1861,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(targetDir, fullPath)) continue;
+			if (!isPathSafe$1(targetDir, fullPath)) continue;
 			const parentDir = dirname(fullPath);
 			if (parentDir !== targetDir) await mkdir(parentDir, { recursive: true });
 			await writeFile(fullPath, content);
@@ -1663,13 +1927,13 @@ async function installBlobSkillForAgent(skill, agentType, options = {}) {
 	const canonicalDir = join(canonicalBase, skillName);
 	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd);
 	const agentDir = join(agentBase, skillName);
-	if (!isPathSafe(canonicalBase, canonicalDir)) return {
+	if (!isPathSafe$1(canonicalBase, canonicalDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
-	if (!isPathSafe(agentBase, agentDir)) return {
+	if (!isPathSafe$1(agentBase, agentDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
@@ -1678,7 +1942,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(targetDir, fullPath)) continue;
+			if (!isPathSafe$1(targetDir, fullPath)) continue;
 			const parentDir = dirname(fullPath);
 			if (parentDir !== targetDir) await mkdir(parentDir, { recursive: true });
 			await writeFile(fullPath, file.contents, "utf-8");
@@ -1810,7 +2074,7 @@ async function listInstalledSkills(options = {}) {
 			for (const agentType of agentsToCheck) {
 				const agent = agents[agentType];
 				if (scope.global && agent.globalSkillsDir === void 0) continue;
-				const agentBase = scope.global ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
+				const agentBase = getAgentBaseDir(agentType, scope.global, cwd);
 				let found = false;
 				const possibleNames = Array.from(new Set([
 					entry.name,
@@ -1819,7 +2083,7 @@ async function listInstalledSkills(options = {}) {
 				]));
 				for (const possibleName of possibleNames) {
 					const agentSkillDir = join(agentBase, possibleName);
-					if (!isPathSafe(agentBase, agentSkillDir)) continue;
+					if (!isPathSafe$1(agentBase, agentSkillDir)) continue;
 					try {
 						await access(agentSkillDir);
 						found = true;
@@ -1831,7 +2095,7 @@ async function listInstalledSkills(options = {}) {
 					for (const agentEntry of agentEntries) {
 						const candidateDir = join(agentBase, agentEntry.name);
 						if (!await isDirEntryOrSymlinkToDir(agentEntry, candidateDir)) continue;
-						if (!isPathSafe(agentBase, candidateDir)) continue;
+						if (!isPathSafe$1(agentBase, candidateDir)) continue;
 						try {
 							const candidateSkillMd = join(candidateDir, "SKILL.md");
 							await stat(candidateSkillMd);
@@ -2754,7 +3018,7 @@ async function tryBlobInstall(ownerRepo, options = {}) {
 		tree
 	};
 }
-var version$1 = "1.5.9";
+var version$1 = "1.5.10";
 const isCancelled$1 = (value) => typeof value === "symbol";
 async function isSourcePrivate(source) {
 	const ownerRepo = parseOwnerRepo(source);
@@ -2894,13 +3158,15 @@ async function promptForAgents(message, choices) {
 async function selectAgentsInteractive(options) {
 	const supportsGlobalFilter = (a) => !options.global || agents[a].globalSkillsDir;
 	const universalAgents = getUniversalAgents().filter(supportsGlobalFilter);
+	const visibleUniversalAgents = getVisibleUniversalAgents().filter(supportsGlobalFilter);
 	const otherAgents = getNonUniversalAgents().filter(supportsGlobalFilter);
 	const universalSection = {
 		title: "Universal (.agents/skills)",
-		items: universalAgents.map((a) => ({
+		items: visibleUniversalAgents.map((a) => ({
 			value: a,
 			label: agents[a].displayName
-		}))
+		})),
+		hiddenCount: universalAgents.length - visibleUniversalAgents.length
 	};
 	const otherChoices = otherAgents.map((a) => ({
 		value: a,
@@ -4210,6 +4476,7 @@ async function runSync(args, options = {}) {
 	let targetAgents;
 	const validAgents = Object.keys(agents);
 	const universalAgents = getUniversalAgents();
+	const visibleUniversalAgents = getVisibleUniversalAgents();
 	if (options.agent?.includes("*")) {
 		targetAgents = validAgents;
 		M.info(`Installing to all ${targetAgents.length} agents`);
@@ -4240,10 +4507,11 @@ async function runSync(args, options = {}) {
 				initialSelected: [],
 				lockedSection: {
 					title: "Universal (.agents/skills)",
-					items: universalAgents.map((a) => ({
+					items: visibleUniversalAgents.map((a) => ({
 						value: a,
 						label: agents[a].displayName
-					}))
+					})),
+					hiddenCount: universalAgents.length - visibleUniversalAgents.length
 				}
 			});
 			if (isCancelled(selected)) {
@@ -4266,10 +4534,11 @@ async function runSync(args, options = {}) {
 				initialSelected: installedAgents.filter((a) => !universalAgents.includes(a)),
 				lockedSection: {
 					title: "Universal (.agents/skills)",
-					items: universalAgents.map((a) => ({
+					items: visibleUniversalAgents.map((a) => ({
 						value: a,
 						label: agents[a].displayName
-					}))
+					})),
+					hiddenCount: universalAgents.length - visibleUniversalAgents.length
 				}
 			});
 			if (isCancelled(selected)) {
@@ -4500,13 +4769,14 @@ async function runList(args) {
 		else console.log(`${DIM$2}Try listing global skills with -g${RESET$2}`);
 		return;
 	}
-	function printSkill(skill, indent = false) {
+	function printSkill(skill, indent = false, maxNameLength = 0, maxPathLength = 0) {
 		const prefix = indent ? "  " : "";
 		const shortPath = shortenPath(skill.canonicalPath, cwd);
 		const agentNames = skill.agents.map((a) => agents[a].displayName);
 		const agentInfo = skill.agents.length > 0 ? formatList(agentNames) : `${YELLOW}not linked${RESET$2}`;
-		console.log(`${prefix}${CYAN}${sanitizeMetadata(skill.name)}${RESET$2} ${DIM$2}${shortPath}${RESET$2}`);
-		console.log(`${prefix}  ${DIM$2}Agents:${RESET$2} ${agentInfo}`);
+		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}`);
 	}
 	console.log(`${BOLD$2}${scopeLabel} Skills${RESET$2}`);
 	console.log();
@@ -4526,16 +4796,42 @@ async function runList(args) {
 			const title = group.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
 			console.log(`${BOLD$2}${title}${RESET$2}`);
 			const skills = groupedSkills[group];
-			if (skills) for (const skill of skills) printSkill(skill, true);
+			if (skills) {
+				let maxNameLength = 0;
+				let maxPathLength = 0;
+				for (const skill of skills) {
+					const nameLength = sanitizeMetadata(skill.name).length;
+					const pathLength = shortenPath(skill.canonicalPath, cwd).length;
+					if (nameLength > maxNameLength) maxNameLength = nameLength;
+					if (pathLength > maxPathLength) maxPathLength = pathLength;
+				}
+				for (const skill of skills) printSkill(skill, true, maxNameLength, maxPathLength);
+			}
 			console.log();
 		}
 		if (ungroupedSkills.length > 0) {
 			console.log(`${BOLD$2}General${RESET$2}`);
-			for (const skill of ungroupedSkills) printSkill(skill, true);
+			let maxNameLength = 0;
+			let maxPathLength = 0;
+			for (const skill of ungroupedSkills) {
+				const nameLength = sanitizeMetadata(skill.name).length;
+				const pathLength = shortenPath(skill.canonicalPath, cwd).length;
+				if (nameLength > maxNameLength) maxNameLength = nameLength;
+				if (pathLength > maxPathLength) maxPathLength = pathLength;
+			}
+			for (const skill of ungroupedSkills) printSkill(skill, true, maxNameLength, maxPathLength);
 			console.log();
 		}
 	} else {
-		for (const skill of installedSkills) printSkill(skill);
+		let maxNameLength = 0;
+		let maxPathLength = 0;
+		for (const skill of installedSkills) {
+			const nameLength = sanitizeMetadata(skill.name).length;
+			const pathLength = shortenPath(skill.canonicalPath, cwd).length;
+			if (nameLength > maxNameLength) maxNameLength = nameLength;
+			if (pathLength > maxPathLength) maxPathLength = pathLength;
+		}
+		for (const skill of installedSkills) printSkill(skill, false, maxNameLength, maxPathLength);
 		console.log();
 	}
 }
@@ -4745,7 +5041,19 @@ function deriveSkillFolder(skillPath) {
 	if (folder.endsWith("/")) folder = folder.slice(0, -1);
 	return folder;
 }
+function supportsAppendedSubpath(source) {
+	if (source.startsWith("git@")) return false;
+	if (source.endsWith(".git")) return false;
+	if (source.startsWith("http://") || source.startsWith("https://")) try {
+		const host = new URL(source).hostname;
+		return host === "github.com" || host === "gitlab.com";
+	} catch {
+		return false;
+	}
+	return true;
+}
 function appendFolderAndRef(source, skillPath, ref) {
+	if (!supportsAppendedSubpath(source)) return formatSourceInput(source, ref);
 	const folder = deriveSkillFolder(skillPath);
 	const withFolder = folder ? `${source}/${folder}` : source;
 	return ref ? `${withFolder}#${ref}` : withFolder;
@@ -4946,13 +5254,21 @@ async function updateGlobalSkills(options = {}) {
 	}
 	for (const [source, itemsForSource] of bySource) {
 		const firstEntry = itemsForSource[0].entry;
+		const sourceUrl = firstEntry.sourceUrl || firstEntry.source;
+		let tempDir = null;
 		process.stdout.write(`\r${DIM$1}Checking skills from source: ${source}${RESET$1}\x1b[K\n`);
 		try {
-			const tree = await fetchRepoTree(source, firstEntry.ref, getGitHubToken);
-			if (tree) {
+			if (firstEntry.sourceType === "github") {
+				const tree = await fetchRepoTree(source, firstEntry.ref, getGitHubToken);
+				if (!tree) {
+					console.log(`  ${DIM$1}✗ Failed to fetch tree for ${source}${RESET$1}`);
+					continue;
+				}
 				const discoveredPaths = findSkillMdPaths(tree);
-				await checkAndPromptForDeletions(source, Object.entries(lock.skills).filter(([_, entry]) => entry.source === source).map(([name, _]) => name), lock.skills, true, options, discoveredPaths);
+				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) {
+					if (deletedSkillSet.has(skillName)) continue;
 					const latestHash = getSkillFolderHashFromTree(tree, entry.skillPath);
 					if (latestHash && latestHash !== entry.skillFolderHash) updates.push({
 						name: skillName,
@@ -4960,9 +5276,29 @@ async function updateGlobalSkills(options = {}) {
 						entry
 					});
 				}
-			} else console.log(`  ${DIM$1}✗ Failed to fetch tree for ${source}${RESET$1}`);
+				continue;
+			}
+			tempDir = await cloneRepo(sourceUrl, firstEntry.ref);
+			const discoveredPaths = (await discoverSkills(tempDir)).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);
+			const deletedSkillSet = new Set(deletedSkills);
+			for (const { name: skillName, entry } of itemsForSource) {
+				if (deletedSkillSet.has(skillName)) continue;
+				const skillPath = entry.skillPath;
+				if (!discoveredPaths.includes(skillPath)) continue;
+				const latestHash = await computeSkillFolderHash(join(tempDir, dirname(skillPath)));
+				if (latestHash && latestHash !== entry.skillFolderHash) updates.push({
+					name: skillName,
+					source,
+					entry
+				});
+			}
 		} catch (error) {
-			console.log(`  ${DIM$1}✗ Error checking skills from ${source}${RESET$1}`);
+			console.log(`  ${DIM$1}✗ Failed to check skills from ${source}${RESET$1}`);
+		} finally {
+			if (tempDir) await cleanupTempDir(tempDir);
 		}
 	}
 	if (checkable.length > 0) process.stdout.write("\r\x1B[K");
@@ -5191,6 +5527,368 @@ async function runUpdate(args = []) {
 	});
 	console.log();
 }
+const BLOB_ALLOWED_OWNERS = [
+	"vercel",
+	"vercel-labs",
+	"heygen-com"
+];
+const EXCLUDE_FILES = new Set(["metadata.json"]);
+const EXCLUDE_DIRS = new Set([
+	".git",
+	"__pycache__",
+	"__pypackages__"
+]);
+const USE_AGENT_CONFIGS = {
+	"claude-code": {
+		command: "claude",
+		args: []
+	},
+	codex: {
+		command: "codex",
+		args: []
+	}
+};
+const SUPPORTED_USE_AGENTS = Object.keys(USE_AGENT_CONFIGS);
+function parseUseOptions(args) {
+	const source = [];
+	const options = {};
+	const errors = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (!arg) continue;
+		if (arg === "--help" || arg === "-h") options.help = true;
+		else if (arg === "--full-depth") options.fullDepth = true;
+		else if (arg === "--dangerously-accept-openclaw-risks") options.dangerouslyAcceptOpenclawRisks = true;
+		else if (arg === "--skill" || arg === "-s") {
+			const value = args[i + 1];
+			if (!value || value.startsWith("-")) errors.push(`${arg} requires a skill name`);
+			else if (options.skill) {
+				errors.push("Only one --skill value can be provided");
+				i++;
+			} else {
+				options.skill = value;
+				i++;
+			}
+		} else if (arg === "--agent" || arg === "-a") {
+			options.agent = options.agent || [];
+			i++;
+			let nextArg = args[i];
+			const startCount = options.agent.length;
+			while (i < args.length && nextArg && !nextArg.startsWith("-")) {
+				options.agent.push(nextArg);
+				i++;
+				nextArg = args[i];
+			}
+			if (options.agent.length === startCount) errors.push(`${arg} requires an agent name`);
+			i--;
+		} else if (arg.startsWith("-")) errors.push(`Unknown option: ${arg}`);
+		else source.push(arg);
+	}
+	errors.push(...validateUseAgentOption(options.agent));
+	return {
+		source,
+		options,
+		errors
+	};
+}
+function buildUsePrompt(input) {
+	const sections = [
+		"You are being given a Skill to execute for the user's next request.",
+		"Use the following SKILL.md as your instructions:",
+		`<SKILL.md>\n${input.skillMd}\n</SKILL.md>`
+	];
+	if (input.hasSupportingFiles && input.supportDir) sections.push(`Supporting files for this skill were downloaded to:\n${input.supportDir}\n\nWhen the SKILL.md references relative paths, read them from that directory.`);
+	return sections.join("\n\n") + "\n";
+}
+async function materializeUseSkill(skill) {
+	const tempRoot = await mkdtemp(join(tmpdir(), "skills-use-"));
+	const skillDir = join(tempRoot, sanitizeName(skill.directoryName || skill.name));
+	if (!isPathSafe(tempRoot, skillDir)) throw new Error("Invalid skill name: potential path traversal detected");
+	await mkdir(skillDir, { recursive: true });
+	if (skill.kind === "blob") await writeSnapshotFiles(skillDir, skill.files);
+	else if (skill.kind === "well-known") await writeMapFiles(skillDir, skill.files);
+	else await copySkillDirectory(skill.path, skillDir);
+	return {
+		tempRoot,
+		skillDir,
+		skillMd: skill.rawContent ?? await readFile(join(skillDir, "SKILL.md"), "utf-8"),
+		hasSupportingFiles: await containsSupportingFiles(skillDir, skillDir)
+	};
+}
+async function runUse(sourceArgs, options = {}, parseErrors = []) {
+	let cloneTempDir = null;
+	try {
+		if (options.help) {
+			console.log(getUseHelp());
+			return;
+		}
+		if (parseErrors.length > 0) fail(parseErrors.join("\n"));
+		if (sourceArgs.length === 0) fail(`Missing required argument: source\n\n${getUseHelp()}`);
+		if (sourceArgs.length > 1) fail(`Expected one source, received ${sourceArgs.length}: ${sourceArgs.join(", ")}`);
+		const useAgent = options.agent?.[0];
+		if (useAgent && !USE_AGENT_CONFIGS[useAgent]) fail(formatUnsupportedAgentError(useAgent));
+		const source = sourceArgs[0];
+		const parsed = parseSource(source);
+		if (getOwnerRepo(parsed)?.split("/")[0]?.toLowerCase() === "openclaw" && !options.dangerouslyAcceptOpenclawRisks) fail([
+			"OpenClaw skills are unverified community submissions.",
+			"Skills run with full agent permissions and could be malicious.",
+			`If you understand the risks, re-run with: skills use ${source} --dangerously-accept-openclaw-risks`
+		].join("\n"));
+		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 {
+			let skills;
+			let blobResult = null;
+			if (parsed.type === "local") {
+				if (!existsSync(parsed.localPath)) fail(`Local path does not exist: ${parsed.localPath}`);
+				skills = await discoverSkills(parsed.localPath, parsed.subpath, {
+					includeInternal,
+					fullDepth: options.fullDepth
+				});
+			} else if (parsed.type === "github" && !options.fullDepth) {
+				const ownerRepo = getOwnerRepo(parsed);
+				const owner = ownerRepo?.split("/")[0]?.toLowerCase();
+				if (ownerRepo && owner && BLOB_ALLOWED_OWNERS.includes(owner)) blobResult = await tryBlobInstall(ownerRepo, {
+					subpath: parsed.subpath,
+					skillFilter: selector,
+					ref: parsed.ref,
+					getToken: getGitHubToken,
+					includeInternal
+				});
+				if (blobResult) skills = blobResult.skills;
+				else {
+					cloneTempDir = await cloneRepo(parsed.url, parsed.ref);
+					skills = await discoverSkills(cloneTempDir, parsed.subpath, {
+						includeInternal,
+						fullDepth: options.fullDepth
+					});
+				}
+			} else {
+				cloneTempDir = await cloneRepo(parsed.url, parsed.ref);
+				skills = await discoverSkills(cloneTempDir, parsed.subpath, {
+					includeInternal,
+					fullDepth: options.fullDepth
+				});
+			}
+			const selected = selectSkill(skills, selector, source);
+			if (blobResult && isBlobSkill(selected)) selectedSkill = {
+				kind: "blob",
+				name: selected.name,
+				directoryName: selected.name,
+				rawContent: selected.rawContent ?? getSkillMdFromSnapshot(selected.files),
+				files: selected.files
+			};
+			else selectedSkill = {
+				kind: "disk",
+				name: selected.name,
+				directoryName: selected.name,
+				rawContent: selected.rawContent,
+				path: selected.path
+			};
+		}
+		const materialized = await materializeUseSkill(selectedSkill);
+		await cleanupClone(cloneTempDir);
+		cloneTempDir = null;
+		const prompt = buildUsePrompt({
+			skillMd: materialized.skillMd,
+			supportDir: materialized.skillDir,
+			hasSupportingFiles: materialized.hasSupportingFiles
+		});
+		if (useAgent) {
+			const exitCode = await launchAgentInteractively(useAgent, prompt);
+			if (exitCode !== 0) process.exit(exitCode);
+			return;
+		}
+		process.stdout.write(prompt);
+	} catch (error) {
+		await cleanupClone(cloneTempDir);
+		if (error instanceof GitCloneError) fail(error.message);
+		if (error instanceof UseCommandError) fail(error.message);
+		fail(error instanceof Error ? error.message : "Unknown error");
+	}
+}
+async function launchAgentInteractively(agent, prompt, spawnImpl = spawnAgent) {
+	const config = USE_AGENT_CONFIGS[agent];
+	if (!config) throw new UseCommandError(formatUnsupportedAgentError(agent));
+	return new Promise((resolve, reject) => {
+		const child = spawnImpl(config.command, [...config.args, prompt], { stdio: "inherit" });
+		let settled = false;
+		child.on("error", (error) => {
+			if (settled) return;
+			settled = true;
+			if (error.code === "ENOENT") {
+				reject(new UseCommandError(`Could not launch ${agents[agent].displayName}: command not found: ${config.command}`));
+				return;
+			}
+			reject(error);
+		});
+		child.on("close", (code) => {
+			if (settled) return;
+			settled = true;
+			resolve(code ?? 1);
+		});
+	});
+}
+function spawnAgent(command, args) {
+	return spawn(command, args, { stdio: "inherit" });
+}
+function getUseHelp() {
+	return `Usage: skills use <source>[@<skill>] [options]
+
+Generate a prompt for using one skill without installing it.
+
+Options:
+  -s, --skill <skill>   Select the skill to use
+  -a, --agent <agent>   Start one supported agent interactively (${SUPPORTED_USE_AGENTS.join(", ")})
+  --full-depth          Search nested directories like skills add --full-depth
+  --dangerously-accept-openclaw-risks
+                         Allow unverified OpenClaw community skills
+  -h, --help            Show this help message
+
+Examples:
+  skills use vercel-labs/agent-skills@nextjs | claude
+  skills use vercel-labs/agent-skills --skill nextjs --agent claude-code
+  skills use vercel-labs/agent-skills@nextjs --agent codex`;
+}
+function resolveSelector(sourceSelector, optionSelector) {
+	if (sourceSelector && optionSelector) {
+		if (sourceSelector.toLowerCase() !== optionSelector.toLowerCase()) throw new UseCommandError(`Conflicting skill selectors: source selects "${sourceSelector}" but --skill selects "${optionSelector}". Provide one selector.`);
+		return optionSelector;
+	}
+	return optionSelector ?? sourceSelector;
+}
+function selectSkill(skills, selector, source) {
+	if (skills.length === 0) throw new UseCommandError("No valid skills found. Skills require a SKILL.md with name and description.");
+	if (!selector) {
+		if (skills.length === 1) return skills[0];
+		throw new UseCommandError(formatMultipleSkillsError(source, skills.map(getSkillDisplayName)));
+	}
+	const selected = filterSkills(skills, [selector]);
+	if (selected.length === 0) throw new UseCommandError(formatNoMatchError(selector, skills.map(getSkillDisplayName)));
+	if (selected.length > 1) throw new UseCommandError(`Skill selector "${selector}" matched multiple skills.`);
+	return selected[0];
+}
+function selectWellKnownSkill(skills, selector, source) {
+	if (skills.length === 0) throw new UseCommandError("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.");
+	let selected;
+	if (!selector) {
+		if (skills.length !== 1) throw new UseCommandError(formatMultipleSkillsError(source, skills.map((s) => s.installName)));
+		selected = skills;
+	} else {
+		selected = skills.filter((skill) => skill.installName.toLowerCase() === selector.toLowerCase() || skill.name.toLowerCase() === selector.toLowerCase());
+		if (selected.length === 0) throw new UseCommandError(formatNoMatchError(selector, skills.map((s) => s.installName)));
+		if (selected.length > 1) throw new UseCommandError(`Skill selector "${selector}" matched multiple skills.`);
+	}
+	const skill = selected[0];
+	return {
+		kind: "well-known",
+		name: skill.name,
+		directoryName: skill.installName,
+		rawContent: skill.content,
+		files: skill.files
+	};
+}
+function formatMultipleSkillsError(source, names) {
+	return [
+		"This source contains multiple skills. Specify exactly one skill:",
+		...names.map((name) => `  - ${name}`),
+		"",
+		`Examples:\n  skills use ${source}@${names[0] ?? "<skill>"}\n  skills use ${source} --skill ${names[0] ?? "<skill>"}`
+	].join("\n");
+}
+function formatNoMatchError(selector, names) {
+	return [
+		`No matching skill found for: ${selector}`,
+		"Available skills:",
+		...names.map((name) => `  - ${name}`)
+	].join("\n");
+}
+function validateUseAgentOption(agentValues) {
+	if (!agentValues || agentValues.length === 0) return [];
+	const errors = [];
+	const validAgents = Object.keys(agents);
+	const invalidAgents = agentValues.filter((agent) => agent !== "*" && !validAgents.includes(agent));
+	if (agentValues.includes("*")) errors.push("skills use --agent does not support '*'; specify exactly one agent.");
+	if (agentValues.length > 1) errors.push("skills use --agent accepts exactly one agent.");
+	if (invalidAgents.length > 0) errors.push(`Invalid agents: ${invalidAgents.join(", ")}\nValid agents: ${validAgents.join(", ")}`);
+	return errors;
+}
+function formatUnsupportedAgentError(agent) {
+	return [`Running ${agents[agent].displayName} is not supported yet.`, `Supported agents for skills use --agent: ${SUPPORTED_USE_AGENTS.join(", ")}`].join("\n");
+}
+async function writeSnapshotFiles(targetDir, files) {
+	for (const file of files) await writeSafeFile(targetDir, file.path, file.contents);
+}
+async function writeMapFiles(targetDir, files) {
+	for (const [path, contents] of files) await writeSafeFile(targetDir, path, contents);
+}
+async function writeSafeFile(targetDir, filePath, contents) {
+	const fullPath = join(targetDir, filePath);
+	if (!isPathSafe(targetDir, fullPath)) return;
+	await mkdir(dirname(fullPath), { recursive: true });
+	if (typeof contents === "string") await writeFile(fullPath, contents, "utf-8");
+	else await writeFile(fullPath, contents);
+}
+async function copySkillDirectory(src, dest) {
+	await mkdir(dest, { recursive: true });
+	const entries = await readdir(src, { withFileTypes: true });
+	await Promise.all(entries.filter((entry) => !isExcluded(entry.name, entry.isDirectory())).map(async (entry) => {
+		const srcPath = join(src, entry.name);
+		const destPath = join(dest, entry.name);
+		if (!isPathSafe(dest, destPath)) return;
+		if (entry.isDirectory()) {
+			await copySkillDirectory(srcPath, destPath);
+			return;
+		}
+		try {
+			await cp(srcPath, destPath, {
+				dereference: true,
+				recursive: true
+			});
+		} catch (err) {
+			if (err instanceof Error && "code" in err && err.code === "ENOENT" && entry.isSymbolicLink()) {
+				console.error(`Skipping broken symlink: ${srcPath}`);
+				return;
+			}
+			throw err;
+		}
+	}));
+}
+async function containsSupportingFiles(rootDir, currentDir) {
+	const entries = await readdir(currentDir, { withFileTypes: true });
+	for (const entry of entries) {
+		const entryPath = join(currentDir, entry.name);
+		const relPath = relative(rootDir, entryPath).split(sep).join("/");
+		if (entry.isDirectory()) {
+			if (await containsSupportingFiles(rootDir, entryPath)) return true;
+		} else if (relPath.toLowerCase() !== "skill.md") return true;
+	}
+	return false;
+}
+function isBlobSkill(skill) {
+	return Array.isArray(skill.files);
+}
+function getSkillMdFromSnapshot(files) {
+	return files.find((file) => file.path.toLowerCase() === "skill.md")?.contents ?? "";
+}
+function isExcluded(name, isDirectory) {
+	return EXCLUDE_FILES.has(name) || isDirectory && EXCLUDE_DIRS.has(name);
+}
+function isPathSafe(basePath, targetPath) {
+	const normalizedBase = normalize(resolve(basePath));
+	const normalizedTarget = normalize(resolve(targetPath));
+	return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
+}
+async function cleanupClone(tempDir) {
+	if (tempDir) await cleanupTempDir(tempDir).catch(() => {});
+}
+function fail(message) {
+	console.error(message);
+	process.exit(1);
+}
+var UseCommandError = class extends Error {};
 const __dirname = dirname(fileURLToPath(import.meta.url));
 function getVersion() {
 	try {
@@ -5234,6 +5932,7 @@ function showBanner() {
 	console.log(`${DIM}The open agent skills ecosystem${RESET}`);
 	console.log();
 	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills add ${DIM}<package>${RESET}        ${DIM}Add a new skill${RESET}`);
+	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills use ${DIM}<package>@<skill>${RESET} ${DIM}Use a skill without installing${RESET}`);
 	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills remove${RESET}               ${DIM}Remove installed skills${RESET}`);
 	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills list${RESET}                 ${DIM}List installed skills${RESET}`);
 	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills find ${DIM}[query]${RESET}         ${DIM}Search for skills${RESET}`);
@@ -5257,6 +5956,8 @@ ${BOLD}Manage Skills:${RESET}
   add <package>        Add a skill package (alias: a)
                        e.g. vercel-labs/agent-skills
                             https://github.com/vercel-labs/agent-skills
+  use <package>@<skill>
+                       Generate a prompt for using one skill without installing it
   remove [skills]      Remove installed skills
   list, ls             List installed skills
   find [query]         Search for skills interactively
@@ -5284,6 +5985,13 @@ ${BOLD}Add Options:${RESET}
   --all                  Shorthand for --skill '*' --agent '*' -y
   --full-depth           Search all subdirectories even when a root SKILL.md exists
 
+${BOLD}Use Options:${RESET}
+  -s, --skill <skill>    Specify the skill to use
+  -a, --agent <agent>    Start one supported agent interactively
+  --full-depth           Search all subdirectories even when a root SKILL.md exists
+  --dangerously-accept-openclaw-risks
+                         Allow unverified OpenClaw community skills
+
 ${BOLD}Remove Options:${RESET}
   -g, --global           Remove from global scope
   -a, --agent <agents>   Remove from specific agents (use '*' for all agents)
@@ -5306,6 +6014,8 @@ ${BOLD}Options:${RESET}
 
 ${BOLD}Examples:${RESET}
   ${DIM}$${RESET} skills add vercel-labs/agent-skills
+  ${DIM}$${RESET} skills use vercel-labs/agent-skills@vercel-optimize | claude
+  ${DIM}$${RESET} skills use vercel-labs/agent-skills --skill vercel-optimize --agent claude-code
   ${DIM}$${RESET} skills add vercel-labs/agent-skills -g
   ${DIM}$${RESET} skills add vercel-labs/agent-skills --agent claude-code cursor
   ${DIM}$${RESET} skills add vercel-labs/agent-skills --skill pr-review commit
@@ -5442,6 +6152,11 @@ async function main() {
 			await runAdd(addSource, addOpts);
 			break;
 		}
+		case "use": {
+			const { source: useSource, options: useOptions, errors: useErrors } = parseUseOptions(restArgs);
+			await runUse(useSource, useOptions, useErrors);
+			break;
+		}
 		case "remove":
 		case "rm":
 		case "r":

package/bin/node_modules/skills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skills",
-  "version": "1.5.9",
+  "version": "1.5.10",
   "description": "The open agent skills ecosystem",
   "type": "module",
   "bin": {
@@ -39,6 +39,9 @@
     "aider-desk",
     "amp",
     "antigravity",
+    "antigravity-cli",
+    "astrbot",
+    "autohand-code",
     "augment",
     "bob",
     "claude-code",
@@ -64,31 +67,44 @@
     "github-copilot",
     "goose",
     "hermes-agent",
+    "inference-sh",
+    "jazz",
     "junie",
     "iflow-cli",
     "kilo",
-    "kimi-cli",
+    "kimi-code-cli",
     "kiro-cli",
     "kode",
+    "lingma",
+    "loaf",
     "mcpjam",
     "mistral-vibe",
+    "moxby",
     "mux",
     "opencode",
     "openhands",
+    "ona",
     "pi",
     "qoder",
+    "qoder-cn",
     "qwen-code",
     "replit",
+    "reasonix",
     "rovodev",
     "roo",
     "tabnine-cli",
+    "terramind",
+    "tinycloud",
     "trae",
     "trae-cn",
     "warp",
     "windsurf",
+    "zed",
     "zencoder",
+    "zenflow",
     "neovate",
     "pochi",
+    "promptscript",
     "adal",
     "universal"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dimcode-darwin-x64",
-  "version": "0.0.78",
+  "version": "0.0.79-beta.0",
   "description": "dimcode binary for macOS x64 (Intel)",
   "os": [
     "darwin"