skill-master 0.1.6 → 0.1.10

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/core/installer.ts
-import { join as join6 } from "path";
+import { join as join7, resolve as resolve3, relative } from "path";
 import { existsSync as existsSync6 } from "fs";
 
 // src/core/git-source.ts
@@ -145,6 +145,9 @@ function step(num, total, msg) {
 function blank() {
   console.log();
 }
+function section(title) {
+  console.log(chalk.bold(title));
+}
 function kv(key, value) {
   console.log(`  ${chalk.gray(key + ":")} ${value}`);
 }
@@ -278,9 +281,123 @@ async function cloneRepo(url, branch) {
 
 // src/core/skill-parser.ts
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-import { readdir } from "fs/promises";
-import { join as join2, basename } from "path";
+import { readdir as readdir2 } from "fs/promises";
+import { join as join3, basename, resolve as resolve2 } from "path";
 import { existsSync as existsSync3 } from "fs";
+
+// src/core/plugin-manifest.ts
+import { readFile as readFile2, readdir } from "fs/promises";
+import { join as join2, dirname as dirname2, resolve, normalize, sep } from "path";
+function isContainedIn(targetPath, basePath) {
+  const normalizedBase = normalize(resolve(basePath));
+  const normalizedTarget = normalize(resolve(targetPath));
+  return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
+}
+function isValidRelativePath(path) {
+  return path.startsWith("./");
+}
+async function getPluginSkillPaths(basePath) {
+  const searchDirs = [];
+  const addPluginSkillPaths = (pluginBase, skills) => {
+    if (!isContainedIn(pluginBase, basePath)) return;
+    if (skills && skills.length > 0) {
+      for (const skillPath of skills) {
+        if (!isValidRelativePath(skillPath)) continue;
+        const skillDir = dirname2(join2(pluginBase, skillPath));
+        if (isContainedIn(skillDir, basePath)) {
+          searchDirs.push(skillDir);
+        }
+      }
+    }
+    searchDirs.push(join2(pluginBase, "skills"));
+  };
+  try {
+    const content = await readFile2(join2(basePath, ".claude-plugin/marketplace.json"), "utf-8");
+    const manifest = JSON.parse(content);
+    const pluginRoot = manifest.metadata?.pluginRoot;
+    const validPluginRoot = pluginRoot === void 0 || isValidRelativePath(pluginRoot);
+    if (validPluginRoot) {
+      for (const plugin of manifest.plugins ?? []) {
+        if (typeof plugin.source !== "string" && plugin.source !== void 0) continue;
+        if (plugin.source !== void 0 && !isValidRelativePath(plugin.source)) continue;
+        const pluginBase = join2(basePath, pluginRoot ?? "", plugin.source ?? "");
+        addPluginSkillPaths(pluginBase, plugin.skills);
+      }
+    }
+  } catch {
+  }
+  try {
+    const content = await readFile2(join2(basePath, ".claude-plugin/plugin.json"), "utf-8");
+    const manifest = JSON.parse(content);
+    addPluginSkillPaths(basePath, manifest.skills);
+  } catch {
+  }
+  return searchDirs;
+}
+async function scanSkillsDir(skillsDir, pluginName, basePath, groupings) {
+  try {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillPath = join2(skillsDir, entry.name);
+      if (isContainedIn(skillPath, basePath)) {
+        groupings.set(resolve(skillPath), pluginName);
+      }
+    }
+  } catch {
+  }
+}
+async function getPluginGroupings(basePath) {
+  const groupings = /* @__PURE__ */ new Map();
+  try {
+    const content = await readFile2(join2(basePath, ".claude-plugin/marketplace.json"), "utf-8");
+    const manifest = JSON.parse(content);
+    const pluginRoot = manifest.metadata?.pluginRoot;
+    const validPluginRoot = pluginRoot === void 0 || isValidRelativePath(pluginRoot);
+    if (validPluginRoot) {
+      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 = join2(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 = join2(pluginBase, skillPath);
+            if (isContainedIn(skillDir, basePath)) {
+              groupings.set(resolve(skillDir), plugin.name);
+            }
+          }
+        } else {
+          await scanSkillsDir(join2(pluginBase, "skills"), plugin.name, basePath, groupings);
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    const content = await readFile2(join2(basePath, ".claude-plugin/plugin.json"), "utf-8");
+    const manifest = JSON.parse(content);
+    if (manifest.name) {
+      if (manifest.skills && manifest.skills.length > 0) {
+        for (const skillPath of manifest.skills) {
+          if (!isValidRelativePath(skillPath)) continue;
+          const skillDir = join2(basePath, skillPath);
+          if (isContainedIn(skillDir, basePath)) {
+            groupings.set(resolve(skillDir), manifest.name);
+          }
+        }
+      } else {
+        await scanSkillsDir(join2(basePath, "skills"), manifest.name, basePath, groupings);
+      }
+    }
+  } catch {
+  }
+  return groupings;
+}
+
+// src/core/skill-parser.ts
 var TOOL_CAPABILITY_MAP = {
   "Bash": "shell",
   "Read": "read_file",
@@ -341,62 +458,108 @@ async function findSkillDirectory(dir) {
 }
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build"]);
 async function findAllSkillDirectories(dir, fullDepth = false) {
+  const results = await findAllSkillDirectoriesWithPlugins(dir, fullDepth);
+  return results.map((r) => r.path);
+}
+async function findAllSkillDirectoriesWithPlugins(dir, fullDepth = false) {
+  const pluginGroupings = await getPluginGroupings(dir);
+  const enhance = (skillPath) => {
+    const resolvedPath = resolve2(skillPath);
+    const pluginName = pluginGroupings.get(resolvedPath);
+    return { path: skillPath, pluginName };
+  };
   if (fullDepth) {
     const results2 = /* @__PURE__ */ new Set();
     await walkForSkills(dir, 0, 5, results2);
-    return [...results2];
+    return [...results2].map(enhance);
   }
   const results = [];
-  if (existsSync3(join2(dir, "SKILL.md"))) {
-    results.push(dir);
+  if (existsSync3(join3(dir, "SKILL.md"))) {
+    results.push(enhance(dir));
     return results;
   }
-  const skillsRoot = join2(dir, ".claude", "skills");
-  if (existsSync3(skillsRoot)) {
+  const seenPaths = /* @__PURE__ */ new Set();
+  const pluginSkillPaths = await getPluginSkillPaths(dir);
+  const priorityDirs = [
+    ...pluginSkillPaths,
+    // Plugin manifest paths first
+    join3(dir, "skills"),
+    join3(dir, "skills", ".curated"),
+    join3(dir, "skills", ".experimental"),
+    join3(dir, "skills", ".system"),
+    join3(dir, ".agent", "skills"),
+    join3(dir, ".agents", "skills"),
+    join3(dir, ".claude", "skills"),
+    join3(dir, ".cline", "skills"),
+    join3(dir, ".codex", "skills"),
+    join3(dir, ".github", "skills"),
+    join3(dir, ".kiro", "skills"),
+    join3(dir, ".opencode", "skills"),
+    join3(dir, ".roo", "skills"),
+    join3(dir, ".windsurf", "skills")
+  ];
+  for (const searchDir of priorityDirs) {
     try {
-      const entries = await readdir(skillsRoot, { withFileTypes: true });
+      const entries = await readdir2(searchDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const skillMdPath = join2(skillsRoot, entry.name, "SKILL.md");
-          if (existsSync3(skillMdPath)) {
-            results.push(join2(skillsRoot, entry.name));
+          const skillDir = join3(searchDir, entry.name);
+          if (existsSync3(join3(skillDir, "SKILL.md")) && !seenPaths.has(skillDir)) {
+            results.push(enhance(skillDir));
+            seenPaths.add(skillDir);
           }
         }
       }
     } catch {
     }
   }
-  try {
-    const topEntries = await readdir(dir, { withFileTypes: true });
-    for (const entry of topEntries) {
-      if (entry.isDirectory() && !entry.name.startsWith(".")) {
-        const skillMdPath = join2(dir, entry.name, "SKILL.md");
-        if (existsSync3(skillMdPath)) {
-          results.push(join2(dir, entry.name));
+  if (results.length === 0) {
+    try {
+      const topEntries = await readdir2(dir, { withFileTypes: true });
+      for (const entry of topEntries) {
+        if (entry.isDirectory() && !entry.name.startsWith(".") && !SKIP_DIRS.has(entry.name)) {
+          const subDir = join3(dir, entry.name);
+          if (existsSync3(join3(subDir, "SKILL.md")) && !seenPaths.has(subDir)) {
+            results.push(enhance(subDir));
+            seenPaths.add(subDir);
+          }
+          try {
+            const subEntries = await readdir2(subDir, { withFileTypes: true });
+            for (const sub of subEntries) {
+              if (sub.isDirectory() && !sub.name.startsWith(".") && !SKIP_DIRS.has(sub.name)) {
+                const nested = join3(subDir, sub.name);
+                if (existsSync3(join3(nested, "SKILL.md")) && !seenPaths.has(nested)) {
+                  results.push(enhance(nested));
+                  seenPaths.add(nested);
+                }
+              }
+            }
+          } catch {
+          }
         }
       }
+    } catch {
     }
-  } catch {
   }
   return results;
 }
 async function walkForSkills(dir, depth, maxDepth, results) {
   if (depth > maxDepth) return;
-  if (existsSync3(join2(dir, "SKILL.md"))) {
+  if (existsSync3(join3(dir, "SKILL.md"))) {
     results.add(dir);
   }
   try {
-    const entries = await readdir(dir, { withFileTypes: true });
+    const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && !SKIP_DIRS.has(entry.name)) {
-        await walkForSkills(join2(dir, entry.name), depth + 1, maxDepth, results);
+        await walkForSkills(join3(dir, entry.name), depth + 1, maxDepth, results);
       }
     }
   } catch {
   }
 }
 async function readSkillMd(dir) {
-  const content = await readTextSafe(join2(dir, "SKILL.md"));
+  const content = await readTextSafe(join3(dir, "SKILL.md"));
   if (!content) return null;
   return parseSkillMd(content, basename(dir));
 }
@@ -413,315 +576,364 @@ function extractEnvKeys(envExampleContent) {
   }
   return keys;
 }
+async function discoverNodeModulesSkills(cwd) {
+  const nmDir = join3(cwd, "node_modules");
+  if (!existsSync3(nmDir)) return [];
+  const results = [];
+  try {
+    const entries = await readdir2(nmDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith("@")) {
+        try {
+          const scopeEntries = await readdir2(join3(nmDir, entry.name), { withFileTypes: true });
+          for (const scopeEntry of scopeEntries) {
+            if (scopeEntry.isDirectory()) {
+              const pkgDir = join3(nmDir, entry.name, scopeEntry.name);
+              if (existsSync3(join3(pkgDir, "SKILL.md"))) {
+                results.push(pkgDir);
+              }
+            }
+          }
+        } catch {
+        }
+      } else if (!entry.name.startsWith(".")) {
+        const pkgDir = join3(nmDir, entry.name);
+        if (existsSync3(join3(pkgDir, "SKILL.md"))) {
+          results.push(pkgDir);
+        }
+      }
+    }
+  } catch {
+  }
+  return results;
+}
 
 // src/core/env-manager.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/utils/paths.ts
 import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/platform/agents.ts
 import { existsSync as existsSync4 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { homedir } from "os";
 var home = homedir();
-var configHome = process.env.XDG_CONFIG_HOME?.trim() || join3(home, ".config");
-var codexHome = process.env.CODEX_HOME?.trim() || join3(home, ".codex");
-var claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join3(home, ".claude");
+var configHome = process.env.XDG_CONFIG_HOME?.trim() || join4(home, ".config");
+var codexHome = process.env.CODEX_HOME?.trim() || join4(home, ".codex");
+var claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join4(home, ".claude");
 var AGENTS = {
   amp: {
     name: "amp",
     displayName: "Amp",
     skillsDir: ".agents/skills",
-    globalSkillsDir: join3(configHome, "agents/skills")
+    globalSkillsDir: join4(configHome, "agents/skills")
   },
   antigravity: {
     name: "antigravity",
     displayName: "Antigravity",
     skillsDir: ".agent/skills",
-    globalSkillsDir: join3(home, ".gemini/antigravity/skills"),
+    globalSkillsDir: join4(home, ".gemini/antigravity/skills"),
     detectMarker: ".agent"
   },
   augment: {
     name: "augment",
     displayName: "Augment",
     skillsDir: ".augment/skills",
-    globalSkillsDir: join3(home, ".augment/skills"),
+    globalSkillsDir: join4(home, ".augment/skills"),
     detectMarker: ".augment"
   },
   "claude-code": {
     name: "claude-code",
     displayName: "Claude Code",
     skillsDir: ".claude/skills",
-    globalSkillsDir: join3(claudeHome, "skills"),
+    globalSkillsDir: join4(claudeHome, "skills"),
     detectMarker: ".claude"
   },
   openclaw: {
     name: "openclaw",
     displayName: "OpenClaw",
     skillsDir: "skills",
-    globalSkillsDir: join3(home, ".openclaw/skills")
+    globalSkillsDir: join4(home, ".openclaw/skills")
   },
   cline: {
     name: "cline",
     displayName: "Cline",
-    skillsDir: ".cline/skills",
-    globalSkillsDir: join3(home, ".cline/skills"),
+    skillsDir: ".agents/skills",
+    globalSkillsDir: join4(home, ".agents", "skills"),
     detectMarker: ".cline"
   },
   codebuddy: {
     name: "codebuddy",
     displayName: "CodeBuddy",
     skillsDir: ".codebuddy/skills",
-    globalSkillsDir: join3(home, ".codebuddy/skills"),
+    globalSkillsDir: join4(home, ".codebuddy/skills"),
     detectMarker: ".codebuddy"
   },
   codex: {
     name: "codex",
     displayName: "Codex",
     skillsDir: ".agents/skills",
-    globalSkillsDir: join3(codexHome, "skills")
+    globalSkillsDir: join4(codexHome, "skills")
   },
   "command-code": {
     name: "command-code",
     displayName: "Command Code",
     skillsDir: ".commandcode/skills",
-    globalSkillsDir: join3(home, ".commandcode/skills"),
+    globalSkillsDir: join4(home, ".commandcode/skills"),
     detectMarker: ".commandcode"
   },
+  cortex: {
+    name: "cortex",
+    displayName: "Cortex",
+    skillsDir: ".cortex/skills",
+    globalSkillsDir: join4(home, ".snowflake/cortex/skills")
+  },
   continue: {
     name: "continue",
     displayName: "Continue",
     skillsDir: ".continue/skills",
-    globalSkillsDir: join3(home, ".continue/skills"),
+    globalSkillsDir: join4(home, ".continue/skills"),
     detectMarker: ".continue"
   },
   crush: {
     name: "crush",
     displayName: "Crush",
     skillsDir: ".crush/skills",
-    globalSkillsDir: join3(home, ".config/crush/skills")
+    globalSkillsDir: join4(home, ".config/crush/skills")
   },
   cursor: {
     name: "cursor",
     displayName: "Cursor",
-    skillsDir: ".cursor/skills",
-    globalSkillsDir: join3(home, ".cursor/skills"),
+    skillsDir: ".agents/skills",
+    globalSkillsDir: join4(home, ".cursor/skills"),
     detectMarker: ".cursor"
   },
   droid: {
     name: "droid",
     displayName: "Droid",
     skillsDir: ".factory/skills",
-    globalSkillsDir: join3(home, ".factory/skills"),
+    globalSkillsDir: join4(home, ".factory/skills"),
     detectMarker: ".factory"
   },
   "gemini-cli": {
     name: "gemini-cli",
     displayName: "Gemini CLI",
     skillsDir: ".agents/skills",
-    globalSkillsDir: join3(home, ".gemini/skills")
+    globalSkillsDir: join4(home, ".gemini/skills")
   },
   "github-copilot": {
     name: "github-copilot",
     displayName: "GitHub Copilot",
     skillsDir: ".agents/skills",
-    globalSkillsDir: join3(home, ".copilot/skills")
+    globalSkillsDir: join4(home, ".copilot/skills")
   },
   goose: {
     name: "goose",
     displayName: "Goose",
     skillsDir: ".goose/skills",
-    globalSkillsDir: join3(configHome, "goose/skills"),
+    globalSkillsDir: join4(configHome, "goose/skills"),
     detectMarker: ".goose"
   },
   junie: {
     name: "junie",
     displayName: "Junie",
     skillsDir: ".junie/skills",
-    globalSkillsDir: join3(home, ".junie/skills"),
+    globalSkillsDir: join4(home, ".junie/skills"),
     detectMarker: ".junie"
   },
   "iflow-cli": {
     name: "iflow-cli",
     displayName: "iFlow CLI",
     skillsDir: ".iflow/skills",
-    globalSkillsDir: join3(home, ".iflow/skills"),
+    globalSkillsDir: join4(home, ".iflow/skills"),
     detectMarker: ".iflow"
   },
   kilo: {
     name: "kilo",
     displayName: "Kilo Code",
     skillsDir: ".kilocode/skills",
-    globalSkillsDir: join3(home, ".kilocode/skills"),
+    globalSkillsDir: join4(home, ".kilocode/skills"),
     detectMarker: ".kilocode"
   },
   "kimi-cli": {
     name: "kimi-cli",
     displayName: "Kimi Code CLI",
     skillsDir: ".agents/skills",
-    globalSkillsDir: join3(home, ".config/agents/skills")
+    globalSkillsDir: join4(home, ".config/agents/skills")
   },
   "kiro-cli": {
     name: "kiro-cli",
     displayName: "Kiro CLI",
     skillsDir: ".kiro/skills",
-    globalSkillsDir: join3(home, ".kiro/skills"),
+    globalSkillsDir: join4(home, ".kiro/skills"),
     detectMarker: ".kiro"
   },
   kode: {
     name: "kode",
     displayName: "Kode",
     skillsDir: ".kode/skills",
-    globalSkillsDir: join3(home, ".kode/skills"),
+    globalSkillsDir: join4(home, ".kode/skills"),
     detectMarker: ".kode"
   },
   mcpjam: {
     name: "mcpjam",
     displayName: "MCPJam",
     skillsDir: ".mcpjam/skills",
-    globalSkillsDir: join3(home, ".mcpjam/skills"),
+    globalSkillsDir: join4(home, ".mcpjam/skills"),
     detectMarker: ".mcpjam"
   },
   "mistral-vibe": {
     name: "mistral-vibe",
     displayName: "Mistral Vibe",
     skillsDir: ".vibe/skills",
-    globalSkillsDir: join3(home, ".vibe/skills"),
+    globalSkillsDir: join4(home, ".vibe/skills"),
     detectMarker: ".vibe"
   },
   mux: {
     name: "mux",
     displayName: "Mux",
     skillsDir: ".mux/skills",
-    globalSkillsDir: join3(home, ".mux/skills"),
+    globalSkillsDir: join4(home, ".mux/skills"),
     detectMarker: ".mux"
   },
   opencode: {
     name: "opencode",
     displayName: "OpenCode",
-    skillsDir: ".opencode/skills",
-    globalSkillsDir: join3(configHome, "opencode/skills")
+    skillsDir: ".agents/skills",
+    globalSkillsDir: join4(configHome, "opencode/skills")
   },
   openhands: {
     name: "openhands",
     displayName: "OpenHands",
     skillsDir: ".openhands/skills",
-    globalSkillsDir: join3(home, ".openhands/skills"),
+    globalSkillsDir: join4(home, ".openhands/skills"),
     detectMarker: ".openhands"
   },
   pi: {
     name: "pi",
     displayName: "Pi",
     skillsDir: ".pi/skills",
-    globalSkillsDir: join3(home, ".pi/agent/skills"),
+    globalSkillsDir: join4(home, ".pi/agent/skills"),
     detectMarker: ".pi"
   },
   qoder: {
     name: "qoder",
     displayName: "Qoder",
     skillsDir: ".qoder/skills",
-    globalSkillsDir: join3(home, ".qoder/skills"),
+    globalSkillsDir: join4(home, ".qoder/skills"),
     detectMarker: ".qoder"
   },
   "qwen-code": {
     name: "qwen-code",
     displayName: "Qwen Code",
     skillsDir: ".qwen/skills",
-    globalSkillsDir: join3(home, ".qwen/skills"),
+    globalSkillsDir: join4(home, ".qwen/skills"),
     detectMarker: ".qwen"
   },
   replit: {
     name: "replit",
     displayName: "Replit",
     skillsDir: ".agents/skills",
-    globalSkillsDir: join3(configHome, "agents/skills")
+    globalSkillsDir: join4(configHome, "agents/skills"),
+    showInUniversalList: false
   },
   roo: {
     name: "roo",
     displayName: "Roo Code",
     skillsDir: ".roo/skills",
-    globalSkillsDir: join3(home, ".roo/skills"),
+    globalSkillsDir: join4(home, ".roo/skills"),
     detectMarker: ".roo"
   },
   trae: {
     name: "trae",
     displayName: "Trae",
     skillsDir: ".trae/skills",
-    globalSkillsDir: join3(home, ".trae/skills"),
+    globalSkillsDir: join4(home, ".trae/skills"),
     detectMarker: ".trae"
   },
   "trae-cn": {
     name: "trae-cn",
     displayName: "Trae CN",
     skillsDir: ".trae/skills",
-    globalSkillsDir: join3(home, ".trae-cn/skills")
+    globalSkillsDir: join4(home, ".trae-cn/skills")
   },
   windsurf: {
     name: "windsurf",
     displayName: "Windsurf",
     skillsDir: ".windsurf/skills",
-    globalSkillsDir: join3(home, ".codeium/windsurf/skills"),
+    globalSkillsDir: join4(home, ".codeium/windsurf/skills"),
     detectMarker: ".windsurf"
   },
   zencoder: {
     name: "zencoder",
     displayName: "Zencoder",
     skillsDir: ".zencoder/skills",
-    globalSkillsDir: join3(home, ".zencoder/skills"),
+    globalSkillsDir: join4(home, ".zencoder/skills"),
     detectMarker: ".zencoder"
   },
   neovate: {
     name: "neovate",
     displayName: "Neovate",
     skillsDir: ".neovate/skills",
-    globalSkillsDir: join3(home, ".neovate/skills"),
+    globalSkillsDir: join4(home, ".neovate/skills"),
     detectMarker: ".neovate"
   },
   pochi: {
     name: "pochi",
     displayName: "Pochi",
     skillsDir: ".pochi/skills",
-    globalSkillsDir: join3(home, ".pochi/skills"),
+    globalSkillsDir: join4(home, ".pochi/skills"),
     detectMarker: ".pochi"
   },
   adal: {
     name: "adal",
     displayName: "AdaL",
     skillsDir: ".adal/skills",
-    globalSkillsDir: join3(home, ".adal/skills"),
+    globalSkillsDir: join4(home, ".adal/skills"),
     detectMarker: ".adal"
+  },
+  universal: {
+    name: "universal",
+    displayName: "Universal",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: join4(configHome, "agents/skills"),
+    showInUniversalList: false
   }
 };
 function detectPlatform(cwd) {
   for (const [key, config] of Object.entries(AGENTS)) {
-    if (config.detectMarker && existsSync4(join3(cwd, config.detectMarker))) {
+    if (config.detectMarker && existsSync4(join4(cwd, config.detectMarker))) {
       return key;
     }
   }
-  if (existsSync4(join3(configHome, "opencode"))) {
+  if (existsSync4(join4(configHome, "opencode"))) {
     return "opencode";
   }
   return "claude-code";
 }
 function getAgentSkillPath(cwd, agent, name) {
-  return join3(cwd, AGENTS[agent].skillsDir, name);
+  return join4(cwd, AGENTS[agent].skillsDir, name);
 }
 function getAgentGlobalSkillPath(agent, name) {
-  return join3(AGENTS[agent].globalSkillsDir, name);
+  return join4(AGENTS[agent].globalSkillsDir, name);
+}
+function isUniversalAgent(type) {
+  return AGENTS[type].skillsDir === ".agents/skills";
 }
 
 // src/utils/paths.ts
-var AGENTS_HOME = join4(homedir2(), ".agents");
-var CONFIG_DIR = join4(AGENTS_HOME, "config");
-var SKILLS_DIR = join4(AGENTS_HOME, "skills");
-var REGISTRY_PATH = join4(AGENTS_HOME, "registry.json");
+var AGENTS_HOME = join5(homedir2(), ".agents");
+var CONFIG_DIR = join5(AGENTS_HOME, "config");
+var SKILLS_DIR = join5(AGENTS_HOME, "skills");
+var REGISTRY_PATH = join5(AGENTS_HOME, "registry.json");
 function getSkillCanonicalPath(name) {
-  return join4(SKILLS_DIR, name);
+  return join5(SKILLS_DIR, name);
 }
 function getSkillConfigPath(name) {
-  return join4(CONFIG_DIR, name);
+  return join5(CONFIG_DIR, name);
 }
 
 // src/core/env-manager.ts
@@ -746,9 +958,9 @@ function serializeEnv(data) {
 }
 async function backupEnv(skillName, agentSkillDir) {
   const locations = [
-    join5(getSkillConfigPath(skillName), ".env"),
-    ...agentSkillDir ? [join5(agentSkillDir, ".env")] : [],
-    join5(getSkillCanonicalPath(skillName), ".env")
+    join6(getSkillConfigPath(skillName), ".env"),
+    ...agentSkillDir ? [join6(agentSkillDir, ".env")] : [],
+    join6(getSkillCanonicalPath(skillName), ".env")
   ];
   for (const loc of locations) {
     const content = await readTextSafe(loc);
@@ -763,16 +975,16 @@ async function backupEnv(skillName, agentSkillDir) {
   return null;
 }
 async function restoreEnv(skillName, envData, skillDir) {
-  const exampleContent = await readTextSafe(join5(skillDir, ".env.example"));
+  const exampleContent = await readTextSafe(join6(skillDir, ".env.example"));
   let finalContent;
   if (exampleContent) {
     finalContent = mergeEnv(envData, exampleContent);
   } else {
     finalContent = serializeEnv(envData);
   }
-  const configEnvPath = join5(getSkillConfigPath(skillName), ".env");
+  const configEnvPath = join6(getSkillConfigPath(skillName), ".env");
   await writeText(configEnvPath, finalContent);
-  const skillEnvPath = join5(skillDir, ".env");
+  const skillEnvPath = join6(skillDir, ".env");
   await writeText(skillEnvPath, finalContent);
   debug(`Restored .env to ${configEnvPath} and ${skillEnvPath}`);
 }
@@ -796,7 +1008,7 @@ function mergeEnv(existing, exampleContent) {
 }
 async function getEnvStatus(skillName, requiredKeys) {
   if (requiredKeys.length === 0) return "configured";
-  const configEnvPath = join5(getSkillConfigPath(skillName), ".env");
+  const configEnvPath = join6(getSkillConfigPath(skillName), ".env");
   const content = await readTextSafe(configEnvPath);
   if (!content) return "missing";
   const data = parseEnvFile(content);
@@ -808,18 +1020,18 @@ async function getEnvStatus(skillName, requiredKeys) {
   return "missing";
 }
 async function setEnvValue(skillName, key, value, skillDir) {
-  const configEnvPath = join5(getSkillConfigPath(skillName), ".env");
+  const configEnvPath = join6(getSkillConfigPath(skillName), ".env");
   const content = await readTextSafe(configEnvPath);
   const data = content ? parseEnvFile(content) : {};
   data[key] = value;
   const newContent = serializeEnv(data);
   await writeText(configEnvPath, newContent);
   if (skillDir) {
-    await writeText(join5(skillDir, ".env"), newContent);
+    await writeText(join6(skillDir, ".env"), newContent);
   }
 }
 function getEnvEditPath(skillName) {
-  return join5(getSkillConfigPath(skillName), ".env");
+  return join6(getSkillConfigPath(skillName), ".env");
 }
 
 // src/core/registry.ts
@@ -924,12 +1136,22 @@ async function getRegistryEntry(skillName) {
 
 // src/core/installer.ts
 var TOTAL_STEPS = 9;
+function sanitizeName(name) {
+  let sanitized = name.replace(/\.\./g, "").replace(/[^a-zA-Z0-9_.-]/g, "");
+  sanitized = sanitized.replace(/^\.+/, "");
+  return sanitized;
+}
+function isPathSafe(targetPath, baseDir) {
+  const rel = relative(resolve3(baseDir), resolve3(targetPath));
+  if (!rel || rel === ".") return false;
+  return !rel.startsWith("..") && !resolve3(rel).includes("..");
+}
 async function installSkill(options) {
   const { source, cwd, copy = false, force = false, global: isGlobal = false } = options;
   step(1, TOTAL_STEPS, "Fetching skill source...");
   let sourceDir;
   if (source.type === "git") {
-    sourceDir = await cloneRepo(source.url, source.branch);
+    sourceDir = source.localPath ?? await cloneRepo(source.url, source.branch);
   } else if (source.type === "local") {
     sourceDir = source.path;
     if (!existsSync6(sourceDir)) {
@@ -948,7 +1170,10 @@ async function installSkill(options) {
   if (!parsed) {
     throw new SkillParseError("Failed to read SKILL.md");
   }
-  const skillName = parsed.frontmatter.name;
+  const skillName = sanitizeName(parsed.frontmatter.name);
+  if (!skillName) {
+    throw new SkillParseError("Skill name is empty after sanitization");
+  }
   info(`Found skill: ${skillName}${parsed.frontmatter.version ? ` v${parsed.frontmatter.version}` : ""}`);
   step(4, TOTAL_STEPS, "Detecting agent platform...");
   const agent = options.agent ?? detectPlatform(cwd);
@@ -963,6 +1188,9 @@ async function installSkill(options) {
   }
   step(6, TOTAL_STEPS, "Installing to canonical path...");
   const canonicalPath = getSkillCanonicalPath(skillName);
+  if (!isPathSafe(canonicalPath, SKILLS_DIR)) {
+    throw new SkillParseError(`Unsafe canonical path: ${canonicalPath}`);
+  }
   if (existsSync6(canonicalPath) && !force) {
     info("Replacing existing installation");
   }
@@ -974,18 +1202,25 @@ async function installSkill(options) {
     await restoreEnv(skillName, envBackup, canonicalPath);
     success(".env restored successfully");
   } else {
-    const examplePath = join6(canonicalPath, ".env.example");
+    const examplePath = join7(canonicalPath, ".env.example");
     if (existsSync6(examplePath)) {
       warn("Found .env.example \u2014 run `skill-master env edit " + skillName + "` to configure");
     }
   }
   step(8, TOTAL_STEPS, `Linking to ${agent} skills directory...`);
   const agentPath = isGlobal ? getAgentGlobalSkillPath(agent, skillName) : getAgentSkillPath(cwd, agent, skillName);
-  const linkType = await symlinkOrCopy(canonicalPath, agentPath, copy);
-  success(`${linkType === "symlink" ? "Symlinked" : "Copied"} to ${agentPath}`);
+  let installMode;
+  if (isGlobal && isUniversalAgent(agent) && canonicalPath === agentPath) {
+    installMode = "copy";
+    success(`Canonical path is agent path (universal agent): ${agentPath}`);
+  } else {
+    const linkType = await symlinkOrCopy(canonicalPath, agentPath, copy);
+    installMode = linkType;
+    success(`${linkType === "symlink" ? "Symlinked" : "Copied"} to ${agentPath}`);
+  }
   step(9, TOTAL_STEPS, "Updating registry...");
   const capabilities = parsed.frontmatter.capabilities ?? inferCapabilities(parsed.frontmatter["allowed-tools"] ?? []);
-  const envExampleContent = await readTextSafe(join6(canonicalPath, ".env.example"));
+  const envExampleContent = await readTextSafe(join7(canonicalPath, ".env.example"));
   const envKeys = envExampleContent ? extractEnvKeys(envExampleContent) : [];
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const agentInstall = {
@@ -1006,11 +1241,81 @@ async function installSkill(options) {
   await updateRegistry(skillName, entry);
   blank();
   success(`Skill "${skillName}" installed successfully!`);
+  return {
+    skillName,
+    version: parsed.frontmatter.version,
+    canonicalPath,
+    agentPath,
+    installMode
+  };
+}
+
+// src/core/local-lock.ts
+import { join as join8 } from "path";
+import { readdir as readdir3, readFile as readFile3 } from "fs/promises";
+import { createHash } from "crypto";
+var LOCK_FILENAME = "skills-lock.json";
+var HASH_EXCLUDES = /* @__PURE__ */ new Set([".env", ".git", "node_modules"]);
+function getLocalLockPath(cwd) {
+  return join8(cwd, LOCK_FILENAME);
+}
+function createEmptyLock() {
+  return { version: 1, skills: {} };
+}
+async function readLocalLock(cwd) {
+  const lockPath = getLocalLockPath(cwd);
+  const data = await readJsonSafe(lockPath);
+  if (!data || typeof data !== "object" || data.version !== 1 || data.skills === null || Array.isArray(data.skills) || typeof data.skills !== "object") {
+    return createEmptyLock();
+  }
+  return data;
+}
+async function writeLocalLock(lock, cwd) {
+  const lockPath = getLocalLockPath(cwd);
+  const sorted = {};
+  for (const key of Object.keys(lock.skills).sort()) {
+    sorted[key] = lock.skills[key];
+  }
+  await atomicWriteJson(lockPath, { version: lock.version, skills: sorted });
+}
+async function computeSkillFolderHash(dirPath) {
+  const hash = createHash("sha256");
+  await hashDir(dirPath, "", hash);
+  return hash.digest("hex");
+}
+async function hashDir(basePath, relativePath, hash) {
+  const fullPath = relativePath ? join8(basePath, relativePath) : basePath;
+  const entries = await readdir3(fullPath, { withFileTypes: true });
+  const sorted = entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of sorted) {
+    if (HASH_EXCLUDES.has(entry.name)) continue;
+    const entryRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      await hashDir(basePath, entryRelative, hash);
+    } else if (entry.isFile()) {
+      hash.update(entryRelative);
+      hash.update("\0");
+      const content = await readFile3(join8(basePath, entryRelative));
+      hash.update(content);
+      hash.update("\0");
+    }
+  }
+}
+async function addSkillToLocalLock(skillName, entry, cwd) {
+  const lock = await readLocalLock(cwd);
+  lock.skills[skillName] = entry;
+  await writeLocalLock(lock, cwd);
+}
+async function removeSkillFromLocalLock(skillName, cwd) {
+  const lock = await readLocalLock(cwd);
+  if (!(skillName in lock.skills)) return;
+  delete lock.skills[skillName];
+  await writeLocalLock(lock, cwd);
 }
 
 // src/commands/add.ts
 import { existsSync as existsSync7 } from "fs";
-import { basename as basename2, join as join7 } from "path";
+import { basename as basename2, join as join9, relative as relative2 } from "path";
 function parseAddFlags(args) {
   const flags = {
     global: false,
@@ -1154,7 +1459,7 @@ async function add(args) {
     step(1, 9, "Fetching skill source...");
     sourceDir = await cloneRepo(parsed.url, parsed.ref);
     if (parsed.subpath) {
-      const sub = join7(sourceDir, parsed.subpath);
+      const sub = join9(sourceDir, parsed.subpath);
       if (existsSync7(sub)) {
         sourceDir = sub;
       }
@@ -1165,14 +1470,14 @@ async function add(args) {
       throw new SkillNotFoundError(sourceDir);
     }
   }
-  const allSkillDirs = await findAllSkillDirectories(sourceDir, flags.fullDepth);
+  const allSkillDirs = await findAllSkillDirectoriesWithPlugins(sourceDir, flags.fullDepth);
   if (allSkillDirs.length === 0) {
     throw new SkillNotFoundError(`No SKILL.md found in ${sourceDir}`);
   }
   if (flags.list) {
     blank();
     tableHeader("Skill", "Version", "Description");
-    for (const dir of allSkillDirs) {
+    for (const { path: dir } of allSkillDirs) {
       const sk = await readSkillMd(dir);
       if (sk) {
         tableRow(
@@ -1189,18 +1494,18 @@ async function add(args) {
   if (flags.skill.length > 0 && !flags.skill.includes("*")) {
     const requested = new Set(flags.skill.map((s) => s.toLowerCase()));
     const filtered = [];
-    for (const dir of allSkillDirs) {
-      const sk = await readSkillMd(dir);
+    for (const item of allSkillDirs) {
+      const sk = await readSkillMd(item.path);
       if (!sk) continue;
       const name = sk.frontmatter.name.toLowerCase();
-      const dirName = basename2(dir).toLowerCase();
+      const dirName = basename2(item.path).toLowerCase();
       if (requested.has(name) || requested.has(dirName)) {
-        filtered.push(dir);
+        filtered.push(item);
       }
     }
     if (filtered.length === 0) {
       const available = [];
-      for (const dir of allSkillDirs) {
+      for (const { path: dir } of allSkillDirs) {
         const sk = await readSkillMd(dir);
         if (sk) available.push(sk.frontmatter.name);
       }
@@ -1214,10 +1519,11 @@ async function add(args) {
   }
   const agents = flags.agent.length > 0 ? flags.agent : [void 0];
   try {
-    for (const dir of targetDirs) {
+    for (const { path: dir, pluginName } of targetDirs) {
       for (const agent of agents) {
-        await installSkill({
-          source: { type: "local", path: dir },
+        const installSource = parsed.type === "git" ? { type: "git", url: parsed.url, branch: parsed.ref, localPath: dir } : { type: "local", path: dir };
+        const result = await installSkill({
+          source: installSource,
           agent,
           cwd,
           global: flags.global,
@@ -1225,6 +1531,16 @@ async function add(args) {
           force: flags.force,
           yes: flags.yes
         });
+        if (!flags.global) {
+          const skillDir = relative2(sourceDir, dir);
+          await addSkillToLocalLock(result.skillName, {
+            source,
+            sourceType: parsed.type === "git" ? "github" : "local",
+            computedHash: await computeSkillFolderHash(result.canonicalPath),
+            ...skillDir && skillDir !== "." ? { skillDir } : {},
+            ...pluginName ? { pluginName } : {}
+          }, cwd);
+        }
       }
     }
   } catch (err) {
@@ -1413,6 +1729,7 @@ async function remove(args) {
             await removePath(getSkillConfigPath(skillName));
             success("Purged config directory");
           }
+          await removeSkillFromLocalLock(skillName, process.cwd());
         }
       } else {
         for (const agentRecord of entry.agents) {
@@ -1426,6 +1743,7 @@ async function remove(args) {
           success("Purged config directory");
         }
         await removeFromRegistry(skillName);
+        await removeSkillFromLocalLock(skillName, process.cwd());
       }
       success(`Skill "${skillName}" removed successfully!`);
     }
@@ -1547,6 +1865,9 @@ function parseListFlags(args) {
   }
   return flags;
 }
+function toTitleCase(str) {
+  return str.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
 async function list(args = []) {
   const flags = parseListFlags(args);
   const skills = await listRegistry();
@@ -1560,14 +1881,55 @@ async function list(args = []) {
     info("No skills installed");
     return;
   }
-  blank();
-  tableHeader("Skill", "Version", "Platform(s)", "Installed");
+  const cwd = process.cwd();
+  const localLock = await readLocalLock(cwd);
+  const groupedSkills = {};
+  const ungroupedSkills = [];
   for (const [name, entry] of entries) {
-    const date = new Date(entry.installed_at).toLocaleDateString();
-    const platforms = entry.agents.map((a) => a.agent).join(", ");
-    tableRow(name, entry.version ?? "-", platforms, date);
+    const lockEntry = localLock.skills[name];
+    if (lockEntry?.pluginName) {
+      const group = lockEntry.pluginName;
+      if (!groupedSkills[group]) {
+        groupedSkills[group] = [];
+      }
+      groupedSkills[group].push([name, entry]);
+    } else {
+      ungroupedSkills.push([name, entry]);
+    }
   }
+  const hasGroups = Object.keys(groupedSkills).length > 0;
   blank();
+  if (hasGroups) {
+    const sortedGroups = Object.keys(groupedSkills).sort();
+    for (const group of sortedGroups) {
+      section(toTitleCase(group));
+      tableHeader("Skill", "Version", "Platform(s)", "Installed");
+      for (const [name, entry] of groupedSkills[group]) {
+        const date = new Date(entry.installed_at).toLocaleDateString();
+        const platforms = entry.agents.map((a) => a.agent).join(", ");
+        tableRow(name, entry.version ?? "-", platforms, date);
+      }
+      blank();
+    }
+    if (ungroupedSkills.length > 0) {
+      section("General");
+      tableHeader("Skill", "Version", "Platform(s)", "Installed");
+      for (const [name, entry] of ungroupedSkills) {
+        const date = new Date(entry.installed_at).toLocaleDateString();
+        const platforms = entry.agents.map((a) => a.agent).join(", ");
+        tableRow(name, entry.version ?? "-", platforms, date);
+      }
+      blank();
+    }
+  } else {
+    tableHeader("Skill", "Version", "Platform(s)", "Installed");
+    for (const [name, entry] of entries) {
+      const date = new Date(entry.installed_at).toLocaleDateString();
+      const platforms = entry.agents.map((a) => a.agent).join(", ");
+      tableRow(name, entry.version ?? "-", platforms, date);
+    }
+    blank();
+  }
 }
 
 // src/commands/info.ts
@@ -1703,13 +2065,14 @@ async function find(args) {
       process.exit(1);
     }
     const data = await response.json();
-    if (!Array.isArray(data) || data.length === 0) {
+    const skills = data.skills ?? [];
+    if (skills.length === 0) {
       info("No skills found matching your query.");
       return;
     }
     blank();
     tableHeader("Name", "Source", "Installs");
-    for (const item of data) {
+    for (const item of skills) {
       tableRow(
         item.name ?? "\u2014",
         item.source ?? "\u2014",
@@ -1729,7 +2092,7 @@ async function find(args) {
 
 // src/commands/init.ts
 import { existsSync as existsSync9 } from "fs";
-import { join as join8, basename as basename3 } from "path";
+import { join as join10, basename as basename3 } from "path";
 var SKILL_MD_TEMPLATE = `---
 name: {{NAME}}
 version: 0.1.0
@@ -1755,13 +2118,13 @@ async function init(args) {
   let targetDir;
   let skillName;
   if (nameArg) {
-    targetDir = join8(cwd, nameArg);
+    targetDir = join10(cwd, nameArg);
     skillName = nameArg;
   } else {
     targetDir = cwd;
     skillName = basename3(cwd);
   }
-  const skillMdPath = join8(targetDir, "SKILL.md");
+  const skillMdPath = join10(targetDir, "SKILL.md");
   if (existsSync9(skillMdPath)) {
     error(`SKILL.md already exists at ${skillMdPath}`);
     process.exit(1);
@@ -1834,6 +2197,301 @@ async function getRemoteHead(source) {
   }
 }
 
+// src/commands/sync.ts
+import { relative as relative3 } from "path";
+function parseSyncFlags(args) {
+  const flags = {
+    agent: [],
+    yes: false,
+    force: false,
+    help: false
+  };
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    switch (arg) {
+      case "-h":
+      case "--help":
+        flags.help = true;
+        i++;
+        break;
+      case "-a":
+      case "--agent":
+        i++;
+        while (i < args.length && !args[i].startsWith("-")) {
+          flags.agent.push(args[i]);
+          i++;
+        }
+        break;
+      case "-y":
+      case "--yes":
+        flags.yes = true;
+        i++;
+        break;
+      case "-f":
+      case "--force":
+        flags.force = true;
+        i++;
+        break;
+      default:
+        if (arg.startsWith("-")) {
+          throw new Error(`Unknown option: ${arg}`);
+        }
+        i++;
+        break;
+    }
+  }
+  return { flags };
+}
+function printSyncHelp() {
+  console.log("Usage: skill-master sync [options]");
+  console.log("");
+  console.log("Discover and sync skills from node_modules.");
+  console.log("");
+  console.log("Options:");
+  console.log("  -h, --help            Show this help message");
+  console.log("  -a, --agent <agents>  Target agents (space-separated)");
+  console.log("  -y, --yes             Skip confirmations");
+  console.log("  -f, --force           Force reinstall even if unchanged");
+}
+async function sync(args) {
+  const { flags } = parseSyncFlags(args);
+  if (flags.help) {
+    printSyncHelp();
+    process.exit(0);
+  }
+  const cwd = process.cwd();
+  info("Scanning node_modules for skills...");
+  const skillDirs = await discoverNodeModulesSkills(cwd);
+  if (skillDirs.length === 0) {
+    info("No skills found in node_modules.");
+    return;
+  }
+  const lock = await readLocalLock(cwd);
+  const skills = [];
+  for (const dir of skillDirs) {
+    const parsed = await readSkillMd(dir);
+    if (!parsed) continue;
+    const name = sanitizeName(parsed.frontmatter.name);
+    const currentHash = await computeSkillFolderHash(dir);
+    const lockEntry = lock.skills[name];
+    let status;
+    if (!lockEntry) {
+      status = "new";
+    } else if (lockEntry.computedHash !== currentHash || flags.force) {
+      status = "updated";
+    } else {
+      status = "unchanged";
+    }
+    skills.push({ dir, name, version: parsed.frontmatter.version, status });
+  }
+  const actionable = skills.filter((s) => s.status !== "unchanged");
+  if (actionable.length === 0) {
+    success("All node_modules skills are up to date.");
+    return;
+  }
+  blank();
+  tableHeader("Skill", "Version", "Status");
+  for (const s of skills) {
+    tableRow(s.name, s.version ?? "-", s.status);
+  }
+  blank();
+  info(`${actionable.length} skill(s) to install/update.`);
+  if (!flags.yes) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve4) => {
+      rl.question("Proceed? [y/N] ", resolve4);
+    });
+    rl.close();
+    if (answer.toLowerCase() !== "y") {
+      info("Aborted.");
+      return;
+    }
+  }
+  const agents = flags.agent.length > 0 ? flags.agent : [void 0];
+  for (const s of actionable) {
+    for (const agent of agents) {
+      try {
+        const result = await installSkill({
+          source: { type: "local", path: s.dir },
+          agent,
+          cwd,
+          global: false,
+          copy: false,
+          force: flags.force,
+          yes: true
+        });
+        await addSkillToLocalLock(result.skillName, {
+          source: relative3(cwd, s.dir),
+          sourceType: "node_modules",
+          computedHash: await computeSkillFolderHash(result.canonicalPath)
+        }, cwd);
+      } catch (err) {
+        error(`Failed to install ${s.name}: ${err.message}`);
+      }
+    }
+  }
+  blank();
+  success(`Synced ${actionable.length} skill(s) from node_modules.`);
+}
+
+// src/commands/restore.ts
+import { existsSync as existsSync10 } from "fs";
+function parseRestoreFlags(args) {
+  const flags = { help: false };
+  for (const arg of args) {
+    if (arg === "-h" || arg === "--help") {
+      flags.help = true;
+    }
+  }
+  return { flags };
+}
+function printRestoreHelp() {
+  console.log("Usage: skill-master restore [options]");
+  console.log("");
+  console.log("Restore skills from skills-lock.json.");
+  console.log("");
+  console.log("Options:");
+  console.log("  -h, --help  Show this help message");
+}
+async function restore(args) {
+  const { flags } = parseRestoreFlags(args);
+  if (flags.help) {
+    printRestoreHelp();
+    process.exit(0);
+  }
+  const cwd = process.cwd();
+  const lock = await readLocalLock(cwd);
+  const entries = Object.entries(lock.skills);
+  if (entries.length === 0) {
+    info("No skills found in skills-lock.json. Nothing to restore.");
+    return;
+  }
+  info(`Restoring ${entries.length} skill(s) from skills-lock.json...`);
+  blank();
+  const github = [];
+  const nodeModules = [];
+  const local = [];
+  for (const [name, entry] of entries) {
+    switch (entry.sourceType) {
+      case "github":
+        github.push([name, entry]);
+        break;
+      case "node_modules":
+        nodeModules.push([name, entry]);
+        break;
+      case "local":
+        local.push([name, entry]);
+        break;
+    }
+  }
+  let installed = 0;
+  let failed = 0;
+  if (nodeModules.length > 0) {
+    info(`Syncing ${nodeModules.length} node_modules skill(s)...`);
+    const nmSkillDirs = await discoverNodeModulesSkills(cwd);
+    const nmMap = /* @__PURE__ */ new Map();
+    for (const dir of nmSkillDirs) {
+      const parsed = await readSkillMd(dir);
+      if (parsed) nmMap.set(sanitizeName(parsed.frontmatter.name), dir);
+    }
+    for (const [name] of nodeModules) {
+      const dir = nmMap.get(name);
+      if (!dir) {
+        warn(`Skill "${name}" not found in node_modules \u2014 run npm install first`);
+        failed++;
+        continue;
+      }
+      try {
+        const result = await installSkill({
+          source: { type: "local", path: dir },
+          cwd,
+          global: false,
+          yes: true
+        });
+        await addSkillToLocalLock(result.skillName, {
+          source: dir,
+          sourceType: "node_modules",
+          computedHash: await computeSkillFolderHash(result.canonicalPath)
+        }, cwd);
+        installed++;
+      } catch (err) {
+        error(`Failed to restore "${name}": ${err.message}`);
+        failed++;
+      }
+    }
+  }
+  for (const [name, entry] of github) {
+    try {
+      const parsed = parseSource(entry.source);
+      if (parsed.type !== "git" || !parsed.url) {
+        warn(`Invalid source for "${name}": ${entry.source}`);
+        failed++;
+        continue;
+      }
+      const sourceDir = await cloneRepo(parsed.url, parsed.ref);
+      let skillPath = sourceDir;
+      if (parsed.subpath) {
+        skillPath = `${skillPath}/${parsed.subpath}`;
+      }
+      if (entry.skillDir) {
+        skillPath = `${skillPath}/${entry.skillDir}`;
+      }
+      const result = await installSkill({
+        source: { type: "local", path: skillPath },
+        cwd,
+        global: false,
+        yes: true
+      });
+      await addSkillToLocalLock(result.skillName, {
+        source: entry.source,
+        sourceType: "github",
+        computedHash: await computeSkillFolderHash(result.canonicalPath),
+        ...entry.skillDir ? { skillDir: entry.skillDir } : {},
+        ...entry.pluginName ? { pluginName: entry.pluginName } : {}
+      }, cwd);
+      installed++;
+    } catch (err) {
+      error(`Failed to restore "${name}": ${err.message}`);
+      failed++;
+    }
+  }
+  for (const [name, entry] of local) {
+    if (!existsSync10(entry.source)) {
+      warn(`Local source not found for "${name}": ${entry.source}`);
+      failed++;
+      continue;
+    }
+    try {
+      const localPath = entry.skillDir ? `${entry.source}/${entry.skillDir}` : entry.source;
+      const result = await installSkill({
+        source: { type: "local", path: localPath },
+        cwd,
+        global: false,
+        yes: true
+      });
+      await addSkillToLocalLock(result.skillName, {
+        source: entry.source,
+        sourceType: "local",
+        computedHash: await computeSkillFolderHash(result.canonicalPath),
+        ...entry.skillDir ? { skillDir: entry.skillDir } : {},
+        ...entry.pluginName ? { pluginName: entry.pluginName } : {}
+      }, cwd);
+      installed++;
+    } catch (err) {
+      error(`Failed to restore "${name}": ${err.message}`);
+      failed++;
+    }
+  }
+  blank();
+  if (failed > 0) {
+    warn(`Restored ${installed} skill(s), ${failed} failed.`);
+  } else {
+    success(`Restored ${installed} skill(s) successfully.`);
+  }
+}
+
 // src/cli.ts
 var VERSION = "0.1.0";
 var HELP = `
@@ -1845,6 +2503,8 @@ Usage:
   skill-master list [options]             List installed skills (alias: ls)
   skill-master find [query]               Search for skills (aliases: search, f, s)
   skill-master update [skill]             Update skills (alias: upgrade)
+  skill-master sync [options]             Sync skills from node_modules
+  skill-master restore                    Restore skills from skills-lock.json (alias: install-lock)
   skill-master init [name]                Create a new skill template
   skill-master check                      Check for skill updates
   skill-master env <list|set|edit>        Manage environment variables
@@ -1862,12 +2522,19 @@ Add Options:
   --copy                Copy instead of symlink
   --force               Force reinstall
 
+Sync Options:
+  -a, --agent <agents>  Target agents (space-separated)
+  -y, --yes             Skip confirmations
+  -f, --force           Force reinstall even if unchanged
+
 Examples:
   skill-master add owner/repo
   skill-master add https://github.com/user/skill -a claude-code cursor -y
   skill-master add ./local-skill --agent=cursor --copy
   skill-master remove my-skill --purge
   skill-master find "code review"
+  skill-master sync -y
+  skill-master restore
   skill-master init my-new-skill
   skill-master check
 `;
@@ -1923,6 +2590,15 @@ async function main() {
       case "check":
         await check(commandArgs);
         break;
+      // sync — discover and install skills from node_modules
+      case "sync":
+        await sync(commandArgs);
+        break;
+      // restore with alias: install-lock
+      case "restore":
+      case "install-lock":
+        await restore(commandArgs);
+        break;
       // env, info, doctor — skill-master extensions
       case "env":
         await env(commandArgs);