skilllib 1.12.2 → 1.14.0

package/dist/{chunk-YQFLFWAY.js → chunk-XMXC2XM2.js}

@@ -139,6 +139,77 @@ import { join as join6, resolve as resolve4 } from "path";
 // src/harnesses.ts
 import { existsSync } from "fs";
 import { delimiter, join as join2 } from "path";
+var EXTRAS = [
+  { id: "github-copilot", name: "GitHub Copilot", short: "Cp", icon: "\u25D0", color: "#E8E8E8", project: [".agents/skills", ".claude/skills", ".github/skills"], global: [".agents/skills", ".claude/skills", ".copilot/skills"], detect: [".copilot"], bin: "copilot" },
+  { id: "gemini-cli", name: "Gemini CLI", short: "Ge", icon: "\u2726", color: "#8AB4F8", project: [".agents/skills", ".gemini/skills"], global: [".agents/skills", ".gemini/skills"], detect: [], bin: "gemini" },
+  { id: "opencode", name: "OpenCode", short: "Oc", icon: "\u2318", color: "#A78BFA", project: [".agents/skills", ".claude/skills", ".opencode/skills"], global: [".agents/skills", ".claude/skills", ".config/opencode/skills"], detect: [".config/opencode", ".opencode"], bin: "opencode" },
+  { id: "antigravity", name: "Antigravity", short: "Ag", icon: "\u25B2", color: "#34A853", project: [".agents/skills", ".agent/skills"], global: [".gemini/config/skills", ".gemini/antigravity/skills"], detect: [".gemini/antigravity"], bin: "agy", app: "Antigravity" },
+  { id: "antigravity-ide", name: "Antigravity IDE", short: "Ai", icon: "\u25B2", color: "#34A853", project: [".agents/skills", ".agent/skills"], global: [".gemini/antigravity-ide/skills"], detect: [".gemini/antigravity-ide"], app: "Antigravity IDE" },
+  { id: "antigravity-cli", name: "Antigravity CLI", short: "Ac", icon: "\u25B2", color: "#34A853", project: [".agents/skills", ".agent/skills"], global: [".gemini/antigravity-cli/skills"], detect: [".gemini/antigravity-cli"], bin: "agy" },
+  { id: "windsurf", name: "Windsurf", short: "Ws", icon: "\u224B", color: "#0EA5E9", project: [".windsurf/skills"], global: [".codeium/windsurf/skills"], detect: [".codeium/windsurf"], bin: "windsurf", app: "Windsurf" },
+  { id: "devin", name: "Devin", short: "Dv", icon: "\u0394", color: "#7C6AF7", project: [".agents/skills", ".devin/skills", ".windsurf/skills"], global: [".agents/skills", ".config/devin/skills"], detect: [".config/devin"], bin: "devin" },
+  { id: "cline", name: "Cline", short: "Cl", icon: "\u25A3", color: "#22C55E", project: [".agents/skills"], global: [".agents/skills"], detect: [".cline"], bin: "cline" },
+  { id: "amp", name: "Amp", short: "Am", icon: "\u26A1", color: "#F5C16C", project: [".agents/skills"], global: [".config/agents/skills"], detect: [".config/amp"], bin: "amp" },
+  { id: "droid", name: "Factory Droid", short: "Dr", icon: "\xB7", color: "#8A93A6", project: [".agents/skills"], global: [".agents/skills", ".factory/skills"], detect: [".factory"], bin: "droid" },
+  { id: "openclaw", name: "OpenClaw", short: "Ow", icon: "\xB7", color: "#8A93A6", project: ["skills"], global: [".openclaw/skills"], detect: [".openclaw", ".clawdbot", ".moltbot"], bin: "openclaw" },
+  { id: "continue", name: "Continue", short: "Cn", icon: "\xB7", color: "#8A93A6", project: [".continue/skills"], global: [".continue/skills"], detect: [".continue"] },
+  { id: "augment", name: "Augment", short: "Au", icon: "\xB7", color: "#8A93A6", project: [".augment/skills"], global: [".augment/skills"], detect: [".augment"] },
+  { id: "junie", name: "Junie", short: "Ju", icon: "\xB7", color: "#8A93A6", project: [".junie/skills"], global: [".junie/skills"], detect: [".junie"], bin: "junie" },
+  { id: "roo", name: "Roo Code", short: "Ro", icon: "\xB7", color: "#8A93A6", project: [".roo/skills"], global: [".roo/skills"], detect: [".roo"] },
+  { id: "goose", name: "Goose", short: "Gs", icon: "\xB7", color: "#8A93A6", project: [".goose/skills"], global: [".config/goose/skills"], detect: [".config/goose"], bin: "goose" },
+  { id: "openhands", name: "OpenHands", short: "Oh", icon: "\xB7", color: "#8A93A6", project: [".openhands/skills"], global: [".openhands/skills"], detect: [".openhands"] },
+  { id: "crush", name: "Crush", short: "Cr", icon: "\xB7", color: "#8A93A6", project: [".crush/skills"], global: [".config/crush/skills"], detect: [".config/crush"], bin: "crush" },
+  { id: "pi", name: "Pi", short: "Pi", icon: "\xB7", color: "#8A93A6", project: [".agents/skills"], global: [".agents/skills", ".pi/agent/skills"], detect: [".pi/agent"], bin: "pi" },
+  { id: "kimi-code-cli", name: "Kimi Code CLI", short: "Ki", icon: "\xB7", color: "#8A93A6", project: [".agents/skills"], global: [".agents/skills"], detect: [".kimi"], bin: "kimi" },
+  { id: "kilo", name: "Kilo Code", short: "Kl", icon: "\xB7", color: "#8A93A6", project: [".agents/skills"], global: [".kilo/skills", ".kilocode/skills"], detect: [".kilo", ".kilocode"] },
+  { id: "kiro-cli", name: "Kiro CLI", short: "Kr", icon: "\xB7", color: "#8A93A6", project: [".kiro/skills"], global: [".kiro/skills"], detect: [".kiro"], bin: "kiro" },
+  { id: "qwen-code", name: "Qwen Code", short: "Qw", icon: "\xB7", color: "#8A93A6", project: [".qwen/skills"], global: [".qwen/skills"], detect: [".qwen"], bin: "qwen" },
+  { id: "warp", name: "Warp", short: "Wp", icon: "\xB7", color: "#8A93A6", project: [".agents/skills"], global: [".agents/skills"], detect: [".warp"], app: "Warp" },
+  { id: "replit", name: "Replit", short: "Rp", icon: "\xB7", color: "#8A93A6", project: [".agents/skills"], global: [".config/agents/skills"], detect: [] },
+  { id: "trae", name: "Trae", short: "Tr", icon: "\xB7", color: "#8A93A6", project: [".trae/skills"], global: [".trae/skills"], detect: [".trae"], app: "Trae" },
+  { id: "mux", name: "Mux", short: "Mx", icon: "\xB7", color: "#8A93A6", project: [".mux/skills"], global: [".mux/skills"], detect: [".mux"] },
+  { id: "mistral-vibe", name: "Mistral Vibe", short: "Mv", icon: "\xB7", color: "#8A93A6", project: [".vibe/skills"], global: [".vibe/skills"], detect: [".vibe"], bin: "vibe" },
+  { id: "qoder", name: "Qoder", short: "Qd", icon: "\xB7", color: "#8A93A6", project: [".qoder/skills"], global: [".qoder/skills"], detect: [".qoder"] },
+  { id: "zencoder", name: "Zencoder", short: "Ze", icon: "\xB7", color: "#8A93A6", project: [".zencoder/skills"], global: [".zencoder/skills"], detect: [".zencoder"] },
+  { id: "neovate", name: "Neovate", short: "Nv", icon: "\xB7", color: "#8A93A6", project: [".neovate/skills"], global: [".neovate/skills"], detect: [".neovate"] },
+  { id: "adal", name: "AdaL", short: "Ad", icon: "\xB7", color: "#8A93A6", project: [".adal/skills"], global: [".adal/skills"], detect: [".adal"] },
+  { id: "bob", name: "IBM Bob", short: "Bb", icon: "\xB7", color: "#8A93A6", project: [".bob/skills"], global: [".bob/skills"], detect: [".bob"] },
+  { id: "aider-desk", name: "AiderDesk", short: "Adk", icon: "\xB7", color: "#8A93A6", project: [".aider-desk/skills"], global: [".aider-desk/skills"], detect: [".aider-desk"] },
+  { id: "codebuddy", name: "CodeBuddy", short: "Cb", icon: "\xB7", color: "#8A93A6", project: [".codebuddy/skills"], global: [".codebuddy/skills"], detect: [".codebuddy"] },
+  { id: "command-code", name: "Command Code", short: "Cm", icon: "\xB7", color: "#8A93A6", project: [".commandcode/skills"], global: [".commandcode/skills"], detect: [".commandcode"] },
+  { id: "cortex", name: "Cortex Code", short: "Ct", icon: "\xB7", color: "#8A93A6", project: [".cortex/skills"], global: [".snowflake/cortex/skills"], detect: [".snowflake/cortex"] },
+  { id: "hermes-agent", name: "Hermes Agent", short: "He", icon: "\xB7", color: "#8A93A6", project: [".hermes/skills"], global: [".hermes/skills"], detect: [".hermes"] },
+  { id: "iflow-cli", name: "iFlow CLI", short: "If", icon: "\xB7", color: "#8A93A6", project: [".iflow/skills"], global: [".iflow/skills"], detect: [".iflow"] },
+  { id: "kode", name: "Kode", short: "Kd", icon: "\xB7", color: "#8A93A6", project: [".kode/skills"], global: [".kode/skills"], detect: [".kode"] },
+  { id: "mcpjam", name: "MCPJam", short: "Mj", icon: "\xB7", color: "#8A93A6", project: [".mcpjam/skills"], global: [".mcpjam/skills"], detect: [".mcpjam"] },
+  { id: "minimax-code", name: "MiniMax Code", short: "Mm", icon: "\xB7", color: "#8A93A6", project: [".minimax/skills"], global: [".minimax/skills"], detect: [".minimax"] },
+  { id: "pochi", name: "Pochi", short: "Po", icon: "\xB7", color: "#8A93A6", project: [".pochi/skills"], global: [".pochi/skills"], detect: [".pochi"] },
+  { id: "rovodev", name: "Rovo Dev", short: "Rv", icon: "\xB7", color: "#8A93A6", project: [".rovodev/skills"], global: [".rovodev/skills"], detect: [".rovodev"] },
+  { id: "tabnine-cli", name: "Tabnine CLI", short: "Tn", icon: "\xB7", color: "#8A93A6", project: [".tabnine/agent/skills"], global: [".tabnine/agent/skills"], detect: [".tabnine"] },
+  { id: "zcode", name: "ZCode", short: "Zc", icon: "\xB7", color: "#8A93A6", project: [".zcode/skills"], global: [".zcode/skills"], detect: [".zcode"], app: "ZCode" },
+  { id: "autohand-code", name: "Autohand Code", short: "Ah", icon: "\xB7", color: "#8A93A6", project: [".autohand/skills"], global: [".autohand/skills"], detect: [".autohand"] },
+  { id: "codearts-agent", name: "CodeArts Agent", short: "Ca", icon: "\xB7", color: "#8A93A6", project: [".codeartsdoer/skills"], global: [".codeartsdoer/skills"], detect: [".codeartsdoer"] },
+  { id: "codemaker", name: "CodeMaker", short: "Mk", icon: "\xB7", color: "#8A93A6", project: [".codemaker/skills"], global: [".codemaker/skills"], detect: [".codemaker"] },
+  { id: "codestudio", name: "CodeStudio", short: "Cs", icon: "\xB7", color: "#8A93A6", project: [".codestudio/skills"], global: [".codestudio/skills"], detect: [".codestudio"] },
+  { id: "deepagents", name: "Deep Agents", short: "Da", icon: "\xB7", color: "#8A93A6", project: [".agents/skills"], global: [".deepagents/agent/skills"], detect: [".deepagents"] },
+  { id: "dexto", name: "Dexto", short: "Dx", icon: "\xB7", color: "#8A93A6", project: [".agents/skills"], global: [".agents/skills"], detect: [".dexto"] },
+  { id: "firebender", name: "Firebender", short: "Fb", icon: "\xB7", color: "#8A93A6", project: [".agents/skills"], global: [".firebender/skills"], detect: [".firebender"] },
+  { id: "forgecode", name: "ForgeCode", short: "Fc", icon: "\xB7", color: "#8A93A6", project: [".forge/skills"], global: [".forge/skills"], detect: [".forge"] },
+  { id: "fx", name: "fx", short: "Fx", icon: "\xB7", color: "#8A93A6", project: [".agents/skills"], global: [".agents/skills"], detect: [".fx"] },
+  { id: "inference-sh", name: "inference.sh", short: "In", icon: "\xB7", color: "#8A93A6", project: [".inferencesh/skills"], global: [".inferencesh/skills"], detect: [".inferencesh"] },
+  { id: "jazz", name: "Jazz", short: "Jz", icon: "\xB7", color: "#8A93A6", project: [".jazz/skills"], global: [".jazz/skills"], detect: [".jazz"] },
+  { id: "kimchi", name: "Kimchi", short: "Kc", icon: "\xB7", color: "#8A93A6", project: [".kimchi/skills"], global: [".config/kimchi/harness/skills"], detect: [".config/kimchi"] },
+  { id: "lingma", name: "Lingma", short: "Lg", icon: "\xB7", color: "#8A93A6", project: [".lingma/skills"], global: [".lingma/skills"], detect: [".lingma"] },
+  { id: "loaf", name: "Loaf", short: "Lf", icon: "\xB7", color: "#8A93A6", project: [".agents/skills"], global: [".agents/skills"], detect: [".loaf"] },
+  { id: "moxby", name: "Moxby", short: "Mb", icon: "\xB7", color: "#8A93A6", project: [".moxby/skills"], global: [".moxby/skills"], detect: [".moxby"] },
+  { id: "ona", name: "Ona", short: "On", icon: "\xB7", color: "#8A93A6", project: [".ona/skills"], global: [".ona/skills"], detect: [".ona"] },
+  { id: "posit-assistant", name: "Posit Assistant", short: "Pa", icon: "\xB7", color: "#8A93A6", project: [".posit/assistant/skills"], global: [".posit/assistant/skills"], detect: [".posit"] },
+  { id: "reasonix", name: "Reasonix", short: "Rx", icon: "\xB7", color: "#8A93A6", project: [".reasonix/skills"], global: [".reasonix/skills"], detect: [".reasonix"] },
+  { id: "sarvam-code", name: "Sarvam Code", short: "Sv", icon: "\xB7", color: "#8A93A6", project: [".agents/skills"], global: [".agents/skills"], detect: [".sarvam"] },
+  { id: "terramind", name: "Terramind", short: "Tm", icon: "\xB7", color: "#8A93A6", project: [".terramind/skills"], global: [".terramind/skills"], detect: [".terramind"] },
+  { id: "tinycloud", name: "TinyCloud", short: "Ty", icon: "\xB7", color: "#8A93A6", project: [".tinycloud/skills"], global: [".tinycloud/skills"], detect: [".tinycloud"] }
+];
+var FEATURED_HARNESSES = ["claude-code", "cursor", "codex", "zed", "grok"];
 var home = userHome;
 var HARNESSES = [
   {
@@ -196,7 +267,19 @@ var HARNESSES = [
     // The first folder is where global links for Grok go, so those links stay out of ~/.grok/skills.
     globalDirs: () => [join2(home(), ".agents", "skills"), join2(grokDir(), "skills"), join2(home(), ".claude", "skills"), join2(home(), ".cursor", "skills")],
     installed: () => existsSync(grokDir()) || onPath("grok") || hasApp("Grok")
-  }
+  },
+  ...EXTRAS.map(
+    (e) => ({
+      id: e.id,
+      name: e.name,
+      short: e.short,
+      icon: e.icon,
+      color: e.color,
+      projectDirs: [...e.project],
+      globalDirs: () => e.global.map((g) => join2(home(), g)),
+      installed: () => e.detect.some((d) => existsSync(join2(home(), d))) || ("bin" in e && e.bin ? onPath(e.bin) : false) || ("app" in e && e.app ? hasApp(e.app) : false)
+    })
+  )
 ];
 function onPath(bin) {
   const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
@@ -215,20 +298,59 @@ function preference(dir) {
   const i = PREFERRED_DIRS.indexOf(dir);
   return i === -1 ? PREFERRED_DIRS.length : i;
 }
-function cost(dirs) {
-  return dirs.length * 100 + dirs.reduce((sum, d) => sum + preference(d), 0);
+function projectDirsInUse(enabled) {
+  return ALL_PROJECT_DIRS.filter((d) => d !== "skills" || enabled.includes("openclaw"));
+}
+function cover(enabled, universe, reads, pref) {
+  const left = new Set(enabled);
+  const chosen = [];
+  while (left.size) {
+    let best = null;
+    let bestCount = 0;
+    let bestPref = Infinity;
+    for (const dir of universe) {
+      if (chosen.includes(dir)) continue;
+      const count = [...left].filter((id) => reads(id).includes(dir)).length;
+      if (count === 0) continue;
+      const p = pref(dir);
+      if (count > bestCount || count === bestCount && (p < bestPref || p === bestPref && (best === null || dir < best))) {
+        best = dir;
+        bestCount = count;
+        bestPref = p;
+      }
+    }
+    if (!best) break;
+    chosen.push(best);
+    for (const id of [...left]) if (reads(id).includes(best)) left.delete(id);
+  }
+  return chosen;
 }
 function installDirs(enabled, keep) {
   if (enabled.length === 0) return [keep ?? PROJECT_SKILLS_DIR];
-  let best = [];
-  for (let mask = 1; mask < 1 << ALL_PROJECT_DIRS.length; mask++) {
-    const dirs = ALL_PROJECT_DIRS.filter((_, i) => mask & 1 << i).sort((a, b) => preference(a) - preference(b));
-    if (keep && !dirs.includes(keep)) continue;
-    if (!enabled.every((id) => harness(id).projectDirs.some((d) => dirs.includes(d)))) continue;
-    if (best.length === 0 || cost(dirs) < cost(best)) best = dirs;
-  }
-  const primary = keep ?? best[0];
-  return [primary, ...best.filter((d) => d !== primary)];
+  const reads = (id) => harness(id).projectDirs;
+  const rest = keep ? enabled.filter((id) => !reads(id).includes(keep)) : enabled;
+  const chosen = [.../* @__PURE__ */ new Set([...keep ? [keep] : [], ...cover(rest, ALL_PROJECT_DIRS, reads, preference)])];
+  const primary = keep ?? [...chosen].sort((a, b) => preference(a) - preference(b) || a.localeCompare(b))[0];
+  return [primary, ...chosen.filter((d) => d !== primary).sort((a, b) => preference(a) - preference(b) || a.localeCompare(b))];
+}
+function globalPreference(dir) {
+  const agents = realPath(join2(userHome(), ".agents", "skills"));
+  const claude2 = realPath(join2(claudeDir(), "skills"));
+  const real = realPath(dir);
+  if (real === agents) return 0;
+  if (real === claude2) return 1;
+  return 2;
+}
+function globalInstallDirs(enabled) {
+  if (enabled.length === 0) return [];
+  const reads = (id) => harness(id).globalDirs();
+  const chosen = cover(enabled, [...new Set(enabled.flatMap(reads))], reads, globalPreference);
+  const claude2 = join2(claudeDir(), "skills");
+  const agents = join2(userHome(), ".agents", "skills");
+  const primary = chosen.find((d) => realPath(d) === realPath(claude2)) ?? chosen.find((d) => realPath(d) === realPath(agents)) ?? chosen[0];
+  if (!primary) return [];
+  const dirs = [primary, ...chosen.filter((d) => realPath(d) !== realPath(primary))];
+  return dirs.filter((d, i) => dirs.findIndex((o) => realPath(o) === realPath(d)) === i);
 }
 
 // src/project.ts
@@ -312,15 +434,25 @@ function indexFile(name) {
   return join4(storeDir(name), "versions.json");
 }
 function versionHistory(name) {
-  return readState(indexFile(name)) ?? [];
+  const hit = historyCache.get(name);
+  if (hit) return hit;
+  const history = readState(indexFile(name)) ?? [];
+  historyCache.set(name, history);
+  return history;
 }
 function versionDir(name, version) {
   return join4(storeDir(name), String(version));
 }
 var latestCache = /* @__PURE__ */ new Map();
+var historyCache = /* @__PURE__ */ new Map();
 function forgetLatest(name) {
-  if (name) latestCache.delete(name);
-  else latestCache.clear();
+  if (name) {
+    latestCache.delete(name);
+    historyCache.delete(name);
+  } else {
+    latestCache.clear();
+    historyCache.clear();
+  }
 }
 function latestVersion(name) {
   if (latestCache.has(name)) return latestCache.get(name) ?? null;
@@ -337,7 +469,9 @@ function latestVersion(name) {
       if (existsSync3(versionDir(name, next.version))) throw new Error(`${versionDir(name, next.version)} exists but ${indexFile(name)} doesn't list it: fix the index before adding versions`);
       mkdirSync2(storeDir(name), { recursive: true });
       copySkill(source, versionDir(name, next.version));
-      writeState(indexFile(name), [...history, next]);
+      const recorded = [...history, next];
+      writeState(indexFile(name), recorded);
+      historyCache.set(name, recorded);
       result = next;
     }
   }
@@ -463,26 +597,63 @@ function normalizeRemote(url) {
 }
 var repos = /* @__PURE__ */ new Map();
 var changedAt = (path) => statSync3(path, { throwIfNoEntry: false })?.mtimeMs ?? -1;
+function gitCommon(root) {
+  const gitPath = join5(root, ".git");
+  const st = statSync3(gitPath, { throwIfNoEntry: false });
+  if (!st) return null;
+  if (st.isDirectory()) return existsSync4(join5(gitPath, "HEAD")) ? gitPath : null;
+  if (!st.isFile()) return null;
+  const gitdir = readFileSync3(gitPath, "utf-8").match(/^gitdir:\s*(.+?)\s*$/m)?.[1];
+  if (!gitdir) return null;
+  const dir = resolve3(root, gitdir);
+  if (!existsSync4(dir)) return null;
+  let common = dir;
+  try {
+    const resolved = resolve3(dir, readFileSync3(join5(dir, "commondir"), "utf-8").trim());
+    if (existsSync4(resolved)) common = resolved;
+  } catch {
+  }
+  return existsSync4(join5(common, "HEAD")) ? common : null;
+}
+function remoteUrls(configPath) {
+  let text;
+  try {
+    text = readFileSync3(configPath, "utf-8");
+  } catch {
+    return [];
+  }
+  if (/^\s*\[include/m.test(text)) return null;
+  const urls = [];
+  let section = "";
+  for (const line of text.split(/\r?\n/)) {
+    const header = line.match(/^\s*\[([^\]]+)\]\s*$/);
+    if (header) {
+      const remote = header[1].match(/^remote\s+"(.+)"$/) ?? header[1].match(/^remote\s+(\S+)$/);
+      section = remote?.[1] ?? "";
+      continue;
+    }
+    const url = section ? line.match(/^\s*url\s*=\s*(.*?)\s*$/) : null;
+    if (url) urls.push([`remote.${section}.url`, url[1]]);
+  }
+  return urls;
+}
 function repoOf(root) {
   const real = realPath(root);
   const hit = repos.get(real);
   if (hit && (hit.config ? changedAt(hit.config) === hit.seen : !existsSync4(join5(root, ".git")))) return hit.repo;
-  const out2 = gitIn(root, ["rev-parse", "--show-prefix", "--git-common-dir"])?.split("\n");
-  if (!out2) {
+  const commonPath = gitCommon(root);
+  if (!commonPath) {
     repos.set(real, { repo: null, config: null, seen: 0 });
     return null;
   }
-  const common = realNative(resolve3(root, out2[1].trim())) ?? resolve3(root, out2[1].trim());
+  const common = realNative(commonPath) ?? commonPath;
   const folder = basename2(common) === ".git" ? dirname2(common) : common;
   const config = join5(common, "config");
   const seen = changedAt(config);
-  let repo = null;
-  if (out2[0] === "") {
-    const urls = (gitIn(root, ["config", "--get-regexp", "^remote\\..*\\.url$"]) ?? "").split("\n").filter(Boolean).map((l) => [l.slice(0, l.indexOf(" ")), l.slice(l.indexOf(" ") + 1)]);
-    const url = (urls.find(([k]) => k === "remote.origin.url") ?? urls[0])?.[1];
-    const remote = url ? normalizeRemote(url) : void 0;
-    repo = { file: pinsFileFor(root, remote, folder), folder, common, ...remote ? { remote } : {}, root };
-  }
+  const urls = remoteUrls(config) ?? (gitIn(root, ["config", "--get-regexp", "^remote\\..*\\.url$"]) ?? "").split("\n").filter(Boolean).map((l) => [l.slice(0, l.indexOf(" ")), l.slice(l.indexOf(" ") + 1)]);
+  const url = (urls.find(([k]) => k === "remote.origin.url") ?? urls[0])?.[1];
+  const remote = url ? normalizeRemote(url) : void 0;
+  const repo = { file: pinsFileFor(root, remote, folder), folder, common, ...remote ? { remote } : {}, root };
   repos.set(real, { repo, config, seen });
   return repo;
 }
@@ -574,7 +745,10 @@ function isProjectCandidate(root) {
 function rememberProjects(roots) {
   const incoming = roots.map((r) => resolve3(r)).filter((r) => isProjectCandidate(r) && !isAgentWorktree(r));
   const all = onePerFolder([...knownProjects(), ...incoming]).sort();
-  writeState(projectsFile(), all);
+  const path = projectsFile();
+  const prev = readState(path);
+  if (Array.isArray(prev) && prev.length === all.length && prev.every((p, i) => p === all[i])) return;
+  writeState(path, all);
 }
 function readableRoots(roots) {
   const unreadable = [];
@@ -639,7 +813,7 @@ function findProjects(dir, depth = 4) {
   if (depth < 0 || !existsSync5(dir)) return [];
   if (isProjectCandidate(dir)) {
     const isRepo = existsSync5(join6(dir, ".git"));
-    const hasSkills = ALL_PROJECT_DIRS.some((d) => skillDirsIn(join6(dir, d)).length > 0) || existsSync5(join6(dir, MANIFEST_FILE));
+    const hasSkills = projectDirsInUse(enabledHarnesses()).some((d) => skillDirsIn(join6(dir, d)).length > 0) || existsSync5(join6(dir, MANIFEST_FILE));
     if (isRepo || hasSkills) return [dir];
   }
   let entries = [];
@@ -1112,7 +1286,7 @@ function blindSaid(name, blind, label = basename4) {
   return `${who} only ${blind.length === 1 ? "sees" : "see"} the global copy: ${fixes.join("; ")}, or keep ${name} global (skilllib global keep)`;
 }
 function dependencyDirs(root, name, dep) {
-  const untracked = ALL_PROJECT_DIRS.find((d) => d !== GROK_SKILLS_DIR && existsSync7(join8(root, d, name, "SKILL.md")) && !isLink(join8(root, d, name)));
+  const untracked = projectDirsInUse(enabledHarnesses()).find((d) => d !== GROK_SKILLS_DIR && existsSync7(join8(root, d, name, "SKILL.md")) && !isLink(join8(root, d, name)));
   const primary = dep ? dep.dir ?? PROJECT_SKILLS_DIR : untracked ?? installDirs(enabledHarnesses())[0];
   const wanted = installDirs(enabledHarnesses(), primary);
   const real = (d) => realpathOrNull(join8(root, d));
@@ -1127,7 +1301,9 @@ function trackBlocker(root, name) {
     return `${MANIFEST_FILE} can't be read`;
   }
   const stuck = firstStuck(root, dependencyDirs(root, name, recorded));
-  return stuck ? blockerSaid(root, stuck) : null;
+  if (stuck) return blockerSaid(root, stuck);
+  if (!recorded && !personalPinsFile(root) && gitRepoAbove(root)) return "only the top folder of a git repo can have personal pins";
+  return null;
 }
 function pinsSkill(root, name) {
   try {
@@ -1177,7 +1353,7 @@ function projectStatus(root) {
   const lock = projectSkillsLock(root);
   const unmanaged = [];
   const byName = /* @__PURE__ */ new Map();
-  for (const dir of ALL_PROJECT_DIRS.filter((d) => writableDir(root, d))) {
+  for (const dir of projectDirsInUse(enabled).filter((d) => writableDir(root, d))) {
     for (const path of skillDirsIn(join8(root, dir))) {
       const name = basename4(path);
       if (seen.has(name)) continue;
@@ -1476,10 +1652,20 @@ function addSkill(root, name, { force = false, version, allowTracked = false, pe
     ...moved ? { moved } : {}
   };
 }
+function gitRepoAbove(dir) {
+  let at = resolve6(dir);
+  while (true) {
+    if (existsSync7(join8(at, ".git", "HEAD"))) return true;
+    const parent = dirname3(at);
+    if (parent === at) return false;
+    at = parent;
+  }
+}
 function pinsWhere(root, recorded, personal) {
-  const want = personal ?? (recorded ? !!recorded.personal : !existsSync7(join8(root, MANIFEST_FILE)));
-  if (!want || personalPinsFile(root)) return want;
-  return personal ? "only the top folder of a git repo can have personal pins" : false;
+  const want = personal ?? (recorded ? !!recorded.personal : !!personalPinsFile(root));
+  if (want && !personalPinsFile(root)) return "only the top folder of a git repo can have personal pins";
+  if (personal === void 0 && !recorded && !personalPinsFile(root) && gitRepoAbove(root)) return "only the top folder of a git repo can have personal pins";
+  return want;
 }
 var personalOf = (manifest) => Object.fromEntries(Object.entries(manifest.skills).filter(([, d]) => d.personal));
 function removeSkill(root, name, { force = false } = {}) {
@@ -1754,12 +1940,7 @@ function shippedSkill() {
   return readFileSync5(new URL("../skills/skilllib/SKILL.md", import.meta.url), "utf-8");
 }
 function agentSkillDirs(enabled = enabledHarnesses()) {
-  const claudeSkills = join9(claudeDir(), "skills");
-  const agentsSkills = join9(userHome(), ".agents", "skills");
-  const needsClaude = enabled.some((id) => harness(id).globalDirs().includes(claudeSkills));
-  const needsAgents = enabled.some((id) => !harness(id).globalDirs().includes(claudeSkills));
-  const dirs = [...needsClaude ? [claudeSkills] : [], ...needsAgents ? [agentsSkills] : []];
-  return dirs.filter((d, i) => dirs.findIndex((o) => realPath(o) === realPath(d)) === i).map((d) => join9(d, AGENT_SKILL_NAME));
+  return globalInstallDirs(enabled).map((d) => join9(d, AGENT_SKILL_NAME));
 }
 function isOurs(dir) {
   return existsSync8(join9(dir, OWN_SKILL_MARKER));
@@ -1790,7 +1971,7 @@ function installAgentSkill(enabled = enabledHarnesses()) {
   return { ok: true, dirs: [primary, ...links] };
 }
 function removeAgentSkill() {
-  const all = agentSkillDirs(["claude-code", "codex"]);
+  const all = [...new Set(HARNESSES.flatMap((h) => h.globalDirs().map((d) => join9(d, AGENT_SKILL_NAME))))];
   const removed = all.filter((d) => entryExists(d) && (isOurs(d) || isDangling(d)));
   for (const d of removed) {
     if (!entryExists(d)) continue;
@@ -1807,9 +1988,9 @@ function refreshAgentSkill() {
 }
 
 // src/commands.ts
-import { existsSync as existsSync14, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync7, rmSync as rmSync8 } from "fs";
 import { parseArgs as parseFlags } from "util";
-import { basename as basename10, join as join15, resolve as resolve8, sep as sep9 } from "path";
+import { basename as basename11, join as join17, resolve as resolve9, sep as sep10 } from "path";
 
 // src/git.ts
 import { execFileSync as execFileSync3 } from "child_process";
@@ -1828,11 +2009,13 @@ function git(root, args, input) {
 }
 function gitInfo(root, extraDirs = []) {
   let inRepo;
-  try {
-    inRepo = execFileSync3("git", ["rev-parse", "--show-prefix"], { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
-  } catch {
-    if (!existsSync9(join10(root, ".git"))) return null;
-    inRepo = "";
+  if (existsSync9(join10(root, ".git"))) inRepo = "";
+  else {
+    try {
+      inRepo = execFileSync3("git", ["rev-parse", "--show-prefix"], { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    } catch {
+      return null;
+    }
   }
   const real = (p) => {
     try {
@@ -2209,11 +2392,28 @@ function namesIn(dirs) {
   }
   return [...names].sort();
 }
-var PROJECT_TIDY_DIRS = ALL_PROJECT_DIRS.filter((d) => d !== GROK_SKILLS_DIR);
-var repoTidyDirs = (root) => PROJECT_TIDY_DIRS.filter((d) => notWritable(root, d) === null);
+var CLASSIC_TIDY = [PROJECT_SKILLS_DIR, AGENTS_SKILLS_DIR, ".cursor/skills", ".codex/skills"];
+var tidyDirs = () => {
+  const enabled = enabledHarnesses();
+  const fromEnabled = enabled.flatMap((id) => harness(id).projectDirs);
+  return [.../* @__PURE__ */ new Set([...CLASSIC_TIDY, ...fromEnabled])].filter((d) => d !== GROK_SKILLS_DIR && (d !== "skills" || enabled.includes("openclaw")));
+};
+var repoTidyDirs = (root) => tidyDirs().filter((d) => notWritable(root, d) === null);
 function globalTidyDirs() {
   const own = realPath(join12(grokDir(), "skills"));
-  return globalSkillDirs().filter((d) => realPath(d) !== own);
+  const allowed = new Set(
+    [
+      join12(userHome(), ".agents", "skills"),
+      join12(claudeDir(), "skills"),
+      join12(userHome(), ".cursor", "skills"),
+      join12(userHome(), ".codex", "skills"),
+      ...enabledHarnesses().flatMap((id) => harness(id).globalDirs())
+    ].map((d) => realPath(d))
+  );
+  return globalSkillDirs().filter((d) => {
+    const real = realPath(d);
+    return real !== own && allowed.has(real);
+  });
 }
 function runsFrom(id, dirsWithCopy, readsOf) {
   const reads = readsOf(id).filter((d) => dirsWithCopy.includes(d));
@@ -2401,7 +2601,7 @@ function intoLibrary(path, force = false) {
   return r.name;
 }
 var pinsOf = (where, personal) => personal ? "your personal pins" : `${where}'s skilllib.json`;
-var newPinsOf = (root, where) => pinsOf(where, !existsSync12(join13(root, MANIFEST_FILE)) && personalPinsFile(root) !== null);
+var newPinsOf = (root, where) => pinsOf(where, personalPinsFile(root) !== null);
 function track(root, name) {
   const c = addSkill(root, name);
   if (c.action === "skipped") throw new Error(`${name}: ${c.reason}`);
@@ -2464,8 +2664,8 @@ function applyAll(plans, git2) {
 }
 function brokenLinksIn(root, opened) {
   const where = basename7(root);
-  const tidyDirs = repoTidyDirs(root);
-  const hasCopy = (name) => tidyDirs.some((d) => !isLink(join13(root, d, name)) && existsSync12(join13(root, d, name, "SKILL.md")));
+  const tidyDirs2 = repoTidyDirs(root);
+  const hasCopy = (name) => tidyDirs2.some((d) => !isLink(join13(root, d, name)) && existsSync12(join13(root, d, name, "SKILL.md")));
   const mends = (project, dir, name) => {
     const dep = pinsIn(project)[name];
     return !!dep && (dep.links ?? []).includes(dir) && !syncBlocker(project, name, dep) && versionForHash(name, dep.hash) !== null;
@@ -2485,7 +2685,7 @@ function brokenLinksIn(root, opened) {
   const seen = /* @__PURE__ */ new Set();
   const aliased = (dir) => (realNative(join13(root, dir)) ?? "") !== join13(realRoot, dir);
   const packageFolders = packageSkillFolders(root).map((f) => ({ dir: f.location, top: false })).sort((a, b) => Number(aliased(a.dir)) - Number(aliased(b.dir)));
-  const folders2 = [...ALL_PROJECT_DIRS.map((dir) => ({ dir, top: true })), ...packageFolders].flatMap(({ dir, top }) => {
+  const folders2 = [...projectDirsInUse(enabledHarnesses()).map((dir) => ({ dir, top: true })), ...packageFolders].flatMap(({ dir, top }) => {
     const real = realNative(join13(root, dir)) ?? join13(root, dir);
     if (seen.has(real)) return [];
     seen.add(real);
@@ -2867,7 +3067,7 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
   }
   const agentSkill2 = agentSkillState();
   if (agentSkill2 !== "installed") {
-    const install = {
+    const install2 = {
       label: agentSkill2 === "missing" ? "Install the skilllib skill for your agents" : "Update the skilllib skill",
       hint: "one global skill, in ~/.claude/skills (and ~/.agents/skills)",
       run: () => {
@@ -2882,7 +3082,7 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
       title: agentSkill2 === "missing" ? "Your agents don't know about skilllib" : "The skilllib skill for your agents is out of date",
       detail: "The skilllib skill lets you ask your agents which skills they can use here, where each comes from, and which of your skills a repo should add.",
       at: rows(null, ["skilllib"]),
-      ...agentSkill2 === "missing" ? { choices: [install] } : { fix: install }
+      ...agentSkill2 === "missing" ? { choices: [install2] } : { fix: install2 }
     });
   }
   return issues;
@@ -2959,7 +3159,7 @@ function repoIssues(root, ctx) {
   if (drifted.length) {
     const seen = drifted.some((s) => isShared(gitOf(root)?.of(relativeTo(root, s.path))));
     const yours = drifted.some((s) => untrackable(s));
-    const install = {
+    const install2 = {
       label: "Install the pinned versions",
       hint: seen ? "git will see the copies change" : "your library keeps every version",
       run: () => summarize(where, "synced", syncProject(root, { names: drifted.map((s) => s.name) }))
@@ -2970,7 +3170,7 @@ function repoIssues(root, ctx) {
       title: `${where}: ${plural(drifted.length, "skill")} not at the pinned version`,
       detail: `${drifted.map((s) => s.name).join(", ")}: each copy is another version from your library. sync installs the pinned one.${yours ? ` ${[...new Set(drifted.flatMap((s) => untrackable(s) ? [untrackable(s)] : []))].map((why) => `${drifted.filter((s) => untrackable(s) === why).map((s) => s.name).join(", ")}: ${why}`).join("; ")}, so skilllib can't pin the version that's there; ${drifted.filter((s) => untrackable(s)).length === 1 ? "it may be edits you copied into Your skills on purpose, and stays" : "they may be edits you copied into Your skills on purpose, and stay"} unless you choose this.` : ""}`,
       at: rows(root, drifted.map((s) => s.name)),
-      ...seen || yours ? { choices: [install] } : { fix: install }
+      ...seen || yours ? { choices: [install2] } : { fix: install2 }
     });
   }
   for (const s of unstuck.filter((s2) => s2.state === "folder missing" && s2.latest === null))
@@ -3144,13 +3344,13 @@ function repoIssues(root, ctx) {
         id: `local:${root}:${s.name}`,
         severity: "suggestion",
         title: `${s.name} in ${where} isn't in your library`,
-        detail: "Import it into the library to reuse it in other projects and keep it backed up. The repo then tracks it (in skilllib.json, or your personal pins when it has none).",
+        detail: `Import it into the library to reuse it in other projects and keep it backed up. The repo then tracks it in ${newPinsOf(root, where)}.`,
         at: rows(root, [s.name]),
         choices: [
           {
             label: "Import into the library",
             // Tracking it writes skilllib.json.
-            hint: `copies it into Your skills${gitNote(root, [join13(root, MANIFEST_FILE)])}`,
+            hint: `copies it into Your skills${personalPinsFile(root) ? "" : gitNote(root, [join13(root, MANIFEST_FILE)])}`,
             run: () => {
               intoLibrary(s.path);
               track(root, s.name);
@@ -3207,7 +3407,7 @@ function repoIssues(root, ctx) {
         id: `npx:${root}:${s.name}`,
         severity: "suggestion",
         title: `${s.name} in ${where} came from npx skills, not your library`,
-        detail: `Installed with \`npx skills add\`${s.source ? ` (${s.source})` : ""}. Import it into your library to reuse it in other projects and keep it backed up${teams ? `; ${where}'s copy stays as it is (${committed(s) ? "committed" : `${untrackable(s)}, so skilllib can't track it here`})` : `; ${where} then tracks it (in skilllib.json, or your personal pins when it has none)`}.`,
+        detail: `Installed with \`npx skills add\`${s.source ? ` (${s.source})` : ""}. Import it into your library to reuse it in other projects and keep it backed up${teams ? `; ${where}'s copy stays as it is (${committed(s) ? "committed" : `${untrackable(s)}, so skilllib can't track it here`})` : `; ${where} then tracks it in ${newPinsOf(root, where)}`}.`,
         at: rows(root, [s.name]),
         choices: [
           {
@@ -3478,8 +3678,8 @@ function libraryFor(currentProject) {
 }
 
 // src/usage.ts
-import { createReadStream, existsSync as existsSync13, readdirSync as readdirSync10, statSync as statSync6 } from "fs";
-import { join as join14 } from "path";
+import { createReadStream, existsSync as existsSync13, mkdirSync as mkdirSync9, readdirSync as readdirSync10, renameSync as renameSync4, rmSync as rmSync6, statSync as statSync6, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname7, join as join14 } from "path";
 import { createInterface } from "readline";
 var BUILTIN_COMMANDS = /* @__PURE__ */ new Set([
   "add-dir",
@@ -3581,21 +3781,58 @@ function transcriptFiles(sinceMs) {
     });
   });
 }
+function usageCacheFile() {
+  return join14(skilllibHome(), "usage-cache.json");
+}
+function readUsageCache() {
+  const data = readJson(usageCacheFile());
+  return data?.files && typeof data.files === "object" ? data : { files: {} };
+}
+function writeUsageCache(cache) {
+  const path = usageCacheFile();
+  const temp = `${path}.${process.pid}.tmp`;
+  try {
+    mkdirSync9(dirname7(path), { recursive: true });
+    writeFileSync6(temp, JSON.stringify(cache));
+    renameSync4(temp, path);
+  } catch {
+    rmSync6(temp, { force: true });
+  }
+}
+async function usesIn(file) {
+  const uses = [];
+  const lines = createInterface({ input: createReadStream(file), crlfDelay: Infinity });
+  for await (const line of lines) uses.push(...usesFromTranscriptLine(line));
+  return uses;
+}
 async function scanUsage(days) {
   const sinceMs = Date.now() - days * 24 * 60 * 60 * 1e3;
+  const files = transcriptFiles(sinceMs);
+  const cache = readUsageCache();
+  let dirty = false;
+  for (const file of Object.keys(cache.files)) {
+    if (!files.includes(file) && !existsSync13(file)) {
+      delete cache.files[file];
+      dirty = true;
+    }
+  }
   const seen = /* @__PURE__ */ new Map();
-  for (const file of transcriptFiles(sinceMs)) {
+  for (const file of files) {
     try {
-      const lines = createInterface({ input: createReadStream(file), crlfDelay: Infinity });
-      for await (const line of lines) {
-        for (const use of usesFromTranscriptLine(line)) {
-          if (Date.parse(use.at) >= sinceMs) seen.set(use.key, use);
-        }
+      const st = statSync6(file);
+      const mtimeMs = Math.round(st.mtimeMs);
+      const hit = cache.files[file];
+      const uses = hit && hit.size === st.size && hit.mtimeMs === mtimeMs && Array.isArray(hit.uses) ? hit.uses : await usesIn(file);
+      if (uses !== hit?.uses) {
+        cache.files[file] = { size: st.size, mtimeMs, uses };
+        dirty = true;
       }
+      for (const use of uses) if (Date.parse(use.at) >= sinceMs) seen.set(use.key, use);
     } catch {
       continue;
     }
   }
+  if (dirty) writeUsageCache(cache);
   return [...seen.values()];
 }
 var skillOf = (key) => key.split(":").pop();
@@ -3625,12 +3862,298 @@ function usesByProject(uses, projectOf) {
   return byProject;
 }
 
+// src/install.ts
+import { execFileSync as execFileSync5 } from "child_process";
+import { createWriteStream, existsSync as existsSync14, lstatSync as lstatSync5, mkdirSync as mkdirSync10, mkdtempSync, readdirSync as readdirSync11, rmSync as rmSync7, statSync as statSync7 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename9, join as join15, resolve as resolve8, sep as sep9 } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+var SEARCH_API = process.env.SKILLLIB_SKILLS_API || "https://skills.sh";
+var MAX_BYTES = 32 * 1024 * 1024;
+var SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "coverage"]);
+async function searchSkills(query) {
+  const url = `${SEARCH_API}/api/search?${new URLSearchParams({ q: query, limit: "20" })}`;
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`skills.sh search failed (${res.status})`);
+  const data = await res.json();
+  return (data.skills ?? []).map((s) => ({
+    name: s.name || s.skillId || s.id || "",
+    source: s.source || "",
+    skillId: s.skillId || s.name || "",
+    installs: s.installs ?? 0
+  }));
+}
+var NAME = /^[A-Za-z0-9_.-]+$/;
+function parseInstallSpec(input) {
+  const trimmed = input.trim().replace(/\/+$/, "");
+  if (!trimmed) return null;
+  if (trimmed.startsWith(".") || trimmed.startsWith("/") || trimmed.startsWith("~") || /^[A-Za-z]:[\\/]/.test(trimmed)) {
+    return { local: trimmed.replace(/^~(?=$|[\\/])/, userHome()) };
+  }
+  let text = trimmed;
+  try {
+    const url = new URL(trimmed);
+    const host = url.hostname.replace(/^www\./, "");
+    const parts2 = url.pathname.split("/").filter(Boolean);
+    if (host === "skills.sh" && parts2.length >= 2) text = parts2.length >= 3 ? `${parts2[0]}/${parts2[1]}@${parts2.slice(2).join("/")}` : `${parts2[0]}/${parts2[1]}`;
+    else if (host === "github.com" && parts2.length >= 2) {
+      const repo = parts2[1].replace(/\.git$/, "");
+      if (parts2[2] === "tree" && parts2.length >= 5) return namePair(parts2[0], repo, parts2.slice(4).join("/"));
+      return namePair(parts2[0], repo);
+    } else return null;
+  } catch {
+  }
+  const at = text.split("@");
+  if (at.length === 2 && at[0]?.includes("/") && at[1] && at[0].split("/").length === 2) {
+    const [owner, repo] = at[0].split("/");
+    return namePair(owner, repo, at[1]);
+  }
+  const parts = text.split("/");
+  if (parts.length === 2) return namePair(parts[0], parts[1]);
+  if (parts.length >= 3) return namePair(parts[0], parts[1], parts.slice(2).join("/"));
+  return null;
+}
+function namePair(owner, repo, skill) {
+  if (!NAME.test(owner) || !NAME.test(repo) || owner === "." || repo === "." || owner === ".." || repo === "..") return null;
+  return skill ? { owner, repo, skill } : { owner, repo };
+}
+function escapes(root, path) {
+  const base = realpathOrNull(root);
+  const real = realpathOrNull(path);
+  if (!base || !real) return true;
+  return real !== base && !real.startsWith(base + sep9);
+}
+function findSkillDirs(root, depth = 0) {
+  if (depth > 6 || !isDir(root)) return [];
+  if (isSkillDir(root)) return escapes(root, root) ? [] : [root];
+  let names = [];
+  try {
+    names = readdirSync11(root);
+  } catch {
+    return [];
+  }
+  return names.filter((n) => !n.startsWith(".") && !SKIP.has(n)).flatMap((n) => {
+    const path = join15(root, n);
+    const st = lstatSync5(path, { throwIfNoEntry: false });
+    if (!st?.isDirectory()) return [];
+    if (st.isSymbolicLink() && escapes(root, path)) return [];
+    return findSkillDirs(path, depth + 1);
+  });
+}
+function skillNamed(dirs, skill) {
+  if (!skill) return dirs;
+  const want = skill.split("/").filter(Boolean).pop();
+  return dirs.filter((d) => basename9(d) === want || readSkillInfo(d).name === want);
+}
+async function downloadGitHub(owner, repo) {
+  const dest = mkdtempSync(join15(tmpdir2(), "skilllib-"));
+  const archive = join15(dest, "repo.tar.gz");
+  const url = `https://codeload.github.com/${owner}/${repo}/tar.gz/HEAD`;
+  let res;
+  try {
+    res = await fetch(url, { redirect: "follow" });
+  } catch (err) {
+    rmSync7(dest, { recursive: true, force: true });
+    throw new Error(`couldn't download ${owner}/${repo} (${err instanceof Error ? err.message : err})`);
+  }
+  if (!res.ok || !res.body) {
+    rmSync7(dest, { recursive: true, force: true });
+    throw new Error(res.status === 404 ? `${owner}/${repo} not found on GitHub` : `couldn't download ${owner}/${repo} (${res.status})`);
+  }
+  const host = new URL(res.url).hostname;
+  if (host !== "codeload.github.com" && host !== "github.com") {
+    rmSync7(dest, { recursive: true, force: true });
+    throw new Error(`refusing to download ${owner}/${repo} from ${host}`);
+  }
+  let bytes = 0;
+  try {
+    await pipeline(
+      Readable.from(
+        (async function* () {
+          const reader = res.body.getReader();
+          for (; ; ) {
+            const { done, value } = await reader.read();
+            if (done) return;
+            bytes += value.byteLength;
+            if (bytes > MAX_BYTES) throw new Error(`${owner}/${repo} is larger than ${MAX_BYTES / 1024 / 1024}MB`);
+            yield value;
+          }
+        })()
+      ),
+      createWriteStream(archive)
+    );
+    execFileSync5("tar", ["-xzf", archive, "-C", dest], { stdio: "ignore" });
+  } catch (err) {
+    rmSync7(dest, { recursive: true, force: true });
+    if (err instanceof Error && /larger than|couldn't download/.test(err.message)) throw err;
+    throw new Error(`couldn't extract ${owner}/${repo}`);
+  }
+  rmSync7(archive, { force: true });
+  const top = readdirSync11(dest);
+  const root = top.length === 1 && statSync7(join15(dest, top[0])).isDirectory() ? join15(dest, top[0]) : dest;
+  return { tmp: dest, root };
+}
+function installGlobal(name, { force = false } = {}) {
+  const latest = latestVersion(name);
+  if (!latest) return { ok: false, reason: "not in the library" };
+  const parents = globalInstallDirs(enabledHarnesses());
+  if (!parents.length) return { ok: false, reason: "no agents chosen yet (skilllib harnesses)" };
+  const [primary, ...links] = parents;
+  const dest = join15(primary, name);
+  if (entryExists(dest) && !isLink(dest) && !isDir(dest)) return { ok: false, reason: `${dest} is a file` };
+  const there = treeHash(dest);
+  if (there && there !== latest.hash && versionForHash(name, there) === null && !force) {
+    return { ok: false, reason: `${name} is already global, with edits that aren't in your library (pass --force to replace them)` };
+  }
+  if (there !== latest.hash) {
+    if (isLink(dest)) rmSync7(dest, { force: true });
+    mkdirSync10(primary, { recursive: true });
+    copySkill(versionDir(name, latest.version), dest);
+  }
+  const wrote = [dest];
+  for (const dir of links) {
+    const link2 = join15(dir, name);
+    if (isLink(link2) && realpathOrNull(link2) === null) rmSync7(link2, { force: true });
+    else if (entryExists(link2)) {
+      if (realpathOrNull(link2) === realpathOrNull(dest)) wrote.push(link2);
+      continue;
+    }
+    mkdirSync10(dir, { recursive: true });
+    linkDir(realpathOrNull(dest) ?? dest, join15(realpathOrNull(dir) ?? dir, name));
+    wrote.push(link2);
+  }
+  setKeepGlobal([name], true);
+  return { ok: true, dirs: wrote };
+}
+function installFound(dirs, source, { force = false, global = false, allowTracked = false } = {}) {
+  const root = global ? null : projectHere();
+  const label = source.startsWith("/") || source.startsWith(".") ? source : `skills.sh: ${source}`;
+  return dirs.map((dir) => {
+    const imported = importSkill(dir, { force });
+    if (imported.status !== "exists") recordOrigin(imported.name, label);
+    const row = { name: imported.name, source, status: imported.status };
+    if (imported.status === "exists") {
+      row.reason = "the library already has a different version (pass --force)";
+      return row;
+    }
+    if (global) {
+      const placed = installGlobal(imported.name, { force });
+      if (!placed.ok) {
+        row.status = "skipped";
+        row.reason = placed.reason;
+      } else row.global = placed.dirs;
+      return row;
+    }
+    if (!root) return row;
+    row.project = addSkill(root, imported.name, { force, allowTracked });
+    if (row.project.action === "skipped") {
+      row.status = "skipped";
+      row.reason = row.project.reason;
+    }
+    return row;
+  });
+}
+async function resolveInstallDir(spec) {
+  if ("local" in spec) {
+    const path = resolve8(spec.local);
+    if (!existsSync14(path)) throw new Error(`${path} doesn't exist`);
+    const dirs2 = isSkillDir(path) ? [path] : findSkillDirs(path);
+    return { dirs: dirs2, source: path, many: dirs2.length > 1 };
+  }
+  const got = await downloadGitHub(spec.owner, spec.repo);
+  const source = spec.skill ? `${spec.owner}/${spec.repo}@${spec.skill}` : `${spec.owner}/${spec.repo}`;
+  const dirs = skillNamed(findSkillDirs(got.root), spec.skill);
+  return { tmp: got.tmp, dirs, source, many: !spec.skill && dirs.length > 1 };
+}
+
+// src/check.ts
+import { join as join16 } from "path";
+function promptTokens(name, description) {
+  return Math.max(1, Math.ceil((name.length + 1 + description.length) / 4));
+}
+function freshLabel(state, version, latest) {
+  if (state === "update available") return `v${version} \u2192 v${latest}`;
+  if (state === "edited locally, update available") return `edited here, library has v${latest}`;
+  if (state === "edited locally") return "edited here";
+  if (state === "out of sync") return "not the pinned version";
+  if (state === "folder missing") return "folder missing";
+  if (state === "ok" || state === "repo skill, in library" || state === "untracked copy of library skill") return "current";
+  if (state === "untracked, differs from library" || state === "repo skill, differs from library") return "differs from your library";
+  return "not in your library";
+}
+function libraryFresh(path, name) {
+  const lib = join16(libraryDir(), name);
+  if (!isSkillDir(lib)) return "not in your library";
+  const here = treeHash(path);
+  return here && here === treeHash(lib) ? "matches your library" : "differs from your library";
+}
+var settled = /* @__PURE__ */ new Set(["current", "matches your library", "vendor", "skilllib"]);
+function byWeight(rows2) {
+  const rank = (r) => (r.uses === 0 ? 0 : 1) * 2 + (settled.has(r.fresh) ? 1 : 0);
+  return [...rows2].sort((a, b) => rank(a) - rank(b) || b.everyPrompt - a.everyPrompt || a.name.localeCompare(b.name));
+}
+function tokenSum(rows2, where) {
+  return rows2.filter((r) => !where || r.where === where).reduce((n, r) => n + r.everyPrompt, 0);
+}
+function rough(n) {
+  const rounded = n >= 100 ? Math.round(n / 100) * 100 : n;
+  return String(rounded).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+function checkBrief(rows2, ctx) {
+  const global = rows2.filter((r) => r.where === "global");
+  const repo = rows2.filter((r) => r.where === "repo");
+  const globalTokens = tokenSum(global);
+  const unused = rows2.filter((r) => r.uses === 0);
+  const unusedGlobal = global.filter((r) => r.uses === 0 && r.lever !== "skilllib");
+  const unusedTokens = tokenSum(unusedGlobal);
+  const n = (count) => `${count} skill${count === 1 ? "" : "s"}`;
+  const lines = [
+    `${n(rows2.length)}. ~${rough(globalTokens)} tokens of names and descriptions in every prompt${ctx.repo ? `, plus ~${rough(tokenSum(repo))} from this repo` : ""}.`,
+    `${unused.length} had no Claude Code use in ${ctx.days} days. A zero is a hint: Cursor and Codex aren't in these transcripts.`
+  ];
+  if (!globalTokens) return [...lines, "Nothing global is loading."];
+  lines.push(
+    unusedTokens * 2 >= globalTokens ? "Heavy. More than half of every prompt's skill list had no use." : unusedTokens * 4 >= globalTokens ? "Mixed. A good share of every prompt is skills with no use." : "Fine. Most of what loads has been used."
+  );
+  const plugins = Object.entries(Object.groupBy(global.filter((r) => r.lever === "plugin"), (r) => r.via ?? r.name)).map(([id, skills = []]) => ({
+    id,
+    tokens: tokenSum(skills),
+    idle: tokenSum(skills.filter((s) => s.uses === 0)),
+    skills: skills.length,
+    used: skills.filter((s) => s.uses > 0).length
+  })).filter((p) => p.idle > 0 && p.idle * 2 >= p.tokens).sort((a, b) => b.tokens - a.tokens);
+  const yours = unusedGlobal.filter((r) => r.lever === "yours");
+  const synced = unusedGlobal.filter((r) => r.lever === "claude.ai");
+  const drop = plugins.reduce((n2, p) => n2 + p.tokens, 0) + tokenSum(yours) + tokenSum(synced);
+  if (drop > 0) lines.push(`You can drop ~${rough(drop)} tokens.`);
+  for (const p of plugins.slice(0, 3)) {
+    lines.push(
+      p.used ? `~${rough(p.tokens)} is ${p.id} (${p.skills} skills, ${p.used} used). Turning the plugin off drops all of it, including ${p.used === 1 ? "that one" : "those"}.` : `~${rough(p.tokens)} is ${p.id} (${p.skills} skills, no use). Turn the plugin off.`
+    );
+  }
+  if (plugins.length > 3) lines.push(`${plugins.length - 3} more plugins are in the same spot.`);
+  if (plugins.length) lines.push("Turn a Claude Code plugin off with skilllib plugin off <id>. Cursor plugins turn off in Cursor.");
+  if (yours.length) {
+    const names = yours.sort((a, b) => b.everyPrompt - a.everyPrompt).slice(0, 5).map((r) => r.name);
+    const more = yours.length > 5 ? `, and ${yours.length - 5} more` : "";
+    lines.push(`~${rough(tokenSum(yours))} are your own global skills with no use (${names.join(", ")}${more}). Move them into the repos that need them, or delete them.`);
+  }
+  if (synced.length) lines.push(`~${rough(tokenSum(synced))} are claude.ai skills with no use. Turn them off on claude.ai.`);
+  const builtins = unusedGlobal.filter((r) => r.lever === "built-in");
+  if (builtins.length) {
+    const who = [...new Set(builtins.map((r) => r.via ?? "the agent"))].join(", ");
+    lines.push(`~${rough(tokenSum(builtins))} are ${who} built-ins with no use. They ship with the agent. skilllib can't unload them.`);
+  }
+  return lines;
+}
+
 // src/move.ts
-import { basename as basename9 } from "path";
+import { basename as basename10 } from "path";
 function moveGlobalSkills(skills, roots, {
   group,
   allowTracked = false,
-  label = basename9,
+  label = basename10,
   allowTrackedHint = "re-run with --allow-tracked"
 } = {}) {
   const byName = /* @__PURE__ */ new Map();
@@ -3749,9 +4272,9 @@ function projectOfFactory(projects2) {
   const sorted2 = [...projects2].sort((a, b) => b.length - a.length);
   return (cwd) => {
     if (!cwd) return null;
-    const known = sorted2.find((p) => cwd === p || cwd.startsWith(p + sep9));
+    const known = sorted2.find((p) => cwd === p || cwd.startsWith(p + sep10));
     if (known) return known;
-    const repo = cwd.split(`${sep9}.claude${sep9}worktrees${sep9}`)[0];
+    const repo = cwd.split(`${sep10}.claude${sep10}worktrees${sep10}`)[0];
     return isProjectCandidate(repo) ? repo : null;
   };
 }
@@ -3765,7 +4288,7 @@ var projectsFor = (args) => {
   if (!args.all) return [requireProject()];
   const { readable, unreadable } = readableRoots(visibleProjects());
   for (const u of unreadable) {
-    error(`${basename10(u.root)}: ${u.reason}`);
+    error(`${basename11(u.root)}: ${u.reason}`);
     process.exitCode = 1;
   }
   return readable;
@@ -3777,7 +4300,7 @@ function requireProject() {
   if (!isProjectCandidate(findProjectRoot())) {
     const top = findProjectRoot();
     if (realPath(top) !== realPath(userHome())) throw new Error(`${tildify(top)} is skilllib's or an agent's own folder, not a project. Run this inside a project.`);
-    const stray = existsSync14(join15(userHome(), MANIFEST_FILE)) ? `, though ${tildify(join15(userHome(), MANIFEST_FILE))} makes it look like one` : "";
+    const stray = existsSync15(join17(userHome(), MANIFEST_FILE)) ? `, though ${tildify(join17(userHome(), MANIFEST_FILE))} makes it look like one` : "";
     throw new Error(`Your home folder isn't a project${stray}: skills added here would load in every repo. Run this inside a project.`);
   }
   throw new Error("Not in a git repo. Run this inside a project (or `git init` first).");
@@ -3799,7 +4322,7 @@ async function status(args) {
   const root = requireProject();
   const skills = projectStatus(root);
   const nested = nestedSkills(root);
-  info(`${basename10(root)} ${dim(tildify(root))}
+  info(`${basename11(root)} ${dim(tildify(root))}
 `);
   if (skills.length === 0 && nested.length === 0) info("No skills in this project yet. Add one from your library with: skilllib add <name>");
   const usage2 = await usageBySkill(args.days, root);
@@ -3872,7 +4395,7 @@ async function list(args) {
     const installs = /* @__PURE__ */ new Map();
     for (const project of visibleProjects()) {
       for (const name of Object.keys(pinsIn(project))) {
-        installs.set(name, [...installs.get(name) ?? [], basename10(project)]);
+        installs.set(name, [...installs.get(name) ?? [], basename11(project)]);
       }
     }
     const usage2 = await usageBySkill(args.days);
@@ -3915,7 +4438,7 @@ function teamStateIn(root, extraDirs = []) {
 function projects(args) {
   const { readable: roots, unreadable } = readableRoots(visibleProjects());
   for (const u of unreadable) {
-    error(`${basename10(u.root)}: ${u.reason}`);
+    error(`${basename11(u.root)}: ${u.reason}`);
     process.exitCode = 1;
   }
   if (args.json) {
@@ -3924,7 +4447,7 @@ function projects(args) {
       roots.map((root) => {
         const teamState = teamStateIn(root);
         return {
-          name: basename10(root),
+          name: basename11(root),
           path: root,
           skills: projectStatus(root).map((s) => ({ name: s.name, managed: s.managed, state: teamState(s), version: s.version, latest: s.latest }))
         };
@@ -3942,7 +4465,7 @@ function projects(args) {
       const usual = /* @__PURE__ */ new Set(["ok", "local only", "repo skill", "repo skill, in library", "from npx skills"]);
       const attention = skills.filter((s) => !usual.has(teamState(s))).length;
       return {
-        Project: basename10(root),
+        Project: basename11(root),
         Path: dim(tildify(root)),
         Skills: skills.map((s) => s.name).join(", ") || dim("none"),
         "Local only": String(skills.filter((s) => teamState(s) === "local only").length),
@@ -3961,7 +4484,7 @@ function add(args) {
   const pins = readManifest(root).skills;
   const done = changes.filter((c) => c.action !== "skipped" && pins[c.name]);
   if (!args.json && args.personal === void 0 && done.some((c) => c.action === "installed" && !c.moved && pins[c.name].personal))
-    info(dim(`Pinned in your personal pins (${tildify(personalPinsDir())}) and kept out of git. --shared pins in skilllib.json for the team.`));
+    info(dim(`Pinned for you (${tildify(personalPinsDir())}), kept out of git. To share it with the team: skilllib add <name> --shared, then commit skilllib.json and the skill folders.`));
   rememberProjects([root]);
 }
 function remove(args) {
@@ -3977,11 +4500,11 @@ function changeEach(args, change, nothing) {
     const changes = change(root);
     if (changes.some(incomplete)) process.exitCode = 1;
     if (!args.json) {
-      if (args.all) info(`${basename10(root)} ${dim(tildify(root))}`);
+      if (args.all) info(`${basename11(root)} ${dim(tildify(root))}`);
       if (changes.length === 0) nothing(root);
       else printChanges(root, changes, args);
     }
-    return { project: basename10(root), path: root, changes: withDirs(root, changes) };
+    return { project: basename11(root), path: root, changes: withDirs(root, changes) };
   });
   if (args.json) args.all ? json("changes --all", results) : json("changes", results[0].changes);
   return roots;
@@ -4012,7 +4535,7 @@ function update(args) {
 function outdated(args) {
   const roots = projectsFor(args);
   const behind = roots.flatMap(
-    (root) => projectStatus(root).filter((s) => s.state.endsWith("update available") && s.latest !== null && s.version !== null).map((s) => ({ project: basename10(root), path: root, skill: s.name, installed: s.version, latest: s.latest, state: s.state }))
+    (root) => projectStatus(root).filter((s) => s.state.endsWith("update available") && s.latest !== null && s.version !== null).map((s) => ({ project: basename11(root), path: root, skill: s.name, installed: s.version, latest: s.latest, state: s.state }))
   );
   if (args.json) return json("outdated", behind);
   const rows2 = behind.map((b) => ({ Project: b.project, Skill: b.skill, Installed: `v${b.installed}`, Latest: `v${b.latest}`, Status: colorState(b.state) }));
@@ -4023,7 +4546,7 @@ function outdated(args) {
 }
 function importSkills(args) {
   if (args.global && args.positional.length) throw new Error("skilllib import --global takes no folders: it imports all your global skills");
-  const dirs = args.global ? yourGlobals().map((m) => m.path) : args.positional.map((p) => resolve8(p));
+  const dirs = args.global ? yourGlobals().map((m) => m.path) : args.positional.map((p) => resolve9(p));
   if (dirs.length === 0) {
     throw new Error("Usage: skilllib import <skill-dir>... [--force] | skilllib import --global");
   }
@@ -4043,11 +4566,11 @@ function importSkills(args) {
       continue;
     }
     success(`${name} ${dim(result === "unchanged" ? "already in library" : result === "added" ? "added to library" : "library updated")}`);
-    const root = resolve8(dir, "..", "..", "..");
+    const root = resolve9(dir, "..", "..", "..");
     const dep = projectHere(root) === root ? readManifest(root).skills[name] : void 0;
-    if (dep && realpathOrNull(join15(root, dep.dir ?? PROJECT_SKILLS_DIR, name)) === realpathOrNull(dir) && dep.hash !== treeHash(dir)) {
+    if (dep && realpathOrNull(join17(root, dep.dir ?? PROJECT_SKILLS_DIR, name)) === realpathOrNull(dir) && dep.hash !== treeHash(dir)) {
       const change = addSkill(root, name);
-      if (change.action !== "skipped") info(dim(`  ${basename10(root)} now depends on ${name} v${change.to}`));
+      if (change.action !== "skipped") info(dim(`  ${basename11(root)} now depends on ${name} v${change.to}`));
     }
   }
   if (args.json) json("import", results);
@@ -4063,14 +4586,14 @@ function scan(args) {
   const library = new Set(librarySkills().map((s) => s.name));
   const skillNames = (root) => [
     // Not a folder that links out of the repo: what's in it isn't the repo's (as in status).
-    .../* @__PURE__ */ new Set([...ALL_PROJECT_DIRS.filter((d) => !notWritable(root, d)).flatMap((d) => skillDirsIn(join15(root, d))).map((d) => basename10(d)), ...nestedSkills(root).map((s) => s.name)])
+    .../* @__PURE__ */ new Set([...projectDirsInUse(enabledHarnesses()).filter((d) => !notWritable(root, d)).flatMap((d) => skillDirsIn(join17(root, d))).map((d) => basename11(d)), ...nestedSkills(root).map((s) => s.name)])
   ];
   const withSkills = found.filter((root) => skillNames(root).length > 0);
   info(`Scanned ${roots.map((r) => tildify(r)).join(", ")}: ${found.length} project${found.length === 1 ? "" : "s"}, ${withSkills.length} with skills
 `);
   table(
     withSkills.map((root) => ({
-      Project: basename10(root),
+      Project: basename11(root),
       Path: dim(tildify(root)),
       Skills: skillNames(root).map((n) => library.has(n) ? n : yellow(n)).join(", ")
     }))
@@ -4127,7 +4650,7 @@ function newSkill(args) {
   if (!r.ok) {
     throw new Error(`Can't create ${name}: ${r.reason}`);
   }
-  success(`Created ${tildify(join15(r.dir, "SKILL.md"))}`);
+  success(`Created ${tildify(join17(r.dir, "SKILL.md"))}`);
 }
 function restore(args) {
   const backups = [...listBackups(), ...pluginBackups()];
@@ -4240,7 +4763,7 @@ async function usage(args) {
     return json("usage", {
       usageDays: args.days,
       source: "Claude Code transcripts",
-      skills: summaries.map((s) => ({ skill: s.skill, uses: s.uses, lastUsed: s.lastUsed, projects: [...s.projects].map((p) => basename10(p)), inLibrary: library.has(s.skill) })),
+      skills: summaries.map((s) => ({ skill: s.skill, uses: s.uses, lastUsed: s.lastUsed, projects: [...s.projects].map((p) => basename11(p)), inLibrary: library.has(s.skill) })),
       unusedLibrarySkills: unused
     });
   }
@@ -4248,13 +4771,13 @@ async function usage(args) {
     info(`No skill usage in Claude Code transcripts from the last ${args.days} days.`);
     return;
   }
-  info(`Skill usage, last ${args.days} days ${dim(`(from ${tildify(join15(claudeDir(), "projects"))})`)}
+  info(`Skill usage, last ${args.days} days ${dim(`(from ${tildify(join17(claudeDir(), "projects"))})`)}
 `);
   table(
     summaries.map((s) => ({
       Skill: s.skill,
       Uses: String(s.uses),
-      Projects: [...s.projects].map((p) => basename10(p)).join(", ") || dim("-"),
+      Projects: [...s.projects].map((p) => basename11(p)).join(", ") || dim("-"),
       "Last used": lastUsed(s),
       Library: library.has(s.skill) ? green("yes") : dim("no")
     }))
@@ -4264,9 +4787,117 @@ async function usage(args) {
     warn(`Library skills unused in the last ${args.days} days: ${unused.join(", ")}`);
   }
 }
+var LEVER = { plugin: "plugin", "built-in": "built-in", "claude.ai": "claude.ai", system: "system", skilllib: "skilllib" };
+async function check(args) {
+  const root = projectHere();
+  const usage2 = await usageBySkill(args.days);
+  const kept = keptGlobal();
+  const machine = machineSkills().filter((m) => !m.broken);
+  const loaded = root ? skillsLoadedIn(root, machine) : machine;
+  const local = root ? projectStatus(root) : [];
+  const localByName = new Map(local.map((s) => [s.name, s]));
+  const seen = /* @__PURE__ */ new Set();
+  const rows2 = [];
+  for (const g of loaded) {
+    seen.add(g.name);
+    const here = localByName.get(g.name);
+    const u = usage2.get(g.name);
+    const repoFresh = here && here.state !== "folder missing" ? freshLabel(here.state, here.version, here.latest) : null;
+    const lever = LEVER[g.kind] ?? "yours";
+    rows2.push({
+      name: g.name,
+      where: "global",
+      description: g.description,
+      everyPrompt: promptTokens(g.name, g.description),
+      uses: u?.uses ?? 0,
+      lastUsed: u ? u.lastUsed.slice(0, 10) : null,
+      projects: [...u?.projects ?? []].map((p) => basename11(p)),
+      fresh: lever === "yours" ? repoFresh ?? libraryFresh(g.path, g.name) : lever,
+      path: g.path,
+      lever,
+      ...lever !== "yours" && lever !== "skilllib" ? { via: g.origin } : {},
+      ...here ? { alsoInRepo: true } : {},
+      ...kept.has(g.name) ? { keptGlobal: true } : {}
+    });
+  }
+  for (const s of local) {
+    if (seen.has(s.name) || s.state === "folder missing") continue;
+    const u = usage2.get(s.name);
+    const { description } = readSkillInfo(s.path);
+    rows2.push({
+      name: s.name,
+      where: "repo",
+      description,
+      everyPrompt: promptTokens(s.name, description),
+      uses: u?.uses ?? 0,
+      lastUsed: u ? u.lastUsed.slice(0, 10) : null,
+      projects: [...u?.projects ?? []].map((p) => basename11(p)),
+      fresh: freshLabel(s.state, s.version, s.latest),
+      path: s.path,
+      lever: "repo"
+    });
+  }
+  const skills = byWeight(rows2);
+  const repoName = root ? basename11(root) : null;
+  const brief = checkBrief(skills, { days: args.days, repo: repoName });
+  const report = {
+    days: args.days,
+    repo: repoName,
+    everyPrompt: { global: tokenSum(skills, "global"), repo: tokenSum(skills, "repo") },
+    note: "Uses are Claude Code transcripts only, so 0 means it wasn't seen. everyPrompt is a rough token count (chars/4) of the name and description, which sit in every prompt. The rest of SKILL.md loads only when the skill is used. brief is the report.",
+    brief,
+    skills: skills.map(({ lastUsed: lastUsed2, projects: projects2, via, alsoInRepo, keptGlobal: keptGlobal2, ...rest }) => ({
+      ...rest,
+      ...lastUsed2 ? { lastUsed: lastUsed2 } : {},
+      ...projects2.length ? { projects: projects2 } : {},
+      ...via ? { via } : {},
+      ...alsoInRepo ? { alsoInRepo } : {},
+      ...keptGlobal2 ? { keptGlobal: keptGlobal2 } : {}
+    }))
+  };
+  if (args.json) return json("check", report);
+  if (!skills.length) return info("No skills loaded.");
+  info(brief.join("\n"));
+}
+function pluginCommand(args) {
+  const [action, id, extra] = args.positional;
+  if (action !== "off" && action !== "on" || !id || extra) throw new Error("Usage: skilllib plugin off|on <id>");
+  const on = action === "on";
+  const targets = pluginTargets(id);
+  const results = targets.map((p) => setPluginOn(p, on));
+  const ok = results.every((r) => r.ok);
+  const message = [...results.map((r) => r.message), stillOnElsewhere(targets)].filter(Boolean).join(" ");
+  if (!ok) process.exitCode = 1;
+  const body = { id: targets[0].id, on, ok, message };
+  if (args.json) return json("plugin", body);
+  if (ok) success(message);
+  else error(message);
+}
+function pluginTargets(id) {
+  const claude2 = installedPlugins().filter((p) => p.agent === "claude-code");
+  const exact = claude2.filter((p) => p.id === id);
+  const matches = exact.length ? exact : claude2.filter((p) => pluginNameOf(p.id) === id);
+  if (!matches.length) {
+    const cursor = cursorPlugins().some((p) => p.id === id || pluginNameOf(p.id) === id);
+    throw new Error(cursor ? `${id} is a Cursor plugin. Turn it off in Cursor (Settings \u2192 Plugins).` : `No Claude Code plugin ${id}.`);
+  }
+  const ids = [...new Set(matches.map((p) => p.id))];
+  if (ids.length > 1) throw new Error(`Several plugins match ${id}: ${ids.join(", ")}. Pass the id.`);
+  const everywhere = matches.filter((p) => !p.projectPath);
+  if (everywhere.length) return everywhere;
+  if (matches.length === 1) return matches;
+  const where = matches.map((p) => `${basename11(p.projectPath)} (${p.scope})`).join(", ");
+  throw new Error(`${matches[0].id} is installed in more than one repo (${where}). This command switches the copy that loads in every repo, and these are per-repo installs.`);
+}
+function stillOnElsewhere(targets) {
+  const id = targets[0].id;
+  const switched = new Set(targets.map((p) => p.projectPath).filter((p) => !!p));
+  const left = installedPlugins().filter((p) => p.agent === "claude-code" && p.id === id && p.projectPath && !switched.has(p.projectPath) && p.on !== false);
+  return left.length ? `Still on in ${left.map((p) => `${basename11(p.projectPath)} (${p.scope})`).join(", ")}.` : "";
+}
 function show(args) {
   const name = args.positional[0];
-  const dir = name ? join15(libraryDir(), name) : "";
+  const dir = name ? join17(libraryDir(), name) : "";
   if (!name || !isSkillDir(dir)) {
     throw new Error(name ? `${name} is not in the library` : "Usage: skilllib show <skill-name>");
   }
@@ -4278,8 +4909,8 @@ function show(args) {
       path: dir,
       latest: latestVersion(name)?.version ?? null,
       origin: libraryOrigins()[name] ?? "",
-      projects: projectsUsing(name).map((p) => basename10(p)),
-      skillMd: readFileSync7(join15(dir, "SKILL.md"), "utf-8")
+      projects: projectsUsing(name).map((p) => basename11(p)),
+      skillMd: readFileSync7(join17(dir, "SKILL.md"), "utf-8")
     });
   }
   info(`${name} ${dim(tildify(dir))}`);
@@ -4301,7 +4932,7 @@ function harnessesCommand(args) {
   }
   const enabled = enabledHarnesses();
   for (const h of HARNESSES) {
-    info(`${enabled.includes(h.id) ? green("\u25C9") : dim("\u25CB")} ${h.name.padEnd(12)} ${dim(`reads ${h.projectDirs.join(", ")}${h.installed() ? " \xB7 detected" : ""}`)}`);
+    info(`${enabled.includes(h.id) ? green("\u25C9") : dim("\u25CB")} ${h.name.padEnd(18)} ${dim(`reads ${h.projectDirs.join(", ")}${h.installed() ? " \xB7 detected" : ""}`)}`);
   }
   info(dim(`
 New installs go to ${installDirs(enabled).join(" (real copy) + ")}${installDirs(enabled).length > 1 ? " (link)" : ""}.`));
@@ -4310,7 +4941,7 @@ function link(args) {
   const roots = projectsFor(args);
   for (const root of roots) {
     const res = linkAll(root, { allowTracked: args.allowTracked });
-    const label = args.all ? `${basename10(root)}: ` : "";
+    const label = args.all ? `${basename11(root)}: ` : "";
     if (res.linked.length) success(`${label}linked ${res.linked.length} skill(s) for your other agents`);
     else if (!args.all && !res.blocked.length && !res.uncommitted.length && !res.inTheWay.length) {
       const missing = projectStatus(root).filter((s) => s.state === "folder missing").map((s) => s.name);
@@ -4356,11 +4987,11 @@ ${unreviewed} not reviewed. Keep one global on purpose: skilllib global keep <na
 }
 function repoRoot(repo) {
   const looksLikePath = /[\\/]/.test(repo) || repo.startsWith(".") || repo.startsWith("~");
-  const named = looksLikePath ? [] : visibleProjects().filter((p) => basename10(p) === repo);
+  const named = looksLikePath ? [] : visibleProjects().filter((p) => basename11(p) === repo);
   if (named.length === 1) return named[0];
   if (named.length > 1) throw new Error(`Several projects are named ${repo}: ${named.map(tildify).join(", ")}. Pass its path.`);
   const path = expandHome(repo);
-  if (!existsSync14(path)) throw new Error(`No project ${repo} (pass its path, or see skilllib projects)`);
+  if (!existsSync15(path)) throw new Error(`No project ${repo} (pass its path, or see skilllib projects)`);
   const root = projectHere(path);
   if (root !== path) throw new Error(root ? `${tildify(path)} is inside ${tildify(root)}: pass the repo's top folder` : `${tildify(path)} isn't in a git repo`);
   return root;
@@ -4382,22 +5013,22 @@ function moveGlobal(args, names, yours) {
         moved,
         ...reason ? { reason } : {},
         ...left ? { left } : {},
-        projects: changes.map(([root, c]) => ({ project: basename10(root), path: root, change: withDirs(root, [c])[0] }))
+        projects: changes.map(([root, c]) => ({ project: basename11(root), path: root, change: withDirs(root, [c])[0] }))
       }))
     );
   }
   for (const m of moves) {
-    if (m.moved) success(`${m.name} now loads only in ${m.changes.map(([r]) => basename10(r)).join(", ")} (the global copy is in skilllib restore)`);
+    if (m.moved) success(`${m.name} now loads only in ${m.changes.map(([r]) => basename11(r)).join(", ")} (the global copy is in skilllib restore)`);
     else error(`${m.name}: ${m.reason}`);
-    for (const [root, c] of m.changes) warnHeldLinks(root, c, `in ${basename10(root)}`);
+    for (const [root, c] of m.changes) warnHeldLinks(root, c, `in ${basename11(root)}`);
     if (m.left) warn(`${m.name}: ${m.left.join(", ")} now point${m.left.length === 1 ? "s" : ""} at nothing (the repo's own copy serves that package): remove ${m.left.length === 1 ? "it" : "them"}`);
   }
   const toCommit = [...new Set(moves.filter((m) => m.moved).flatMap((m) => m.changes.filter(([r]) => pinsIn(r)[m.name] && !pinsIn(r)[m.name].personal).map(([r]) => r)))];
-  if (toCommit.length) info(dim(`Commit skilllib.json and the skill folders in ${toCommit.map((r) => basename10(r)).join(", ")}.`));
+  if (toCommit.length) info(dim(`Commit skilllib.json and the skill folders in ${toCommit.map((r) => basename11(r)).join(", ")}.`));
 }
 function tidy(args) {
   const names = args.positional;
-  const keepFor = (base) => args.keep ? Object.fromEntries(names.map((n) => [n, base ? resolve8(base, args.keep) : expandHome(args.keep)])) : {};
+  const keepFor = (base) => args.keep ? Object.fromEntries(names.map((n) => [n, base ? resolve9(base, args.keep) : expandHome(args.keep)])) : {};
   if (args.keep && !names.length) {
     throw new Error("Usage: skilllib tidy <name>... --keep <folder>");
   }
@@ -4406,13 +5037,13 @@ function tidy(args) {
   for (const name of names) {
     const where = targets.map((root) => ({ root, ...foldersOf(root, name) })).filter((w) => w.all.length);
     if (!where.length) {
-      problems.push(`${name}: no skill by that name ${args.global ? "in your global folders" : args.all ? "in your projects" : `in ${basename10(targets[0])}`}`);
+      problems.push(`${name}: no skill by that name ${args.global ? "in your global folders" : args.all ? "in your projects" : `in ${basename11(targets[0])}`}`);
       continue;
     }
     if (!args.keep) continue;
     for (const { root, real } of where) {
       if (real.includes(keepFor(root)[name])) continue;
-      const label = root ? `${basename10(root)} \xB7 ` : "";
+      const label = root ? `${basename11(root)} \xB7 ` : "";
       problems.push(
         `${label}${name}: no copy in ${args.keep}; ${real.length ? `pick one of: ${real.map((d) => folderLabel(root, d)).join(", ")}` : "it has no real copy to keep"}`
       );
@@ -4422,7 +5053,7 @@ function tidy(args) {
     throw new Error(problems.join("\n"));
   }
   const reports = targets.map(
-    (root) => root === null ? { label: "global folders", report: planGlobalTidy({ keep: keepFor(null) }) } : { label: basename10(root), report: planProjectTidy(root, { keep: keepFor(root) }) }
+    (root) => root === null ? { label: "global folders", report: planGlobalTidy({ keep: keepFor(null) }) } : { label: basename11(root), report: planProjectTidy(root, { keep: keepFor(root) }) }
   );
   let held = 0;
   let changed = 0;
@@ -4454,7 +5085,7 @@ function tidy(args) {
   }
   if (args.dryRun) info(dim("\nNothing changed (--dry-run)."));
   else if (changed) info(dim(`
-Replaced copies are in ${tildify(join15(skilllibHome(), "tidy-backup"))}; \`skilllib restore\` puts them back.`));
+Replaced copies are in ${tildify(join17(skilllibHome(), "tidy-backup"))}; \`skilllib restore\` puts them back.`));
   if (held) {
     process.exitCode = 1;
     info(dim(`${held} change${held === 1 ? "" : "s"} held back because git would see them. Re-run with --allow-git to make them.`));
@@ -4485,11 +5116,108 @@ function agentSkill(args) {
   else if (state === "outdated") warn("The skilllib skill is out of date. Run `skilllib agent-skill install` to update it.");
   else info("Your agents don't know about skilllib yet. Run `skilllib agent-skill install` so you can ask them about your skills.");
 }
+function installsOf(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1).replace(/\.0$/, "")}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1).replace(/\.0$/, "")}K`;
+  return String(n);
+}
+async function search(args) {
+  const query = args.positional.join(" ").trim();
+  if (!query) throw new Error("Usage: skilllib search <query>");
+  const hits = await searchSkills(query);
+  if (args.json) return json("search", hits);
+  if (!hits.length) return info(`No skills on skills.sh for \u201C${query}\u201D.`);
+  table(hits.map((h) => ({ Skill: h.name, Source: h.source, Installs: dim(installsOf(h.installs)) })));
+  info(dim("\nInstall one: skilllib install <source>   e.g. skilllib install owner/repo@skill"));
+}
+async function install(args) {
+  if (!args.positional.length) {
+    throw new Error("Usage: skilllib install <owner/repo[@skill] | url | folder>... [--global] [--all] [--force]\nSearch first: skilllib search <query>");
+  }
+  const results = [];
+  for (const input of args.positional) {
+    const spec = parseInstallSpec(input);
+    if (!spec) {
+      const hits = await searchSkills(input).catch(() => []);
+      const exact = hits.filter((h) => h.skillId === input || h.name === input);
+      const pick = exact.length === 1 ? exact[0] : hits.length === 1 ? hits[0] : void 0;
+      if (!pick || !pick.source.includes("/")) {
+        process.exitCode = 1;
+        if (args.json) results.push({ name: input, source: input, status: "skipped", reason: hits.length ? `several matches: ${hits.slice(0, 8).map((h) => `${h.source}@${h.skillId}`).join(", ")}` : "not a GitHub repo, skills.sh URL, or folder" });
+        else if (hits.length) {
+          warn(`\u201C${input}\u201D matches several skills. Pass one of these:`);
+          for (const h of hits.slice(0, 8)) info(`  skilllib install ${h.source}@${h.skillId} ${dim(installsOf(h.installs))}`);
+        } else error(`${input}: not a GitHub repo, skills.sh URL, or folder. Try skilllib search ${input}`);
+        continue;
+      }
+      args.positional.push(`${pick.source}@${pick.skillId}`);
+      continue;
+    }
+    let resolved;
+    try {
+      resolved = await resolveInstallDir(spec);
+    } catch (err) {
+      process.exitCode = 1;
+      const reason = err instanceof Error ? err.message : String(err);
+      if (args.json) results.push({ name: input, source: input, status: "skipped", reason });
+      else error(reason);
+      continue;
+    }
+    try {
+      if (!resolved.dirs.length) {
+        process.exitCode = 1;
+        const reason = "skill" in spec && spec.skill ? `no skill named ${spec.skill} in ${spec.owner}/${spec.repo}` : "no SKILL.md found";
+        if (args.json) results.push({ name: input, source: resolved.source, status: "skipped", reason });
+        else error(`${resolved.source}: ${reason}`);
+        continue;
+      }
+      if (resolved.many && !args.all) {
+        process.exitCode = 1;
+        const names = resolved.dirs.map((d) => basename11(d));
+        const reason = `${names.length} skills. Pass @name, or --all. ${names.slice(0, 12).join(", ")}`;
+        if (args.json) results.push({ name: input, source: resolved.source, status: "skipped", reason });
+        else {
+          warn(`${resolved.source} has ${names.length} skills. Install one, or all of them:`);
+          const base = "owner" in spec ? `${spec.owner}/${spec.repo}` : resolved.source;
+          for (const name of names.slice(0, 12)) info(`  skilllib install ${base}@${name}`);
+          if (names.length > 12) info(dim(`  \u2026 and ${names.length - 12} more`));
+          info(dim(`  skilllib install ${base} --all`));
+        }
+        continue;
+      }
+      const installed = installFound(resolved.dirs, "owner" in spec ? `${spec.owner}/${spec.repo}` : resolved.source, {
+        force: args.force,
+        global: args.global,
+        allowTracked: args.allowTracked
+      });
+      results.push(...installed);
+      if (!args.json) {
+        for (const row of installed) {
+          if (row.status === "exists" || row.status === "skipped") {
+            process.exitCode = 1;
+            warn(`${row.name}: ${row.reason}`);
+          } else {
+            const where = row.global ? `global ${row.global.map((d) => tildify(d)).join(", ")}` : row.project ? `this project (${row.project.action})` : "your library";
+            success(`${row.name} ${row.status === "unchanged" ? "already in your library" : "installed"} \u2192 ${where}`);
+          }
+        }
+        if (!args.global && !projectHere() && installed.some((r) => r.status !== "exists" && r.status !== "skipped")) {
+          info(dim("Not in a project, so nothing was added here. In a repo: skilllib add <name>. Everywhere: skilllib install <source> --global"));
+        }
+      }
+    } finally {
+      if (resolved.tmp) rmSync8(resolved.tmp, { recursive: true, force: true });
+    }
+  }
+  if (args.json) json("install", results);
+  else if (results.some((r) => r.project && r.project.action !== "skipped")) info(dim("Commit skilllib.json and the skill folders."));
+}
 
 export {
   realPath,
   skilllibHome,
   PROJECT_SKILLS_DIR,
+  FEATURED_HARNESSES,
   HARNESSES,
   harness,
   installDirs,
@@ -4600,10 +5328,14 @@ export {
   doctor,
   apply,
   usage,
+  check,
+  pluginCommand,
   show,
   harnessesCommand,
   link,
   globalCommand,
   tidy,
-  agentSkill
+  agentSkill,
+  search,
+  install
 };