skills 1.4.0 → 1.4.2

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { r as __toESM } from "./_chunks/rolldown-runtime.mjs";
 import { l as pD, u as require_picocolors } from "./_chunks/libs/@clack/core.mjs";
-import { a as Y, c as xe, i as Se, l as ye, n as M, o as fe, r as Me, s as ve, t as Ie } from "./_chunks/libs/@clack/prompts.mjs";
+import { a as Y, c as ve, i as Se, l as xe, n as M, o as be, r as Me, s as fe, t as Ie, u as ye } from "./_chunks/libs/@clack/prompts.mjs";
 import "./_chunks/libs/@kwsites/file-exists.mjs";
 import "./_chunks/libs/@kwsites/promise-deferred.mjs";
 import { t as esm_default } from "./_chunks/libs/simple-git.mjs";
@@ -13,7 +13,7 @@ import { execSync, spawn, spawnSync } from "child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep } from "path";
 import { homedir, platform, tmpdir } from "os";
-import "crypto";
+import { createHash } from "crypto";
 import { fileURLToPath } from "url";
 import * as readline from "readline";
 import { Writable } from "stream";
@@ -180,7 +180,8 @@ const S_STEP_CANCEL = import_picocolors.default.red("■");
 const S_STEP_SUBMIT = import_picocolors.default.green("◇");
 const S_RADIO_ACTIVE = import_picocolors.default.green("●");
 const S_RADIO_INACTIVE = import_picocolors.default.dim("○");
-const S_CHECKBOX_LOCKED = import_picocolors.default.green("✓");
+import_picocolors.default.green("✓");
+const S_BULLET = import_picocolors.default.green("•");
 const S_BAR = import_picocolors.default.dim("│");
 const S_BAR_H = import_picocolors.default.dim("─");
 const cancelSymbol = Symbol("cancel");
@@ -223,10 +224,11 @@ async function searchMultiselect(options) {
 			if (state === "active") {
 				if (lockedSection && lockedSection.items.length > 0) {
 					lines.push(`${S_BAR}`);
-					lines.push(`${S_BAR}  ${S_BAR_H}${S_BAR_H} ${import_picocolors.default.bold(lockedSection.title)} ${S_BAR_H.repeat(30)}`);
-					for (const item of lockedSection.items) lines.push(`${S_BAR}    ${S_CHECKBOX_LOCKED} ${item.label}`);
+					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)}`);
 					lines.push(`${S_BAR}`);
-					lines.push(`${S_BAR}  ${S_BAR_H}${S_BAR_H} ${import_picocolors.default.bold("Other agents")} ${S_BAR_H.repeat(34)}`);
+					lines.push(`${S_BAR}  ${S_BAR_H}${S_BAR_H} ${import_picocolors.default.bold("Additional agents")} ${S_BAR_H.repeat(29)}`);
 				}
 				const searchLine = `${S_BAR}  ${import_picocolors.default.dim("Search:")} ${query}${import_picocolors.default.inverse(" ")}`;
 				lines.push(searchLine);
@@ -348,7 +350,13 @@ var GitCloneError = class extends Error {
 };
 async function cloneRepo(url, ref) {
 	const tempDir = await mkdtemp(join(tmpdir(), "skills-"));
-	const git = esm_default({ timeout: { block: CLONE_TIMEOUT_MS } });
+	const git = esm_default({
+		timeout: { block: CLONE_TIMEOUT_MS },
+		env: {
+			...process.env,
+			GIT_TERMINAL_PROMPT: "0"
+		}
+	});
 	const cloneOptions = ref ? [
 		"--depth",
 		"1",
@@ -416,6 +424,36 @@ async function getPluginSkillPaths(basePath) {
 	} catch {}
 	return searchDirs;
 }
+async function getPluginGroupings(basePath) {
+	const groupings = /* @__PURE__ */ new Map();
+	try {
+		const content = await readFile(join(basePath, ".claude-plugin/marketplace.json"), "utf-8");
+		const manifest = JSON.parse(content);
+		const pluginRoot = manifest.metadata?.pluginRoot;
+		if (pluginRoot === void 0 || isValidRelativePath(pluginRoot)) for (const plugin of manifest.plugins ?? []) {
+			if (!plugin.name) continue;
+			if (typeof plugin.source !== "string" && plugin.source !== void 0) continue;
+			if (plugin.source !== void 0 && !isValidRelativePath(plugin.source)) continue;
+			const pluginBase = join(basePath, pluginRoot ?? "", plugin.source ?? "");
+			if (!isContainedIn(pluginBase, basePath)) continue;
+			if (plugin.skills && plugin.skills.length > 0) for (const skillPath of plugin.skills) {
+				if (!isValidRelativePath(skillPath)) continue;
+				const skillDir = join(pluginBase, skillPath);
+				if (isContainedIn(skillDir, basePath)) groupings.set(resolve(skillDir), plugin.name);
+			}
+		}
+	} catch {}
+	try {
+		const content = await readFile(join(basePath, ".claude-plugin/plugin.json"), "utf-8");
+		const manifest = JSON.parse(content);
+		if (manifest.name && manifest.skills && manifest.skills.length > 0) for (const skillPath of manifest.skills) {
+			if (!isValidRelativePath(skillPath)) continue;
+			const skillDir = join(basePath, skillPath);
+			if (isContainedIn(skillDir, basePath)) groupings.set(resolve(skillDir), manifest.name);
+		}
+	} catch {}
+	return groupings;
+}
 const SKIP_DIRS = [
 	"node_modules",
 	".git",
@@ -467,9 +505,16 @@ async function discoverSkills(basePath, subpath, options) {
 	const skills = [];
 	const seenNames = /* @__PURE__ */ new Set();
 	const searchPath = subpath ? join(basePath, subpath) : basePath;
+	const pluginGroupings = await getPluginGroupings(searchPath);
+	const enhanceSkill = (skill) => {
+		const resolvedPath = resolve(skill.path);
+		if (pluginGroupings.has(resolvedPath)) skill.pluginName = pluginGroupings.get(resolvedPath);
+		return skill;
+	};
 	if (await hasSkillMd(searchPath)) {
-		const skill = await parseSkillMd(join(searchPath, "SKILL.md"), options);
+		let skill = await parseSkillMd(join(searchPath, "SKILL.md"), options);
 		if (skill) {
+			skill = enhanceSkill(skill);
 			skills.push(skill);
 			seenNames.add(skill.name);
 			if (!options?.fullDepth) return skills;
@@ -489,7 +534,6 @@ async function discoverSkills(basePath, subpath, options) {
 		join(searchPath, ".codex/skills"),
 		join(searchPath, ".commandcode/skills"),
 		join(searchPath, ".continue/skills"),
-		join(searchPath, ".cursor/skills"),
 		join(searchPath, ".github/skills"),
 		join(searchPath, ".goose/skills"),
 		join(searchPath, ".iflow/skills"),
@@ -513,8 +557,9 @@ async function discoverSkills(basePath, subpath, options) {
 		for (const entry of entries) if (entry.isDirectory()) {
 			const skillDir = join(dir, entry.name);
 			if (await hasSkillMd(skillDir)) {
-				const skill = await parseSkillMd(join(skillDir, "SKILL.md"), options);
+				let skill = await parseSkillMd(join(skillDir, "SKILL.md"), options);
 				if (skill && !seenNames.has(skill.name)) {
+					skill = enhanceSkill(skill);
 					skills.push(skill);
 					seenNames.add(skill.name);
 				}
@@ -524,8 +569,9 @@ async function discoverSkills(basePath, subpath, options) {
 	if (skills.length === 0 || options?.fullDepth) {
 		const allSkillDirs = await findSkillDirs(searchPath);
 		for (const skillDir of allSkillDirs) {
-			const skill = await parseSkillMd(join(skillDir, "SKILL.md"), options);
+			let skill = await parseSkillMd(join(skillDir, "SKILL.md"), options);
 			if (skill && !seenNames.has(skill.name)) {
+				skill = enhanceSkill(skill);
 				skills.push(skill);
 				seenNames.add(skill.name);
 			}
@@ -570,7 +616,7 @@ const agents = {
 		skillsDir: ".agent/skills",
 		globalSkillsDir: join(home, ".gemini/antigravity/skills"),
 		detectInstalled: async () => {
-			return existsSync(join(process.cwd(), ".agent")) || existsSync(join(home, ".gemini/antigravity"));
+			return existsSync(join(home, ".gemini/antigravity"));
 		}
 	},
 	augment: {
@@ -603,8 +649,8 @@ const agents = {
 	cline: {
 		name: "cline",
 		displayName: "Cline",
-		skillsDir: ".cline/skills",
-		globalSkillsDir: join(home, ".cline/skills"),
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join(home, ".agents", "skills"),
 		detectInstalled: async () => {
 			return existsSync(join(home, ".cline"));
 		}
@@ -645,6 +691,15 @@ const agents = {
 			return existsSync(join(process.cwd(), ".continue")) || existsSync(join(home, ".continue"));
 		}
 	},
+	cortex: {
+		name: "cortex",
+		displayName: "Cortex Code",
+		skillsDir: ".cortex/skills",
+		globalSkillsDir: join(home, ".snowflake/cortex/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".snowflake/cortex"));
+		}
+	},
 	crush: {
 		name: "crush",
 		displayName: "Crush",
@@ -657,7 +712,7 @@ const agents = {
 	cursor: {
 		name: "cursor",
 		displayName: "Cursor",
-		skillsDir: ".cursor/skills",
+		skillsDir: ".agents/skills",
 		globalSkillsDir: join(home, ".cursor/skills"),
 		detectInstalled: async () => {
 			return existsSync(join(home, ".cursor"));
@@ -687,7 +742,7 @@ const agents = {
 		skillsDir: ".agents/skills",
 		globalSkillsDir: join(home, ".copilot/skills"),
 		detectInstalled: async () => {
-			return existsSync(join(process.cwd(), ".github")) || existsSync(join(home, ".copilot"));
+			return existsSync(join(home, ".copilot"));
 		}
 	},
 	goose: {
@@ -786,7 +841,7 @@ const agents = {
 		skillsDir: ".agents/skills",
 		globalSkillsDir: join(configHome, "opencode/skills"),
 		detectInstalled: async () => {
-			return existsSync(join(configHome, "opencode")) || existsSync(join(claudeHome, "skills"));
+			return existsSync(join(configHome, "opencode"));
 		}
 	},
 	openhands: {
@@ -832,7 +887,7 @@ const agents = {
 		globalSkillsDir: join(configHome, "agents/skills"),
 		showInUniversalList: false,
 		detectInstalled: async () => {
-			return existsSync(join(process.cwd(), ".agents"));
+			return existsSync(join(process.cwd(), ".replit"));
 		}
 	},
 	roo: {
@@ -906,6 +961,14 @@ const agents = {
 		detectInstalled: async () => {
 			return existsSync(join(home, ".adal"));
 		}
+	},
+	universal: {
+		name: "universal",
+		displayName: "Universal",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join(configHome, "agents/skills"),
+		showInUniversalList: false,
+		detectInstalled: async () => false
 	}
 };
 async function detectInstalledAgents() {
@@ -936,6 +999,16 @@ function isPathSafe(basePath, targetPath) {
 function getCanonicalSkillsDir(global, cwd) {
 	return join(global ? homedir() : cwd || process.cwd(), AGENTS_DIR$2, SKILLS_SUBDIR);
 }
+function getAgentBaseDir(agentType, global, cwd) {
+	if (isUniversalAgent(agentType)) return getCanonicalSkillsDir(global, cwd);
+	const agent = agents[agentType];
+	const baseDir = global ? homedir() : cwd || process.cwd();
+	if (global) {
+		if (agent.globalSkillsDir === void 0) return join(baseDir, agent.skillsDir);
+		return agent.globalSkillsDir;
+	}
+	return join(baseDir, agent.skillsDir);
+}
 function resolveSymlinkTarget(linkPath, linkTarget) {
 	return resolve(dirname(linkPath), linkTarget);
 }
@@ -961,7 +1034,9 @@ async function resolveParentSymlinks(path) {
 async function createSymlink(target, linkPath) {
 	try {
 		const resolvedTarget = resolve(target);
-		if (resolvedTarget === resolve(linkPath)) return true;
+		const resolvedLinkPath = resolve(linkPath);
+		const [realTarget, realLinkPath] = await Promise.all([realpath(resolvedTarget).catch(() => resolvedTarget), realpath(resolvedLinkPath).catch(() => resolvedLinkPath)]);
+		if (realTarget === realLinkPath) return true;
 		if (await resolveParentSymlinks(target) === await resolveParentSymlinks(linkPath)) return true;
 		try {
 			if ((await lstat(linkPath)).isSymbolicLink()) {
@@ -994,7 +1069,7 @@ async function installSkillForAgent(skill, agentType, options = {}) {
 	const skillName = sanitizeName(skill.name || basename(skill.path));
 	const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
 	const canonicalDir = join(canonicalBase, skillName);
-	const agentBase = isGlobal ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
+	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd);
 	const agentDir = join(agentBase, skillName);
 	const installMode = options.mode ?? "symlink";
 	if (!isPathSafe(canonicalBase, canonicalDir)) return {
@@ -1053,7 +1128,7 @@ async function installSkillForAgent(skill, agentType, options = {}) {
 		};
 	}
 }
-const EXCLUDE_FILES = new Set(["README.md", "metadata.json"]);
+const EXCLUDE_FILES = new Set(["metadata.json"]);
 const EXCLUDE_DIRS = new Set([".git"]);
 const isExcluded = (name, isDirectory = false) => {
 	if (EXCLUDE_FILES.has(name)) return true;
@@ -1089,10 +1164,10 @@ async function isSkillInstalled(skillName, agentType, options = {}) {
 	}
 }
 function getInstallPath(skillName, agentType, options = {}) {
-	const agent = agents[agentType];
-	const cwd = options.cwd || process.cwd();
+	agents[agentType];
+	options.cwd || process.cwd();
 	const sanitized = sanitizeName(skillName);
-	const targetBase = options.global && agent.globalSkillsDir !== void 0 ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
+	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");
 	return installPath;
@@ -1118,7 +1193,7 @@ async function installRemoteSkillForAgent(skill, agentType, options = {}) {
 	const skillName = sanitizeName(skill.installName);
 	const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
 	const canonicalDir = join(canonicalBase, skillName);
-	const agentBase = isGlobal ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
+	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd);
 	const agentDir = join(agentBase, skillName);
 	if (!isPathSafe(canonicalBase, canonicalDir)) return {
 		success: false,
@@ -1190,7 +1265,7 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 	const skillName = sanitizeName(skill.installName);
 	const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
 	const canonicalDir = join(canonicalBase, skillName);
-	const agentBase = isGlobal ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
+	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd);
 	const agentDir = join(agentBase, skillName);
 	if (!isPathSafe(canonicalBase, canonicalDir)) return {
 		success: false,
@@ -1718,7 +1793,7 @@ async function fetchMintlifySkill(url) {
 }
 const AGENTS_DIR$1 = ".agents";
 const LOCK_FILE$1 = ".skill-lock.json";
-const CURRENT_VERSION = 3;
+const CURRENT_VERSION$1 = 3;
 function getSkillLockPath$1() {
 	return join(homedir(), AGENTS_DIR$1, LOCK_FILE$1);
 }
@@ -1728,7 +1803,7 @@ async function readSkillLock$1() {
 		const content = await readFile(lockPath, "utf-8");
 		const parsed = JSON.parse(content);
 		if (typeof parsed.version !== "number" || !parsed.skills) return createEmptyLockFile();
-		if (parsed.version < CURRENT_VERSION) return createEmptyLockFile();
+		if (parsed.version < CURRENT_VERSION$1) return createEmptyLockFile();
 		return parsed;
 	} catch (error) {
 		return createEmptyLockFile();
@@ -1799,9 +1874,12 @@ async function removeSkillFromLock(skillName) {
 async function getSkillFromLock(skillName) {
 	return (await readSkillLock$1()).skills[skillName] ?? null;
 }
+async function getAllLockedSkills() {
+	return (await readSkillLock$1()).skills;
+}
 function createEmptyLockFile() {
 	return {
-		version: CURRENT_VERSION,
+		version: CURRENT_VERSION$1,
 		skills: {},
 		dismissed: {}
 	};
@@ -1823,8 +1901,74 @@ async function saveSelectedAgents(agents) {
 	lock.lastSelectedAgents = agents;
 	await writeSkillLock(lock);
 }
-var version$1 = "1.4.0";
-const isCancelled = (value) => typeof value === "symbol";
+const LOCAL_LOCK_FILE = "skills-lock.json";
+const CURRENT_VERSION = 1;
+function getLocalLockPath(cwd) {
+	return join(cwd || process.cwd(), LOCAL_LOCK_FILE);
+}
+async function readLocalLock(cwd) {
+	const lockPath = getLocalLockPath(cwd);
+	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) return createEmptyLocalLock();
+		return parsed;
+	} catch {
+		return createEmptyLocalLock();
+	}
+}
+async function writeLocalLock(lock, cwd) {
+	const lockPath = getLocalLockPath(cwd);
+	const sortedSkills = {};
+	for (const key of Object.keys(lock.skills).sort()) sortedSkills[key] = lock.skills[key];
+	const sorted = {
+		version: lock.version,
+		skills: sortedSkills
+	};
+	await writeFile(lockPath, JSON.stringify(sorted, null, 2) + "\n", "utf-8");
+}
+async function computeSkillFolderHash(skillDir) {
+	const files = [];
+	await collectFiles(skillDir, skillDir, files);
+	files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+	const hash = createHash("sha256");
+	for (const file of files) {
+		hash.update(file.relativePath);
+		hash.update(file.content);
+	}
+	return hash.digest("hex");
+}
+async function collectFiles(baseDir, currentDir, results) {
+	const entries = await readdir(currentDir, { withFileTypes: true });
+	await Promise.all(entries.map(async (entry) => {
+		const fullPath = join(currentDir, entry.name);
+		if (entry.isDirectory()) {
+			if (entry.name === ".git" || entry.name === "node_modules") return;
+			await collectFiles(baseDir, fullPath, results);
+		} else if (entry.isFile()) {
+			const content = await readFile(fullPath);
+			const relativePath = relative(baseDir, fullPath).split("\\").join("/");
+			results.push({
+				relativePath,
+				content
+			});
+		}
+	}));
+}
+async function addSkillToLocalLock(skillName, entry, cwd) {
+	const lock = await readLocalLock(cwd);
+	lock.skills[skillName] = entry;
+	await writeLocalLock(lock, cwd);
+}
+function createEmptyLocalLock() {
+	return {
+		version: CURRENT_VERSION,
+		skills: {}
+	};
+}
+var version$1 = "1.4.2";
+const isCancelled$1 = (value) => typeof value === "symbol";
 async function isSourcePrivate(source) {
 	const ownerRepo = parseOwnerRepo(source);
 	if (!ownerRepo) return false;
@@ -1875,7 +2019,7 @@ function buildSecurityLines(auditData, skills, source) {
 	lines.push(`${import_picocolors.default.dim("Details:")} ${import_picocolors.default.dim(`https://skills.sh/${source}`)}`);
 	return lines;
 }
-function shortenPath$1(fullPath, cwd) {
+function shortenPath$2(fullPath, cwd) {
 	const home = homedir();
 	if (fullPath === home || fullPath.startsWith(home + sep)) return "~" + fullPath.slice(home.length);
 	if (fullPath === cwd || fullPath.startsWith(cwd + sep)) return "." + fullPath.slice(cwd.length);
@@ -1952,7 +2096,7 @@ async function promptForAgents(message, choices) {
 		initialSelected: initialValues,
 		required: true
 	});
-	if (!isCancelled(selected)) try {
+	if (!isCancelled$1(selected)) try {
 		await saveSelectedAgents(selected);
 	} catch {}
 	return selected;
@@ -1983,7 +2127,7 @@ async function selectAgentsInteractive(options) {
 		initialSelected: lastSelected ? lastSelected.filter((a) => otherAgents.includes(a) && !universalAgents.includes(a)) : [],
 		lockedSection: universalSection
 	});
-	if (!isCancelled(selected)) try {
+	if (!isCancelled$1(selected)) try {
 		await saveSelectedAgents(selected);
 	} catch {}
 	return selected;
@@ -2040,7 +2184,7 @@ async function handleRemoteSkill(source, url, options, spinner) {
 			M.info(`Valid agents: ${validAgents.join(", ")}`);
 			process.exit(1);
 		}
-		targetAgents = ensureUniversalAgents(options.agent);
+		targetAgents = options.agent;
 	} else {
 		spinner.start("Loading agents...");
 		const installedAgents = await detectInstalledAgents();
@@ -2092,8 +2236,8 @@ async function handleRemoteSkill(source, url, options, spinner) {
 		}
 		installGlobally = scope;
 	}
-	let installMode = "symlink";
-	if (!options.yes) {
+	let installMode = options.copy ? "copy" : "symlink";
+	if (!options.copy && !options.yes) {
 		const modeChoice = await ve({
 			message: "Installation method",
 			options: [{
@@ -2119,7 +2263,7 @@ async function handleRemoteSkill(source, url, options, spinner) {
 	})));
 	const overwriteStatus = new Map(overwriteChecks.map(({ agent, installed }) => [agent, installed]));
 	const summaryLines = [];
-	const shortCanonical = shortenPath$1(getCanonicalPath(remoteSkill.installName, { global: installGlobally }), cwd);
+	const shortCanonical = shortenPath$2(getCanonicalPath(remoteSkill.installName, { global: installGlobally }), cwd);
 	summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
 	summaryLines.push(...buildAgentSummaryLines(targetAgents, installMode));
 	const overwriteAgents = targetAgents.filter((a) => overwriteStatus.get(a)).map((a) => agents[a].displayName);
@@ -2172,18 +2316,27 @@ async function handleRemoteSkill(source, url, options, spinner) {
 			skillFolderHash
 		});
 	} catch {}
+	if (successful.length > 0 && !installGlobally) try {
+		const firstResult = successful[0];
+		const computedHash = await computeSkillFolderHash(firstResult.canonicalPath || firstResult.path);
+		await addSkillToLocalLock(remoteSkill.installName, {
+			source: remoteSkill.sourceIdentifier,
+			sourceType: remoteSkill.providerId,
+			computedHash
+		}, cwd);
+	} catch {}
 	if (successful.length > 0) {
 		const resultLines = [];
 		const firstResult = successful[0];
 		if (firstResult.mode === "copy") {
 			resultLines.push(`${import_picocolors.default.green("✓")} ${remoteSkill.installName} ${import_picocolors.default.dim("(copied)")}`);
 			for (const r of successful) {
-				const shortPath = shortenPath$1(r.path, cwd);
+				const shortPath = shortenPath$2(r.path, cwd);
 				resultLines.push(`  ${import_picocolors.default.dim("→")} ${shortPath}`);
 			}
 		} else {
 			if (firstResult.canonicalPath) {
-				const shortPath = shortenPath$1(firstResult.canonicalPath, cwd);
+				const shortPath = shortenPath$2(firstResult.canonicalPath, cwd);
 				resultLines.push(`${import_picocolors.default.green("✓")} ${shortPath}`);
 			} else resultLines.push(`${import_picocolors.default.green("✓")} ${remoteSkill.installName}`);
 			resultLines.push(...buildResultLines(successful, targetAgents));
@@ -2244,7 +2397,6 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 			for (const s of skills) M.message(`  - ${s.installName}`);
 			process.exit(1);
 		}
-		M.info(`Selected ${selectedSkills.length} skill${selectedSkills.length !== 1 ? "s" : ""}: ${selectedSkills.map((s) => import_picocolors.default.cyan(s.installName)).join(", ")}`);
 	} else if (skills.length === 1) {
 		selectedSkills = skills;
 		const firstSkill = skills[0];
@@ -2302,7 +2454,7 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 			targetAgents = selected;
 		}
 		else if (installedAgents.length === 1 || options.yes) {
-			targetAgents = installedAgents;
+			targetAgents = ensureUniversalAgents(installedAgents);
 			if (installedAgents.length === 1) {
 				const firstAgent = installedAgents[0];
 				M.info(`Installing to: ${import_picocolors.default.cyan(agents[firstAgent].displayName)}`);
@@ -2337,8 +2489,8 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 		}
 		installGlobally = scope;
 	}
-	let installMode = "symlink";
-	if (!options.yes) {
+	let installMode = options.copy ? "copy" : "symlink";
+	if (!options.copy && !options.yes) {
 		const modeChoice = await ve({
 			message: "Installation method",
 			options: [{
@@ -2372,7 +2524,7 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 	}
 	for (const skill of selectedSkills) {
 		if (summaryLines.length > 0) summaryLines.push("");
-		const shortCanonical = shortenPath$1(getCanonicalPath(skill.installName, { global: installGlobally }), cwd);
+		const shortCanonical = shortenPath$2(getCanonicalPath(skill.installName, { global: installGlobally }), cwd);
 		summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
 		summaryLines.push(...buildAgentSummaryLines(targetAgents, installMode));
 		if (skill.files.size > 1) summaryLines.push(`  ${import_picocolors.default.dim("files:")} ${skill.files.size}`);
@@ -2429,6 +2581,21 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 			});
 		} catch {}
 	}
+	if (successful.length > 0 && !installGlobally) {
+		const successfulSkillNames = new Set(successful.map((r) => r.skill));
+		for (const skill of selectedSkills) if (successfulSkillNames.has(skill.installName)) try {
+			const matchingResult = successful.find((r) => r.skill === skill.installName);
+			const installDir = matchingResult?.canonicalPath || matchingResult?.path;
+			if (installDir) {
+				const computedHash = await computeSkillFolderHash(installDir);
+				await addSkillToLocalLock(skill.installName, {
+					source: sourceIdentifier,
+					sourceType: "well-known",
+					computedHash
+				}, cwd);
+			}
+		} catch {}
+	}
 	if (successful.length > 0) {
 		const bySkill = /* @__PURE__ */ new Map();
 		for (const r of successful) {
@@ -2445,12 +2612,12 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 			if (firstResult.mode === "copy") {
 				resultLines.push(`${import_picocolors.default.green("✓")} ${skillName} ${import_picocolors.default.dim("(copied)")}`);
 				for (const r of skillResults) {
-					const shortPath = shortenPath$1(r.path, cwd);
+					const shortPath = shortenPath$2(r.path, cwd);
 					resultLines.push(`  ${import_picocolors.default.dim("→")} ${shortPath}`);
 				}
 			} else {
 				if (firstResult.canonicalPath) {
-					const shortPath = shortenPath$1(firstResult.canonicalPath, cwd);
+					const shortPath = shortenPath$2(firstResult.canonicalPath, cwd);
 					resultLines.push(`${import_picocolors.default.green("✓")} ${shortPath}`);
 				} else resultLines.push(`${import_picocolors.default.green("✓")} ${skillName}`);
 				resultLines.push(...buildResultLines(skillResults, targetAgents));
@@ -2536,7 +2703,7 @@ async function handleDirectUrlSkillLegacy(source, url, options, spinner) {
 			targetAgents = selected;
 		}
 		else if (installedAgents.length === 1 || options.yes) {
-			targetAgents = installedAgents;
+			targetAgents = ensureUniversalAgents(installedAgents);
 			if (installedAgents.length === 1) {
 				const firstAgent = installedAgents[0];
 				M.info(`Installing to: ${import_picocolors.default.cyan(agents[firstAgent].displayName)}`);
@@ -2580,7 +2747,7 @@ async function handleDirectUrlSkillLegacy(source, url, options, spinner) {
 	const overwriteStatus = new Map(overwriteChecks.map(({ agent, installed }) => [agent, installed]));
 	const summaryLines = [];
 	targetAgents.map((a) => agents[a].displayName);
-	const shortCanonical = shortenPath$1(getCanonicalPath(remoteSkill.installName, { global: installGlobally }), cwd);
+	const shortCanonical = shortenPath$2(getCanonicalPath(remoteSkill.installName, { global: installGlobally }), cwd);
 	summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
 	summaryLines.push(...buildAgentSummaryLines(targetAgents, installMode));
 	const overwriteAgents = targetAgents.filter((a) => overwriteStatus.get(a)).map((a) => agents[a].displayName);
@@ -2632,7 +2799,7 @@ async function handleDirectUrlSkillLegacy(source, url, options, spinner) {
 		const resultLines = [];
 		const firstResult = successful[0];
 		if (firstResult.canonicalPath) {
-			const shortPath = shortenPath$1(firstResult.canonicalPath, cwd);
+			const shortPath = shortenPath$2(firstResult.canonicalPath, cwd);
 			resultLines.push(`${import_picocolors.default.green("✓")} ${shortPath}`);
 		} else resultLines.push(`${import_picocolors.default.green("✓")} ${remoteSkill.installName}`);
 		resultLines.push(...buildResultLines(successful, targetAgents));
@@ -2732,9 +2899,29 @@ async function runAdd(args, options = {}) {
 		if (options.list) {
 			console.log();
 			M.step(import_picocolors.default.bold("Available Skills"));
-			for (const skill of skills) {
-				M.message(`  ${import_picocolors.default.cyan(getSkillDisplayName(skill))}`);
-				M.message(`    ${import_picocolors.default.dim(skill.description)}`);
+			const groupedSkills = {};
+			const ungroupedSkills = [];
+			for (const skill of skills) if (skill.pluginName) {
+				const group = skill.pluginName;
+				if (!groupedSkills[group]) groupedSkills[group] = [];
+				groupedSkills[group].push(skill);
+			} else ungroupedSkills.push(skill);
+			const sortedGroups = Object.keys(groupedSkills).sort();
+			for (const group of sortedGroups) {
+				const title = group.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+				console.log(import_picocolors.default.bold(title));
+				for (const skill of groupedSkills[group]) {
+					M.message(`  ${import_picocolors.default.cyan(getSkillDisplayName(skill))}`);
+					M.message(`    ${import_picocolors.default.dim(skill.description)}`);
+				}
+				console.log();
+			}
+			if (ungroupedSkills.length > 0) {
+				if (sortedGroups.length > 0) console.log(import_picocolors.default.bold("General"));
+				for (const skill of ungroupedSkills) {
+					M.message(`  ${import_picocolors.default.cyan(getSkillDisplayName(skill))}`);
+					M.message(`    ${import_picocolors.default.dim(skill.description)}`);
+				}
 			}
 			console.log();
 			Se("Use --skill <name> to install specific skills");
@@ -2764,9 +2951,34 @@ async function runAdd(args, options = {}) {
 			selectedSkills = skills;
 			M.info(`Installing all ${skills.length} skills`);
 		} else {
-			const selected = await multiselect({
+			const sortedSkills = [...skills].sort((a, b) => {
+				if (a.pluginName && !b.pluginName) return -1;
+				if (!a.pluginName && b.pluginName) return 1;
+				if (a.pluginName && b.pluginName && a.pluginName !== b.pluginName) return a.pluginName.localeCompare(b.pluginName);
+				return getSkillDisplayName(a).localeCompare(getSkillDisplayName(b));
+			});
+			const hasGroups = sortedSkills.some((s) => s.pluginName);
+			let selected;
+			if (hasGroups) {
+				const kebabToTitle = (s) => s.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+				const grouped = {};
+				for (const s of sortedSkills) {
+					const groupName = s.pluginName ? kebabToTitle(s.pluginName) : "Other";
+					if (!grouped[groupName]) grouped[groupName] = [];
+					grouped[groupName].push({
+						value: s,
+						label: getSkillDisplayName(s),
+						hint: s.description.length > 60 ? s.description.slice(0, 57) + "..." : s.description
+					});
+				}
+				selected = await be({
+					message: `Select skills to install ${import_picocolors.default.dim("(space to toggle)")}`,
+					options: grouped,
+					required: true
+				});
+			} else selected = await multiselect({
 				message: "Select skills to install",
-				options: skills.map((s) => ({
+				options: sortedSkills.map((s) => ({
 					value: s,
 					label: getSkillDisplayName(s),
 					hint: s.description.length > 60 ? s.description.slice(0, 57) + "..." : s.description
@@ -2818,7 +3030,7 @@ async function runAdd(args, options = {}) {
 				targetAgents = selected;
 			}
 			else if (installedAgents.length === 1 || options.yes) {
-				targetAgents = installedAgents;
+				targetAgents = ensureUniversalAgents(installedAgents);
 				if (installedAgents.length === 1) {
 					const firstAgent = installedAgents[0];
 					M.info(`Installing to: ${import_picocolors.default.cyan(agents[firstAgent].displayName)}`);
@@ -2855,8 +3067,8 @@ async function runAdd(args, options = {}) {
 			}
 			installGlobally = scope;
 		}
-		let installMode = "symlink";
-		if (!options.yes) {
+		let installMode = options.copy ? "copy" : "symlink";
+		if (!options.copy && !options.yes) {
 			const modeChoice = await ve({
 				message: "Installation method",
 				options: [{
@@ -2889,14 +3101,37 @@ async function runAdd(args, options = {}) {
 			if (!overwriteStatus.has(skillName)) overwriteStatus.set(skillName, /* @__PURE__ */ new Map());
 			overwriteStatus.get(skillName).set(agent, installed);
 		}
-		for (const skill of selectedSkills) {
-			if (summaryLines.length > 0) summaryLines.push("");
-			const shortCanonical = shortenPath$1(getCanonicalPath(skill.name, { global: installGlobally }), cwd);
-			summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
-			summaryLines.push(...buildAgentSummaryLines(targetAgents, installMode));
-			const skillOverwrites = overwriteStatus.get(skill.name);
-			const overwriteAgents = targetAgents.filter((a) => skillOverwrites?.get(a)).map((a) => agents[a].displayName);
-			if (overwriteAgents.length > 0) summaryLines.push(`  ${import_picocolors.default.yellow("overwrites:")} ${formatList$1(overwriteAgents)}`);
+		const groupedSummary = {};
+		const ungroupedSummary = [];
+		for (const skill of selectedSkills) if (skill.pluginName) {
+			const group = skill.pluginName;
+			if (!groupedSummary[group]) groupedSummary[group] = [];
+			groupedSummary[group].push(skill);
+		} else ungroupedSummary.push(skill);
+		const printSkillSummary = (skills) => {
+			for (const skill of skills) {
+				if (summaryLines.length > 0) summaryLines.push("");
+				const shortCanonical = shortenPath$2(getCanonicalPath(skill.name, { global: installGlobally }), cwd);
+				summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
+				summaryLines.push(...buildAgentSummaryLines(targetAgents, installMode));
+				const skillOverwrites = overwriteStatus.get(skill.name);
+				const overwriteAgents = targetAgents.filter((a) => skillOverwrites?.get(a)).map((a) => agents[a].displayName);
+				if (overwriteAgents.length > 0) summaryLines.push(`  ${import_picocolors.default.yellow("overwrites:")} ${formatList$1(overwriteAgents)}`);
+			}
+		};
+		const sortedGroups = Object.keys(groupedSummary).sort();
+		for (const group of sortedGroups) {
+			const title = group.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+			summaryLines.push("");
+			summaryLines.push(import_picocolors.default.bold(title));
+			printSkillSummary(groupedSummary[group]);
+		}
+		if (ungroupedSummary.length > 0) {
+			if (sortedGroups.length > 0) {
+				summaryLines.push("");
+				summaryLines.push(import_picocolors.default.bold("General"));
+			}
+			printSkillSummary(ungroupedSummary);
 		}
 		console.log();
 		Me(summaryLines.join("\n"), "Installation Summary");
@@ -2928,6 +3163,7 @@ async function runAdd(args, options = {}) {
 			results.push({
 				skill: getSkillDisplayName(skill),
 				agent: agents[agent].displayName,
+				pluginName: skill.pluginName,
 				...result
 			});
 		}
@@ -2980,37 +3216,76 @@ async function runAdd(args, options = {}) {
 						sourceType: parsed.type,
 						sourceUrl: parsed.url,
 						skillPath: skillPathValue,
-						skillFolderHash
+						skillFolderHash,
+						pluginName: skill.pluginName
 					});
 				} catch {}
 			}
 		}
+		if (successful.length > 0 && !installGlobally) {
+			const successfulSkillNames = new Set(successful.map((r) => r.skill));
+			for (const skill of selectedSkills) {
+				const skillDisplayName = getSkillDisplayName(skill);
+				if (successfulSkillNames.has(skillDisplayName)) try {
+					const computedHash = await computeSkillFolderHash(skill.path);
+					await addSkillToLocalLock(skill.name, {
+						source: normalizedSource || parsed.url,
+						sourceType: parsed.type,
+						computedHash
+					}, cwd);
+				} catch {}
+			}
+		}
 		if (successful.length > 0) {
 			const bySkill = /* @__PURE__ */ new Map();
+			const groupedResults = {};
+			const ungroupedResults = [];
 			for (const r of successful) {
 				const skillResults = bySkill.get(r.skill) || [];
 				skillResults.push(r);
 				bySkill.set(r.skill, skillResults);
+				if (skillResults.length === 1) if (r.pluginName) {
+					const group = r.pluginName;
+					if (!groupedResults[group]) groupedResults[group] = [];
+					groupedResults[group].push(r);
+				} else ungroupedResults.push(r);
 			}
 			const skillCount = bySkill.size;
 			const symlinkFailures = successful.filter((r) => r.mode === "symlink" && r.symlinkFailed);
 			const copiedAgents = symlinkFailures.map((r) => r.agent);
 			const resultLines = [];
-			for (const [skillName, skillResults] of bySkill) {
-				const firstResult = skillResults[0];
-				if (firstResult.mode === "copy") {
-					resultLines.push(`${import_picocolors.default.green("✓")} ${skillName} ${import_picocolors.default.dim("(copied)")}`);
-					for (const r of skillResults) {
-						const shortPath = shortenPath$1(r.path, cwd);
-						resultLines.push(`  ${import_picocolors.default.dim("→")} ${shortPath}`);
+			const printSkillResults = (entries) => {
+				for (const entry of entries) {
+					const skillResults = bySkill.get(entry.skill) || [];
+					const firstResult = skillResults[0];
+					if (firstResult.mode === "copy") {
+						resultLines.push(`${import_picocolors.default.green("✓")} ${entry.skill} ${import_picocolors.default.dim("(copied)")}`);
+						for (const r of skillResults) {
+							const shortPath = shortenPath$2(r.path, cwd);
+							resultLines.push(`  ${import_picocolors.default.dim("→")} ${shortPath}`);
+						}
+					} else {
+						if (firstResult.canonicalPath) {
+							const shortPath = shortenPath$2(firstResult.canonicalPath, cwd);
+							resultLines.push(`${import_picocolors.default.green("✓")} ${shortPath}`);
+						} else resultLines.push(`${import_picocolors.default.green("✓")} ${entry.skill}`);
+						resultLines.push(...buildResultLines(skillResults, targetAgents));
 					}
-				} else {
-					if (firstResult.canonicalPath) {
-						const shortPath = shortenPath$1(firstResult.canonicalPath, cwd);
-						resultLines.push(`${import_picocolors.default.green("✓")} ${shortPath}`);
-					} else resultLines.push(`${import_picocolors.default.green("✓")} ${skillName}`);
-					resultLines.push(...buildResultLines(skillResults, targetAgents));
 				}
+			};
+			const sortedResultGroups = Object.keys(groupedResults).sort();
+			for (const group of sortedResultGroups) {
+				const title = group.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+				resultLines.push("");
+				resultLines.push(import_picocolors.default.bold(title));
+				printSkillResults(groupedResults[group]);
+			}
+			if (ungroupedResults.length > 0) {
+				if (sortedResultGroups.length > 0) {
+					resultLines.push("");
+					resultLines.push(import_picocolors.default.bold("General"));
+				}
+				printSkillResults(ungroupedResults);
 			}
 			const title = import_picocolors.default.green(`Installed ${skillCount} skill${skillCount !== 1 ? "s" : ""}`);
 			Me(resultLines.join("\n"), title);
@@ -3113,6 +3388,7 @@ function parseAddOptions(args) {
 			}
 			i--;
 		} else if (arg === "--full-depth") options.fullDepth = true;
+		else if (arg === "--copy") options.copy = true;
 		else if (arg && !arg.startsWith("-")) source.push(arg);
 	}
 	return {
@@ -3342,6 +3618,340 @@ ${DIM$2}  2) npx skills add <owner/repo@skill>${RESET$2}`;
 	else console.log(`${DIM$2}Discover more skills at${RESET$2} ${TEXT$1}https://skills.sh${RESET$2}`);
 	console.log();
 }
+const isCancelled = (value) => typeof value === "symbol";
+function shortenPath$1(fullPath, cwd) {
+	const home = homedir();
+	if (fullPath === home || fullPath.startsWith(home + sep)) return "~" + fullPath.slice(home.length);
+	if (fullPath === cwd || fullPath.startsWith(cwd + sep)) return "." + fullPath.slice(cwd.length);
+	return fullPath;
+}
+async function discoverNodeModuleSkills(cwd) {
+	const nodeModulesDir = join(cwd, "node_modules");
+	const skills = [];
+	let topNames;
+	try {
+		topNames = await readdir(nodeModulesDir);
+	} catch {
+		return skills;
+	}
+	const processPackageDir = async (pkgDir, packageName) => {
+		const rootSkill = await parseSkillMd(join(pkgDir, "SKILL.md"));
+		if (rootSkill) {
+			skills.push({
+				...rootSkill,
+				packageName
+			});
+			return;
+		}
+		const searchDirs = [
+			pkgDir,
+			join(pkgDir, "skills"),
+			join(pkgDir, ".agents", "skills")
+		];
+		for (const searchDir of searchDirs) try {
+			const entries = await readdir(searchDir);
+			for (const name of entries) {
+				const skillDir = join(searchDir, name);
+				try {
+					if (!(await stat(skillDir)).isDirectory()) continue;
+				} catch {
+					continue;
+				}
+				const skill = await parseSkillMd(join(skillDir, "SKILL.md"));
+				if (skill) skills.push({
+					...skill,
+					packageName
+				});
+			}
+		} catch {}
+	};
+	await Promise.all(topNames.map(async (name) => {
+		if (name.startsWith(".")) return;
+		const fullPath = join(nodeModulesDir, name);
+		try {
+			if (!(await stat(fullPath)).isDirectory()) return;
+		} catch {
+			return;
+		}
+		if (name.startsWith("@")) try {
+			const scopeNames = await readdir(fullPath);
+			await Promise.all(scopeNames.map(async (scopedName) => {
+				const scopedPath = join(fullPath, scopedName);
+				try {
+					if (!(await stat(scopedPath)).isDirectory()) return;
+				} catch {
+					return;
+				}
+				await processPackageDir(scopedPath, `${name}/${scopedName}`);
+			}));
+		} catch {}
+		else await processPackageDir(fullPath, name);
+	}));
+	return skills;
+}
+async function runSync(args, options = {}) {
+	const cwd = process.cwd();
+	console.log();
+	Ie(import_picocolors.default.bgCyan(import_picocolors.default.black(" skills experimental_sync ")));
+	const spinner = Y();
+	spinner.start("Scanning node_modules for skills...");
+	const discoveredSkills = await discoverNodeModuleSkills(cwd);
+	if (discoveredSkills.length === 0) {
+		spinner.stop(import_picocolors.default.yellow("No skills found"));
+		Se(import_picocolors.default.dim("No SKILL.md files found in node_modules."));
+		return;
+	}
+	spinner.stop(`Found ${import_picocolors.default.green(String(discoveredSkills.length))} skill${discoveredSkills.length > 1 ? "s" : ""} in node_modules`);
+	for (const skill of discoveredSkills) {
+		M.info(`${import_picocolors.default.cyan(skill.name)} ${import_picocolors.default.dim(`from ${skill.packageName}`)}`);
+		if (skill.description) M.message(import_picocolors.default.dim(`  ${skill.description}`));
+	}
+	const localLock = await readLocalLock(cwd);
+	const toInstall = [];
+	const upToDate = [];
+	if (options.force) {
+		toInstall.push(...discoveredSkills);
+		M.info(import_picocolors.default.dim("Force mode: reinstalling all skills"));
+	} else {
+		for (const skill of discoveredSkills) {
+			const existingEntry = localLock.skills[skill.name];
+			if (existingEntry) {
+				if (await computeSkillFolderHash(skill.path) === existingEntry.computedHash) {
+					upToDate.push(skill.name);
+					continue;
+				}
+			}
+			toInstall.push(skill);
+		}
+		if (upToDate.length > 0) M.info(import_picocolors.default.dim(`${upToDate.length} skill${upToDate.length !== 1 ? "s" : ""} already up to date`));
+		if (toInstall.length === 0) {
+			console.log();
+			Se(import_picocolors.default.green("All skills are up to date."));
+			return;
+		}
+	}
+	M.info(`${toInstall.length} skill${toInstall.length !== 1 ? "s" : ""} to install/update`);
+	let targetAgents;
+	const validAgents = Object.keys(agents);
+	const universalAgents = getUniversalAgents();
+	if (options.agent?.includes("*")) {
+		targetAgents = validAgents;
+		M.info(`Installing to all ${targetAgents.length} agents`);
+	} else if (options.agent && options.agent.length > 0) {
+		const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+		if (invalidAgents.length > 0) {
+			M.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+			M.info(`Valid agents: ${validAgents.join(", ")}`);
+			process.exit(1);
+		}
+		targetAgents = options.agent;
+	} else {
+		spinner.start("Loading agents...");
+		const installedAgents = await detectInstalledAgents();
+		const totalAgents = Object.keys(agents).length;
+		spinner.stop(`${totalAgents} agents`);
+		if (installedAgents.length === 0) if (options.yes) {
+			targetAgents = universalAgents;
+			M.info("Installing to universal agents");
+		} else {
+			const selected = await searchMultiselect({
+				message: "Which agents do you want to install to?",
+				items: getNonUniversalAgents().map((a) => ({
+					value: a,
+					label: agents[a].displayName,
+					hint: agents[a].skillsDir
+				})),
+				initialSelected: [],
+				lockedSection: {
+					title: "Universal (.agents/skills)",
+					items: universalAgents.map((a) => ({
+						value: a,
+						label: agents[a].displayName
+					}))
+				}
+			});
+			if (isCancelled(selected)) {
+				xe("Sync cancelled");
+				process.exit(0);
+			}
+			targetAgents = selected;
+		}
+		else if (installedAgents.length === 1 || options.yes) {
+			targetAgents = [...installedAgents];
+			for (const ua of universalAgents) if (!targetAgents.includes(ua)) targetAgents.push(ua);
+		} else {
+			const selected = await searchMultiselect({
+				message: "Which agents do you want to install to?",
+				items: getNonUniversalAgents().filter((a) => installedAgents.includes(a)).map((a) => ({
+					value: a,
+					label: agents[a].displayName,
+					hint: agents[a].skillsDir
+				})),
+				initialSelected: installedAgents.filter((a) => !universalAgents.includes(a)),
+				lockedSection: {
+					title: "Universal (.agents/skills)",
+					items: universalAgents.map((a) => ({
+						value: a,
+						label: agents[a].displayName
+					}))
+				}
+			});
+			if (isCancelled(selected)) {
+				xe("Sync cancelled");
+				process.exit(0);
+			}
+			targetAgents = selected;
+		}
+	}
+	const summaryLines = [];
+	for (const skill of toInstall) {
+		const shortCanonical = shortenPath$1(getCanonicalPath(skill.name, { global: false }), cwd);
+		summaryLines.push(`${import_picocolors.default.cyan(skill.name)} ${import_picocolors.default.dim(`← ${skill.packageName}`)}`);
+		summaryLines.push(`  ${import_picocolors.default.dim(shortCanonical)}`);
+	}
+	console.log();
+	Me(summaryLines.join("\n"), "Sync Summary");
+	if (!options.yes) {
+		const confirmed = await ye({ message: "Proceed with sync?" });
+		if (pD(confirmed) || !confirmed) {
+			xe("Sync cancelled");
+			process.exit(0);
+		}
+	}
+	spinner.start("Syncing skills...");
+	const results = [];
+	for (const skill of toInstall) for (const agent of targetAgents) {
+		const result = await installSkillForAgent(skill, agent, {
+			global: false,
+			cwd,
+			mode: "symlink"
+		});
+		results.push({
+			skill: skill.name,
+			packageName: skill.packageName,
+			agent: agents[agent].displayName,
+			success: result.success,
+			path: result.path,
+			canonicalPath: result.canonicalPath,
+			error: result.error
+		});
+	}
+	spinner.stop("Sync complete");
+	const successful = results.filter((r) => r.success);
+	const failed = results.filter((r) => !r.success);
+	const successfulSkillNames = new Set(successful.map((r) => r.skill));
+	for (const skill of toInstall) if (successfulSkillNames.has(skill.name)) try {
+		const computedHash = await computeSkillFolderHash(skill.path);
+		await addSkillToLocalLock(skill.name, {
+			source: skill.packageName,
+			sourceType: "node_modules",
+			computedHash
+		}, cwd);
+	} catch {}
+	console.log();
+	if (successful.length > 0) {
+		const bySkill = /* @__PURE__ */ new Map();
+		for (const r of successful) {
+			const skillResults = bySkill.get(r.skill) || [];
+			skillResults.push(r);
+			bySkill.set(r.skill, skillResults);
+		}
+		const resultLines = [];
+		for (const [skillName, skillResults] of bySkill) {
+			const firstResult = skillResults[0];
+			const pkg = toInstall.find((s) => s.name === skillName)?.packageName;
+			if (firstResult.canonicalPath) {
+				const shortPath = shortenPath$1(firstResult.canonicalPath, cwd);
+				resultLines.push(`${import_picocolors.default.green("✓")} ${skillName} ${import_picocolors.default.dim(`← ${pkg}`)}`);
+				resultLines.push(`  ${import_picocolors.default.dim(shortPath)}`);
+			} else resultLines.push(`${import_picocolors.default.green("✓")} ${skillName} ${import_picocolors.default.dim(`← ${pkg}`)}`);
+		}
+		const skillCount = bySkill.size;
+		const title = import_picocolors.default.green(`Synced ${skillCount} skill${skillCount !== 1 ? "s" : ""}`);
+		Me(resultLines.join("\n"), title);
+	}
+	if (failed.length > 0) {
+		console.log();
+		M.error(import_picocolors.default.red(`Failed to install ${failed.length}`));
+		for (const r of failed) M.message(`  ${import_picocolors.default.red("✗")} ${r.skill} → ${r.agent}: ${import_picocolors.default.dim(r.error)}`);
+	}
+	track({
+		event: "experimental_sync",
+		skillCount: String(toInstall.length),
+		successCount: String(successfulSkillNames.size),
+		agents: targetAgents.join(",")
+	});
+	console.log();
+	Se(import_picocolors.default.green("Done!") + import_picocolors.default.dim("  Review skills before use; they run with full agent permissions."));
+}
+function parseSyncOptions(args) {
+	const options = {};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "-y" || arg === "--yes") options.yes = true;
+		else if (arg === "-f" || arg === "--force") options.force = true;
+		else if (arg === "-a" || arg === "--agent") {
+			options.agent = options.agent || [];
+			i++;
+			let nextArg = args[i];
+			while (i < args.length && nextArg && !nextArg.startsWith("-")) {
+				options.agent.push(nextArg);
+				i++;
+				nextArg = args[i];
+			}
+			i--;
+		}
+	}
+	return { options };
+}
+async function runInstallFromLock(args) {
+	const lock = await readLocalLock(process.cwd());
+	const skillEntries = Object.entries(lock.skills);
+	if (skillEntries.length === 0) {
+		M.warn("No project skills found in skills-lock.json");
+		M.info(`Add project-level skills with ${import_picocolors.default.cyan("npx skills add <package>")} (without ${import_picocolors.default.cyan("-g")})`);
+		return;
+	}
+	const universalAgentNames = getUniversalAgents();
+	const nodeModuleSkills = [];
+	const bySource = /* @__PURE__ */ new Map();
+	for (const [skillName, entry] of skillEntries) {
+		if (entry.sourceType === "node_modules") {
+			nodeModuleSkills.push(skillName);
+			continue;
+		}
+		const existing = bySource.get(entry.source);
+		if (existing) existing.skills.push(skillName);
+		else bySource.set(entry.source, {
+			sourceType: entry.sourceType,
+			skills: [skillName]
+		});
+	}
+	const remoteCount = skillEntries.length - nodeModuleSkills.length;
+	if (remoteCount > 0) M.info(`Restoring ${import_picocolors.default.cyan(String(remoteCount))} skill${remoteCount !== 1 ? "s" : ""} from skills-lock.json into ${import_picocolors.default.dim(".agents/skills/")}`);
+	for (const [source, { skills }] of bySource) try {
+		await runAdd([source], {
+			skill: skills,
+			agent: universalAgentNames,
+			yes: true
+		});
+	} catch (error) {
+		M.error(`Failed to install from ${import_picocolors.default.cyan(source)}: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+	if (nodeModuleSkills.length > 0) {
+		M.info(`${import_picocolors.default.cyan(String(nodeModuleSkills.length))} skill${nodeModuleSkills.length !== 1 ? "s" : ""} from node_modules`);
+		try {
+			const { options: syncOptions } = parseSyncOptions(args);
+			await runSync(args, {
+				...syncOptions,
+				yes: true,
+				agent: universalAgentNames
+			});
+		} catch (error) {
+			M.error(`Failed to sync node_modules skills: ${error instanceof Error ? error.message : "Unknown error"}`);
+		}
+	}
+}
 const RESET$1 = "\x1B[0m";
 const BOLD$1 = "\x1B[1m";
 const DIM$1 = "\x1B[38;5;102m";
@@ -3389,6 +3999,7 @@ async function runList(args) {
 		global: scope,
 		agentFilter
 	});
+	const lockedSkills = await getAllLockedSkills();
 	const cwd = process.cwd();
 	const scopeLabel = scope ? "Global" : "Project";
 	if (installedSkills.length === 0) {
@@ -3397,17 +4008,44 @@ async function runList(args) {
 		else console.log(`${DIM$1}Try listing global skills with -g${RESET$1}`);
 		return;
 	}
-	function printSkill(skill) {
+	function printSkill(skill, indent = false) {
+		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$1}`;
-		console.log(`${CYAN}${skill.name}${RESET$1} ${DIM$1}${shortPath}${RESET$1}`);
-		console.log(`  ${DIM$1}Agents:${RESET$1} ${agentInfo}`);
+		console.log(`${prefix}${CYAN}${skill.name}${RESET$1} ${DIM$1}${shortPath}${RESET$1}`);
+		console.log(`${prefix}  ${DIM$1}Agents:${RESET$1} ${agentInfo}`);
 	}
 	console.log(`${BOLD$1}${scopeLabel} Skills${RESET$1}`);
 	console.log();
-	for (const skill of installedSkills) printSkill(skill);
-	console.log();
+	const groupedSkills = {};
+	const ungroupedSkills = [];
+	for (const skill of installedSkills) {
+		const lockEntry = lockedSkills[skill.name];
+		if (lockEntry?.pluginName) {
+			const group = lockEntry.pluginName;
+			if (!groupedSkills[group]) groupedSkills[group] = [];
+			groupedSkills[group].push(skill);
+		} else ungroupedSkills.push(skill);
+	}
+	if (Object.keys(groupedSkills).length > 0) {
+		const sortedGroups = Object.keys(groupedSkills).sort();
+		for (const group of sortedGroups) {
+			const title = group.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+			console.log(`${BOLD$1}${title}${RESET$1}`);
+			const skills = groupedSkills[group];
+			if (skills) for (const skill of skills) printSkill(skill, true);
+			console.log();
+		}
+		if (ungroupedSkills.length > 0) {
+			console.log(`${BOLD$1}General${RESET$1}`);
+			for (const skill of ungroupedSkills) printSkill(skill, true);
+			console.log();
+		}
+	} else {
+		for (const skill of installedSkills) printSkill(skill);
+		console.log();
+	}
 }
 async function removeCommand(skillNames, options) {
 	const isGlobal = options.global ?? false;
@@ -3472,10 +4110,8 @@ async function removeCommand(skillNames, options) {
 	let targetAgents;
 	if (options.agent && options.agent.length > 0) targetAgents = options.agent;
 	else {
-		spinner.start("Detecting installed agents...");
-		targetAgents = await detectInstalledAgents();
-		if (targetAgents.length === 0) targetAgents = Object.keys(agents);
-		spinner.stop(`Targeting ${targetAgents.length} installed agent(s)`);
+		targetAgents = Object.keys(agents);
+		spinner.stop(`Targeting ${targetAgents.length} potential agent(s)`);
 	}
 	if (!options.yes) {
 		console.log();
@@ -3491,25 +4127,42 @@ async function removeCommand(skillNames, options) {
 	spinner.start("Removing skills...");
 	const results = [];
 	for (const skillName of selectedSkills) try {
+		const canonicalPath = getCanonicalPath(skillName, {
+			global: isGlobal,
+			cwd
+		});
 		for (const agentKey of targetAgents) {
 			const agent = agents[agentKey];
 			const skillPath = getInstallPath(skillName, agentKey, {
 				global: isGlobal,
 				cwd
 			});
-			try {
-				if (await lstat(skillPath).catch(() => null)) await rm(skillPath, {
-					recursive: true,
-					force: true
-				});
-			} catch (err) {
-				M.warn(`Could not remove skill from ${agent.displayName}: ${err instanceof Error ? err.message : String(err)}`);
+			const pathsToCleanup = new Set([skillPath]);
+			const sanitizedName = sanitizeName(skillName);
+			if (isGlobal && agent.globalSkillsDir) pathsToCleanup.add(join(agent.globalSkillsDir, sanitizedName));
+			else pathsToCleanup.add(join(cwd, agent.skillsDir, sanitizedName));
+			for (const pathToCleanup of pathsToCleanup) {
+				if (pathToCleanup === canonicalPath) continue;
+				try {
+					if (await lstat(pathToCleanup).catch(() => null)) await rm(pathToCleanup, {
+						recursive: true,
+						force: true
+					});
+				} catch (err) {
+					M.warn(`Could not remove skill from ${agent.displayName}: ${err instanceof Error ? err.message : String(err)}`);
+				}
 			}
 		}
-		await rm(getCanonicalPath(skillName, {
+		const remainingAgents = (await detectInstalledAgents()).filter((a) => !targetAgents.includes(a));
+		let isStillUsed = false;
+		for (const agentKey of remainingAgents) if (await lstat(getInstallPath(skillName, agentKey, {
 			global: isGlobal,
 			cwd
-		}), {
+		})).catch(() => null)) {
+			isStillUsed = true;
+			break;
+		}
+		if (!isStillUsed) await rm(canonicalPath, {
 			recursive: true,
 			force: true
 		});
@@ -3626,13 +4279,17 @@ function showBanner() {
 	console.log();
 	console.log(`${DIM}The open agent skills ecosystem${RESET}`);
 	console.log();
-	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills add ${DIM}<package>${RESET}   ${DIM}Install a skill${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}`);
-	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills check${RESET}           ${DIM}Check for updates${RESET}`);
-	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills update${RESET}          ${DIM}Update all skills${RESET}`);
-	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills remove${RESET}          ${DIM}Remove installed skills${RESET}`);
-	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills init ${DIM}[name]${RESET}     ${DIM}Create a new skill${RESET}`);
+	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills add ${DIM}<package>${RESET}        ${DIM}Add a new skill${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}`);
+	console.log();
+	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills check${RESET}                ${DIM}Check for updates${RESET}`);
+	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills update${RESET}               ${DIM}Update all skills${RESET}`);
+	console.log();
+	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills experimental_install${RESET} ${DIM}Restore from skills-lock.json${RESET}`);
+	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills init ${DIM}[name]${RESET}          ${DIM}Create a new skill${RESET}`);
+	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills experimental_sync${RESET}    ${DIM}Sync skills from node_modules${RESET}`);
 	console.log();
 	console.log(`${DIM}try:${RESET} npx skills add vercel-labs/agent-skills`);
 	console.log();
@@ -3643,16 +4300,22 @@ function showHelp() {
 	console.log(`
 ${BOLD}Usage:${RESET} skills <command> [options]
 
-${BOLD}Commands:${RESET}
-  add <package>     Add a skill package
-                    e.g. vercel-labs/agent-skills
-                         https://github.com/vercel-labs/agent-skills
-  remove [skills]   Remove installed skills
-  list, ls          List installed skills
-  find [query]      Search for skills interactively
-  init [name]       Initialize a skill (creates <name>/SKILL.md or ./SKILL.md)
-  check             Check for available skill updates
-  update            Update all skills to latest versions
+${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
+  remove [skills]      Remove installed skills
+  list, ls             List installed skills
+  find [query]         Search for skills interactively
+
+${BOLD}Updates:${RESET}
+  check                Check for available skill updates
+  update               Update all skills to latest versions
+
+${BOLD}Project:${RESET}
+  experimental_install Restore skills from skills-lock.json
+  init [name]          Initialize a skill (creates <name>/SKILL.md or ./SKILL.md)
+  experimental_sync    Sync skills from node_modules into agent directories
 
 ${BOLD}Add Options:${RESET}
   -g, --global           Install skill globally (user-level) instead of project-level
@@ -3660,6 +4323,7 @@ ${BOLD}Add Options:${RESET}
   -s, --skill <skills>   Specify skill names to install (use '*' for all skills)
   -l, --list             List available skills in the repository without installing
   -y, --yes              Skip confirmation prompts
+  --copy                 Copy files instead of symlinking to agent directories
   --all                  Shorthand for --skill '*' --agent '*' -y
   --full-depth           Search all subdirectories even when a root SKILL.md exists
 
@@ -3670,6 +4334,10 @@ ${BOLD}Remove Options:${RESET}
   -y, --yes              Skip confirmation prompts
   --all                  Shorthand for --skill '*' --agent '*' -y
   
+${BOLD}Experimental Sync Options:${RESET}
+  -a, --agent <agents>   Specify agents to install to (use '*' for all agents)
+  -y, --yes              Skip confirmation prompts
+
 ${BOLD}List Options:${RESET}
   -g, --global           List global skills (default: project)
   -a, --agent <agents>   Filter by specific agents
@@ -3683,17 +4351,20 @@ ${BOLD}Examples:${RESET}
   ${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
-  ${DIM}$${RESET} skills remove                   ${DIM}# interactive remove${RESET}
-  ${DIM}$${RESET} skills remove web-design        ${DIM}# remove by name${RESET}
+  ${DIM}$${RESET} skills remove                        ${DIM}# interactive remove${RESET}
+  ${DIM}$${RESET} skills remove web-design             ${DIM}# remove by name${RESET}
   ${DIM}$${RESET} skills rm --global frontend-design
-  ${DIM}$${RESET} skills list                     ${DIM}# list all installed skills${RESET}
-  ${DIM}$${RESET} skills ls -g                    ${DIM}# list global skills only${RESET}
-  ${DIM}$${RESET} skills ls -a claude-code        ${DIM}# filter by agent${RESET}
-  ${DIM}$${RESET} skills find                     ${DIM}# interactive search${RESET}
-  ${DIM}$${RESET} skills find typescript          ${DIM}# search by keyword${RESET}
-  ${DIM}$${RESET} skills init my-skill
+  ${DIM}$${RESET} skills list                          ${DIM}# list project skills${RESET}
+  ${DIM}$${RESET} skills ls -g                         ${DIM}# list global skills${RESET}
+  ${DIM}$${RESET} skills ls -a claude-code             ${DIM}# filter by agent${RESET}
+  ${DIM}$${RESET} skills find                          ${DIM}# interactive search${RESET}
+  ${DIM}$${RESET} skills find typescript               ${DIM}# search by keyword${RESET}
   ${DIM}$${RESET} skills check
   ${DIM}$${RESET} skills update
+  ${DIM}$${RESET} skills experimental_install            ${DIM}# restore from skills-lock.json${RESET}
+  ${DIM}$${RESET} skills init my-skill
+  ${DIM}$${RESET} skills experimental_sync              ${DIM}# sync from node_modules${RESET}
+  ${DIM}$${RESET} skills experimental_sync -y           ${DIM}# sync without prompts${RESET}
 
 Discover more skills at ${TEXT}https://skills.sh/${RESET}
 `);
@@ -3984,13 +4655,17 @@ async function main() {
 			console.log();
 			runInit(restArgs);
 			break;
+		case "experimental_install":
+			showLogo();
+			await runInstallFromLock(restArgs);
+			break;
 		case "i":
 		case "install":
 		case "a":
 		case "add": {
 			showLogo();
-			const { source, options } = parseAddOptions(restArgs);
-			await runAdd(source, options);
+			const { source: addSource, options: addOpts } = parseAddOptions(restArgs);
+			await runAdd(addSource, addOpts);
 			break;
 		}
 		case "remove":
@@ -4003,6 +4678,12 @@ async function main() {
 			const { skills, options: removeOptions } = parseRemoveOptions(restArgs);
 			await removeCommand(skills, removeOptions);
 			break;
+		case "experimental_sync": {
+			showLogo();
+			const { options: syncOptions } = parseSyncOptions(restArgs);
+			await runSync(restArgs, syncOptions);
+			break;
+		}
 		case "list":
 		case "ls":
 			await runList(restArgs);