skills 1.4.0 → 1.4.1

package/README.md

@@ -3,7 +3,7 @@
 The CLI for the open agent skills ecosystem.
 
 <!-- agent-list:start -->
-Supports **OpenCode**, **Claude Code**, **Codex**, **Cursor**, and [35 more](#available-agents).
+Supports **OpenCode**, **Claude Code**, **Codex**, **Cursor**, and [37 more](#available-agents).
 <!-- agent-list:end -->
 
 ## Install a Skill
@@ -42,6 +42,7 @@ npx skills add ./my-local-skills
 | `-a, --agent <agents...>` | <!-- agent-names:start -->Target specific agents (e.g., `claude-code`, `codex`). See [Available Agents](#available-agents)<!-- agent-names:end -->                  |
 | `-s, --skill <skills...>` | Install specific skills by name (use `'*'` for all skills)                                                                                         |
 | `-l, --list`              | List available skills without installing                                                                                                           |
+| `--copy`                  | Copy files instead of symlinking to agent directories                                                                                              |
 | `-y, --yes`               | Skip all confirmation prompts                                                                                                                      |
 | `--all`                   | Install all skills to all agents without prompts                                                                                                   |
 
@@ -91,14 +92,14 @@ When installing interactively, you can choose:
 
 ## Other Commands
 
-| Command                      | Description                                             |
-| ---------------------------- | ------------------------------------------------------- |
-| `npx skills list`            | List installed skills (alias: `ls`)                     |
-| `npx skills find [query]`    | Search for skills interactively or by keyword           |
-| `npx skills remove [skills]` | Remove installed skills from agents                     |
-| `npx skills check`           | Check for available skill updates                       |
-| `npx skills update`          | Update all installed skills to latest versions          |
-| `npx skills init [name]`     | Create a new SKILL.md template                          |
+| Command                      | Description                                    |
+| ---------------------------- | ---------------------------------------------- |
+| `npx skills list`            | List installed skills (alias: `ls`)            |
+| `npx skills find [query]`    | Search for skills interactively or by keyword  |
+| `npx skills remove [skills]` | Remove installed skills from agents            |
+| `npx skills check`           | Check for available skill updates              |
+| `npx skills update`          | Update all installed skills to latest versions |
+| `npx skills init [name]`     | Create a new SKILL.md template                 |
 
 ### `skills list`
 
@@ -180,13 +181,13 @@ npx skills remove my-skill --agent '*'
 npx skills rm my-skill
 ```
 
-| Option              | Description                                          |
-| ------------------- | ---------------------------------------------------- |
-| `-g, --global`      | Remove from global scope (~/) instead of project      |
-| `-a, --agent`       | Remove from specific agents (use `'*'` for all)      |
-| `-s, --skill`       | Specify skills to remove (use `'*'` for all)         |
-| `-y, --yes`         | Skip confirmation prompts                            |
-| `--all`             | Shorthand for `--skill '*' --agent '*' -y`           |
+| Option         | Description                                      |
+| -------------- | ------------------------------------------------ |
+| `-g, --global` | Remove from global scope (~/) instead of project |
+| `-a, --agent`  | Remove from specific agents (use `'*'` for all)  |
+| `-s, --skill`  | Specify skills to remove (use `'*'` for all)     |
+| `-y, --yes`    | Skip confirmation prompts                        |
+| `--all`        | Shorthand for `--skill '*' --agent '*' -y`       |
 
 ## What are Agent Skills?
 
@@ -208,7 +209,7 @@ Skills can be installed to any of these agents:
 <!-- supported-agents:start -->
 | Agent | `--agent` | Project Path | Global Path |
 |-------|-----------|--------------|-------------|
-| Amp, Kimi Code CLI, Replit | `amp`, `kimi-cli`, `replit` | `.agents/skills/` | `~/.config/agents/skills/` |
+| Amp, Kimi Code CLI, Replit, Universal | `amp`, `kimi-cli`, `replit`, `universal` | `.agents/skills/` | `~/.config/agents/skills/` |
 | Antigravity | `antigravity` | `.agent/skills/` | `~/.gemini/antigravity/skills/` |
 | Augment | `augment` | `.augment/skills/` | `~/.augment/skills/` |
 | Claude Code | `claude-code` | `.claude/skills/` | `~/.claude/skills/` |
@@ -218,8 +219,9 @@ Skills can be installed to any of these agents:
 | Codex | `codex` | `.agents/skills/` | `~/.codex/skills/` |
 | Command Code | `command-code` | `.commandcode/skills/` | `~/.commandcode/skills/` |
 | Continue | `continue` | `.continue/skills/` | `~/.continue/skills/` |
+| Cortex Code | `cortex` | `.cortex/skills/` | `~/.snowflake/cortex/skills/` |
 | Crush | `crush` | `.crush/skills/` | `~/.config/crush/skills/` |
-| Cursor | `cursor` | `.cursor/skills/` | `~/.cursor/skills/` |
+| Cursor | `cursor` | `.agents/skills/` | `~/.cursor/skills/` |
 | Droid | `droid` | `.factory/skills/` | `~/.factory/skills/` |
 | Gemini CLI | `gemini-cli` | `.agents/skills/` | `~/.gemini/skills/` |
 | GitHub Copilot | `github-copilot` | `.agents/skills/` | `~/.copilot/skills/` |
@@ -323,8 +325,8 @@ The CLI searches for skills in these locations within a repository:
 - `.codebuddy/skills/`
 - `.commandcode/skills/`
 - `.continue/skills/`
+- `.cortex/skills/`
 - `.crush/skills/`
-- `.cursor/skills/`
 - `.factory/skills/`
 - `.goose/skills/`
 - `.junie/skills/`
@@ -356,11 +358,13 @@ If `.claude-plugin/marketplace.json` or `.claude-plugin/plugin.json` exists, ski
 // .claude-plugin/marketplace.json
 {
   "metadata": { "pluginRoot": "./plugins" },
-  "plugins": [{
-    "name": "my-plugin",
-    "source": "my-plugin",
-    "skills": ["./skills/review", "./skills/test"]
-  }]
+  "plugins": [
+    {
+      "name": "my-plugin",
+      "source": "my-plugin",
+      "skills": ["./skills/review", "./skills/test"]
+    }
+  ]
 }
 ```
 

package/dist/cli.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",
@@ -489,7 +497,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"),
@@ -570,7 +577,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: {
@@ -645,6 +652,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 +673,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 +703,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 +802,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 +848,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 +922,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 +960,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 +995,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 +1030,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 +1089,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 +1125,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 +1154,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 +1226,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 +1754,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 +1764,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();
@@ -1801,7 +1837,7 @@ async function getSkillFromLock(skillName) {
 }
 function createEmptyLockFile() {
 	return {
-		version: CURRENT_VERSION,
+		version: CURRENT_VERSION$1,
 		skills: {},
 		dismissed: {}
 	};
@@ -1823,8 +1859,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.1";
+const isCancelled$1 = (value) => typeof value === "symbol";
 async function isSourcePrivate(source) {
 	const ownerRepo = parseOwnerRepo(source);
 	if (!ownerRepo) return false;
@@ -1875,7 +1977,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 +2054,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 +2085,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 +2142,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 +2194,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 +2221,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 +2274,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));
@@ -2302,7 +2413,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 +2448,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 +2483,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 +2540,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 +2571,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 +2662,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 +2706,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 +2758,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));
@@ -2818,7 +2944,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 +2981,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: [{
@@ -2891,7 +3017,7 @@ async function runAdd(args, options = {}) {
 		}
 		for (const skill of selectedSkills) {
 			if (summaryLines.length > 0) summaryLines.push("");
-			const shortCanonical = shortenPath$1(getCanonicalPath(skill.name, { global: installGlobally }), cwd);
+			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);
@@ -2985,6 +3111,20 @@ async function runAdd(args, options = {}) {
 				} 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();
 			for (const r of successful) {
@@ -3001,12 +3141,12 @@ async function runAdd(args, options = {}) {
 				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));
@@ -3113,6 +3253,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 +3483,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";
@@ -3472,10 +3947,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 +3964,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 +4116,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 +4137,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 +4160,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 +4171,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 +4188,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 +4492,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 +4515,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skills",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "The open agent skills ecosystem",
   "type": "module",
   "bin": {
@@ -46,6 +46,7 @@
     "codex",
     "command-code",
     "continue",
+    "cortex",
     "crush",
     "cursor",
     "droid",
@@ -74,7 +75,8 @@
     "zencoder",
     "neovate",
     "pochi",
-    "adal"
+    "adal",
+    "universal"
   ],
   "repository": {
     "type": "git",