skilllib 1.6.0 → 1.10.0

package/dist/{chunk-PHRUPZGX.js → chunk-Z2F5W3DY.js}

@@ -1,11 +1,53 @@
 // src/output.ts
-import { sep } from "path";
+import { resolve as resolve2, sep } from "path";
+
+// src/paths.ts
+import { realpathSync } from "fs";
 import { homedir } from "os";
+import { join, resolve } from "path";
+function userHome() {
+  return process.env.HOME || homedir();
+}
+function realPath(path) {
+  try {
+    return realpathSync(resolve(path));
+  } catch {
+    return resolve(path);
+  }
+}
+function skilllibHome() {
+  return process.env.SKILLLIB_HOME ?? join(userHome(), ".skilllib");
+}
+function libraryDir() {
+  return join(skilllibHome(), "library");
+}
+function claudeDir() {
+  return process.env.CLAUDE_CONFIG_DIR ?? join(userHome(), ".claude");
+}
+function grokDir() {
+  return process.env.GROK_HOME?.trim() || join(userHome(), ".grok");
+}
+function codexHome() {
+  return process.env.CODEX_HOME?.trim() || join(userHome(), ".codex");
+}
+function codexSystemDir() {
+  return process.env.SKILLLIB_CODEX_SYSTEM_DIR ?? "/etc/codex/skills";
+}
+var PROJECT_SKILLS_DIR = ".claude/skills";
+var AGENTS_SKILLS_DIR = ".agents/skills";
+var GROK_SKILLS_DIR = ".grok/skills";
+var MANIFEST_FILE = "skilllib.json";
+function isRepoSkillLocation(location) {
+  return location === AGENTS_SKILLS_DIR || location === GROK_SKILLS_DIR;
+}
+var OWN_SKILL_MARKER = ".managed-by-skilllib";
+
+// src/output.ts
 var jsonMode = false;
 function setJsonMode(on) {
   jsonMode = on;
 }
-function json(data) {
+function json(output, data) {
   process.stdout.write(JSON.stringify(data) + "\n");
 }
 var color = (code) => (s) => process.stdout.isTTY && !jsonMode ? `\x1B[${code}m${s}\x1B[0m` : s;
@@ -19,8 +61,9 @@ var success = (msg) => out(`${green("\u2713")} ${msg}`);
 var warn = (msg) => out(`${yellow("!")} ${msg}`);
 var error = (msg) => console.error(`${red("\u2717")} ${msg}`);
 function tildify(path) {
-  const home2 = homedir();
-  return path === home2 || path.startsWith(home2 + sep) ? "~" + path.slice(home2.length) : path;
+  for (const home2 of /* @__PURE__ */ new Set([resolve2(userHome()), realPath(userHome())]))
+    if (path === home2 || path.startsWith(home2 + sep)) return ("~" + path.slice(home2.length)).replace(/\\/g, "/");
+  return path;
 }
 function truncate(s, max) {
   const line = s.replace(/\s+/g, " ");
@@ -41,35 +84,9 @@ import { existsSync as existsSync8, lstatSync as lstatSync3, mkdirSync as mkdirS
 import { join as join9 } from "path";
 
 // src/config.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join6, resolve as resolve2 } from "path";
-
-// src/paths.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join } from "path";
-function userHome() {
-  return process.env.HOME || homedir2();
-}
-function skilllibHome() {
-  return process.env.SKILLLIB_HOME ?? join(userHome(), ".skilllib");
-}
-function libraryDir() {
-  return join(skilllibHome(), "library");
-}
-function claudeDir() {
-  return process.env.CLAUDE_CONFIG_DIR ?? join(userHome(), ".claude");
-}
-function codexHome() {
-  return process.env.CODEX_HOME?.trim() || join(userHome(), ".codex");
-}
-function codexSystemDir() {
-  return process.env.SKILLLIB_CODEX_SYSTEM_DIR ?? "/etc/codex/skills";
-}
-var PROJECT_SKILLS_DIR = ".claude/skills";
-var AGENTS_SKILLS_DIR = ".agents/skills";
-var MANIFEST_FILE = "skilllib.json";
-var OWN_SKILL_MARKER = ".managed-by-skilllib";
+import { join as join6, resolve as resolve4 } from "path";
 
 // src/harnesses.ts
 import { existsSync } from "fs";
@@ -93,7 +110,7 @@ var HARNESSES = [
     icon: "\u2B21",
     color: "#E8E8E8",
     // The first folder is where links for Cursor go (see linkEverywhere). Cursor also reads .grok/skills;
-    // skilllib leaves that folder to Grok, since it can't tell what Grok needs.
+    // skilllib leaves that folder alone (see Grok). A .grok-only skill stays invisible to Cursor here.
     projectDirs: [".agents/skills", ".cursor/skills", ".claude/skills", ".codex/skills"],
     // Cursor ignores CLAUDE_CONFIG_DIR and CODEX_HOME: it always reads these under your home folder.
     globalDirs: () => [".agents", ".cursor", ".claude", ".codex"].map((d) => join2(home(), d, "skills")),
@@ -118,6 +135,19 @@ var HARNESSES = [
     projectDirs: [".agents/skills"],
     globalDirs: () => [join2(home(), ".agents", "skills")],
     installed: () => existsSync(join2(home(), ".config", "zed")) || onPath("zed") || hasApp("Zed")
+  },
+  {
+    id: "grok",
+    name: "Grok",
+    short: "Gk",
+    icon: "\u2736",
+    color: "#F5C16C",
+    // .agents/skills is first so a skill Grok can't already see is linked into the shared folder, not .grok/skills.
+    projectDirs: [".agents/skills", ".grok/skills", ".claude/skills", ".cursor/skills"],
+    // Grok ignores CLAUDE_CONFIG_DIR: the Claude compat path is always ~/.claude/skills.
+    // 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")
   }
 ];
 function onPath(bin) {
@@ -155,8 +185,7 @@ function installDirs(enabled, keep) {
 
 // src/project.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname, join as join5, resolve } from "path";
+import { dirname, join as join5, resolve as resolve3 } from "path";
 
 // src/versions.ts
 import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
@@ -164,7 +193,7 @@ import { join as join4 } from "path";
 
 // src/skills.ts
 import { createHash } from "crypto";
-import { cpSync, existsSync as existsSync2, readdirSync, readFileSync, realpathSync, rmSync, statSync } from "fs";
+import { cpSync, existsSync as existsSync2, readdirSync, readFileSync, realpathSync as realpathSync2, rmSync, statSync } from "fs";
 import { basename, join as join3, relative, sep as sep2 } from "path";
 import { parse as parseYaml } from "yaml";
 var IGNORED = /* @__PURE__ */ new Set([".DS_Store", ".git", "node_modules"]);
@@ -204,7 +233,7 @@ function treeHash(dir) {
 }
 function copySkill(from, to) {
   rmSync(to, { recursive: true, force: true });
-  cpSync(realpathSync(from), to, { recursive: true, dereference: true, filter: (src) => !IGNORED.has(basename(src)) });
+  cpSync(realpathSync2(from), to, { recursive: true, dereference: true, filter: (src) => !IGNORED.has(basename(src)) });
 }
 function skillDirsIn(dir) {
   if (!existsSync2(dir)) return [];
@@ -263,19 +292,17 @@ function getVersion(name, version) {
 
 // src/project.ts
 function findProjectRoot(from = process.cwd()) {
-  let dir = resolve(from);
+  let dir = resolve3(from);
   while (true) {
     if (existsSync4(join5(dir, MANIFEST_FILE)) || existsSync4(join5(dir, ".git"))) return dir;
     const parent = dirname(dir);
-    if (parent === dir) return resolve(from);
+    if (parent === dir) return resolve3(from);
     dir = parent;
   }
 }
-function projectSkillsDir(root) {
-  return join5(root, PROJECT_SKILLS_DIR);
-}
-function agentsSkillsDir(root) {
-  return join5(root, AGENTS_SKILLS_DIR);
+function projectHere(from = process.cwd()) {
+  const root = findProjectRoot(from);
+  return isProjectCandidate(root) && (existsSync4(join5(root, ".git")) || existsSync4(join5(root, MANIFEST_FILE))) ? root : null;
 }
 function readManifest(root) {
   const path = join5(root, MANIFEST_FILE);
@@ -315,14 +342,23 @@ function knownProjects() {
   const path = projectsFile();
   if (!existsSync4(path)) return [];
   const list2 = JSON.parse(readFileSync3(path, "utf-8"));
-  return list2.filter((p) => existsSync4(p) && isProjectCandidate(p));
+  return onePerFolder(list2.filter((p) => existsSync4(p) && isProjectCandidate(p)));
+}
+function onePerFolder(paths) {
+  const byReal = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const real = realPath(p);
+    const seen = byReal.get(real);
+    if (seen === void 0 || seen === real && p !== real) byReal.set(real, p);
+  }
+  return [...new Set(byReal.values())];
 }
 function isProjectCandidate(root) {
-  return resolve(root) !== homedir3();
+  return realPath(root) !== realPath(userHome());
 }
 function rememberProjects(roots) {
-  const incoming = roots.map((r) => resolve(r)).filter(isProjectCandidate);
-  const all = [.../* @__PURE__ */ new Set([...knownProjects(), ...incoming])].sort();
+  const incoming = roots.map((r) => resolve3(r)).filter(isProjectCandidate);
+  const all = onePerFolder([...knownProjects(), ...incoming]).sort();
   mkdirSync2(skilllibHome(), { recursive: true });
   writeFileSync2(projectsFile(), JSON.stringify(all, null, 2) + "\n");
 }
@@ -344,10 +380,12 @@ function writeConfig(config) {
   writeFileSync3(configFile(), JSON.stringify(config, null, 2) + "\n");
 }
 function expandHome(path) {
-  return resolve2(path.replace(/^~(?=$|\/)/, homedir4()));
+  return resolve4(path.replace(/^~(?=$|\/)/, homedir2()));
 }
 function addRoot(path) {
   const root = expandHome(path);
+  if (!existsSync5(root)) throw new Error(`${tildify(root)} doesn't exist`);
+  if (!statSync2(root).isDirectory()) throw new Error(`${tildify(root)} isn't a folder`);
   const config = readConfig();
   if (!config.roots.includes(root)) writeConfig({ ...config, roots: [...config.roots, root].sort() });
   return root;
@@ -361,8 +399,10 @@ function removeRoot(path) {
 }
 function setHidden(project, hidden) {
   const config = readConfig();
+  if (config.hidden.includes(project) === hidden) return false;
   const rest = config.hidden.filter((h) => h !== project);
   writeConfig({ ...config, hidden: hidden ? [...rest, project].sort() : rest });
+  return true;
 }
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "vendor", "target", "Library", "Applications", "Pictures", "Music", "Movies"]);
 function findProjects(dir, depth = 4) {
@@ -386,8 +426,8 @@ function discoverProjects() {
   return visibleProjects();
 }
 function visibleProjects() {
-  const hidden = new Set(readConfig().hidden);
-  return knownProjects().filter((p) => !hidden.has(p));
+  const hidden = new Set(readConfig().hidden.map(realPath));
+  return knownProjects().filter((p) => !hidden.has(realPath(p)));
 }
 function enabledHarnesses() {
   return readConfig().harnesses ?? HARNESSES.filter((h) => h.installed()).map((h) => h.id);
@@ -418,12 +458,12 @@ function setKeepGlobal(names, keep) {
 
 // src/library.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync7, lstatSync as lstatSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync4, readFileSync as readFileSync6, realpathSync as realpathSync3, renameSync, rmSync as rmSync2, symlinkSync, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync7, lstatSync as lstatSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync4, readFileSync as readFileSync6, realpathSync as realpathSync4, renameSync, rmSync as rmSync2, symlinkSync, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
 import { basename as basename3, dirname as dirname2, join as join8, relative as relative2, sep as sep3 } from "path";
 
 // src/sources.ts
-import { existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, readlinkSync, realpathSync as realpathSync2, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename2, join as join7, resolve as resolve3 } from "path";
+import { existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, readlinkSync, realpathSync as realpathSync3, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename2, join as join7, resolve as resolve5 } from "path";
 function readJson(path) {
   try {
     return JSON.parse(readFileSync5(path, "utf-8"));
@@ -432,24 +472,36 @@ function readJson(path) {
   }
 }
 function skillsShLock() {
-  return readJson(join7(resolve3(claudeDir(), ".."), ".agents", ".skill-lock.json"))?.skills ?? {};
+  return readJson(join7(userHome(), ".agents", ".skill-lock.json"))?.skills ?? {};
 }
 function projectSkillsLock(root) {
   return readJson(join7(root, "skills-lock.json"))?.skills ?? {};
 }
 function realpathOrNull(path) {
   try {
-    return realpathSync2(path);
+    return realpathSync3(path);
   } catch {
     return null;
   }
 }
 function harnessesReading(dir, enabled) {
-  return enabled.filter((id) => HARNESSES.find((h) => h.id === id)?.globalDirs().includes(dir));
+  const real = realPath(dir);
+  return enabled.filter((id) => HARNESSES.find((h) => h.id === id)?.globalDirs().some((d) => realPath(d) === real));
 }
 var systemDirs = () => [codexSystemDir()];
 function globalSkillDirs() {
-  return [...new Set(HARNESSES.flatMap((h) => h.globalDirs()))].filter((d) => !systemDirs().includes(d));
+  const seen = /* @__PURE__ */ new Set();
+  return [...new Set(HARNESSES.flatMap((h) => h.globalDirs()))].filter((d) => {
+    if (systemDirs().includes(d)) return false;
+    const real = realPath(d);
+    if (seen.has(real)) return false;
+    seen.add(real);
+    return true;
+  });
+}
+function globalDirAs(dir) {
+  const real = realPath(dir);
+  return globalSkillDirs().find((d) => realPath(d) === real) ?? dir;
 }
 function systemSkills(enabled) {
   return systemDirs().flatMap(
@@ -492,7 +544,7 @@ function globalFolderSkills(enabled) {
     const inAgents = e.dir === agentsDir || target_.includes(".agents/skills");
     const locked = lock[e.name]?.source;
     if (existsSync6(join7(e.path, OWN_SKILL_MARKER))) {
-      skills.push({ name: e.name, kind: "built-in", origin: "skilllib", path: e.path, description: readSkillInfo(e.path).description, movable: false, broken: false, harnesses: harnessesReading(e.dir, enabled), links: [] });
+      skills.push({ name: e.name, kind: "skilllib", origin: "skilllib", path: e.path, description: readSkillInfo(e.path).description, movable: false, broken: false, harnesses: harnessesReading(e.dir, enabled), links: [] });
       continue;
     }
     skills.push({
@@ -516,8 +568,21 @@ function globalFolderSkills(enabled) {
   return skills;
 }
 function tildify2(p) {
-  const shown = p.startsWith(userHome()) ? "~" + p.slice(userHome().length) : p;
-  return shown.replace(/\\/g, "/");
+  return tildify(p).replace(/\\/g, "/");
+}
+function grokBuiltInSkills(enabled) {
+  if (!enabled.includes("grok")) return [];
+  return skillDirsIn(join7(grokDir(), "bundled", "skills")).map((path) => ({
+    name: basename2(path),
+    kind: "built-in",
+    origin: "Grok",
+    path,
+    description: readSkillInfo(path).description,
+    movable: false,
+    broken: false,
+    harnesses: ["grok"],
+    links: []
+  }));
 }
 function cursorBuiltInSkills(enabled) {
   if (!enabled.includes("cursor")) return [];
@@ -534,30 +599,41 @@ function cursorBuiltInSkills(enabled) {
   }));
 }
 function claudeAiSkills(enabled) {
-  const synced = join7(claudeDir(), "skills", "synced");
-  const harnesses = harnessesReading(join7(claudeDir(), "skills"), enabled);
-  if (!existsSync6(synced) || harnesses.length === 0) return [];
-  return readdirSync3(synced).filter((d) => !d.startsWith(".")).flatMap(
-    (bucket) => skillDirsIn(join7(synced, bucket)).map((path) => ({
-      name: basename2(path),
-      kind: "claude.ai",
-      origin: "claude.ai account",
-      path,
-      description: readSkillInfo(path).description,
-      movable: false,
-      broken: false,
-      harnesses,
-      links: []
-    }))
+  const byReal = /* @__PURE__ */ new Map();
+  for (const skills of [join7(claudeDir(), "skills"), join7(userHome(), ".claude", "skills")]) {
+    const synced = join7(skills, "synced");
+    const real = realpathOrNull(synced);
+    const readers = harnessesReading(skills, enabled);
+    if (!real || readers.length === 0) continue;
+    const entry = byReal.get(real) ?? { dir: synced, readers: [] };
+    for (const id of readers) if (!entry.readers.includes(id)) entry.readers.push(id);
+    byReal.set(real, entry);
+  }
+  return [...byReal.values()].flatMap(
+    ({ dir, readers }) => readdirSync3(dir).filter((d) => !d.startsWith(".")).flatMap(
+      (bucket) => skillDirsIn(join7(dir, bucket)).map((path) => ({
+        name: basename2(path),
+        kind: "claude.ai",
+        origin: "claude.ai account",
+        path,
+        description: readSkillInfo(path).description,
+        movable: false,
+        broken: false,
+        harnesses: enabled.filter((id) => readers.includes(id)),
+        links: []
+      }))
+    )
   );
 }
-function setPluginEnabled(id, on) {
-  const file = join7(claudeDir(), "settings.json");
-  const settings = existsSync6(file) ? readJson(file) : {};
-  if (!settings) throw new Error(`${file} isn't valid JSON, so skilllib won't rewrite it`);
-  settings.enabledPlugins = { ...settings.enabledPlugins, [id]: on };
-  mkdirSync4(claudeDir(), { recursive: true });
-  writeFileSync4(file, JSON.stringify(settings, null, 2) + "\n");
+function pluginDirCandidates(id, installPaths) {
+  const [name = "", marketplace = ""] = id.split("@");
+  const plugins = join7(claudeDir(), "plugins");
+  return [
+    ...installPaths,
+    join7(plugins, "marketplaces", marketplace, "plugins", name),
+    join7(plugins, "marketplaces", marketplace, "external_plugins", name),
+    join7(plugins, "marketplaces", marketplace)
+  ];
 }
 function repoSettingsFiles(root) {
   return [join7(root, ".claude", "settings.json"), join7(root, ".claude", "settings.local.json")];
@@ -575,13 +651,7 @@ function pluginSkills(harnesses, root) {
   const user = enabledPlugins();
   const enabled = root ? enabledPlugins(root) : user;
   const fromMarketplaces = [.../* @__PURE__ */ new Set([...Object.keys(enabled), ...Object.keys(user)])].filter((id) => claude2 && enabled[id] || cursor && user[id]).flatMap((id) => {
-    const [name = "", marketplace = ""] = id.split("@");
-    const candidates = [
-      ...(installed[id] ?? []).flatMap((i) => i.installPath ? [i.installPath] : []),
-      join7(plugins, "marketplaces", marketplace, "plugins", name),
-      join7(plugins, "marketplaces", marketplace, "external_plugins", name),
-      join7(plugins, "marketplaces", marketplace)
-    ];
+    const candidates = pluginDirCandidates(id, (installed[id] ?? []).flatMap((i) => i.installPath ? [i.installPath] : []));
     const dir = candidates.find((c) => existsSync6(join7(c, "skills")));
     if (!dir) return [];
     const inCursor = cursor && user[id] && (installed[id] ?? []).some((i) => i.scope === "user" && i.installPath === dir);
@@ -616,6 +686,7 @@ function machineSkills(enabled = enabledHarnesses()) {
     ...claudeAiSkills(enabled),
     ...pluginSkills(enabled),
     ...cursorBuiltInSkills(enabled),
+    ...grokBuiltInSkills(enabled),
     ...systemSkills(enabled)
   ].sort(byKindAndName);
 }
@@ -637,9 +708,9 @@ function recordOrigin(name, origin) {
   writeFileSync4(originsFile(), JSON.stringify({ ...origins, [name]: origin }, null, 2) + "\n");
 }
 function originFor(dir) {
-  const match = machineSkills().find((s) => resolve3(s.path) === resolve3(dir));
+  const match = machineSkills().find((s) => resolve5(s.path) === resolve5(dir));
   if (match) return match.kind === "global" ? "global folder" : `${match.kind}: ${match.origin}`;
-  const project = dir.split(/[\\/]\.(?:claude|agents)[\\/]skills[\\/]/)[0];
+  const project = dir.split(/[\\/]\.(?:claude|agents|grok|cursor|codex)[\\/]skills[\\/]/)[0];
   if (!project || project === dir) return dir;
   const locked = projectSkillsLock(project)[basename2(dir)]?.source;
   return locked ? `skills.sh: ${locked}` : `project: ${basename2(project)}`;
@@ -658,7 +729,7 @@ function librarySkillDir(name) {
 }
 function realpathOrNull2(path) {
   try {
-    return realpathSync3(path);
+    return realpathSync4(path);
   } catch {
     return null;
   }
@@ -685,7 +756,7 @@ function visibilityOf(root, name, enabled = enabledHarnesses()) {
 }
 function dependencyDirs(root, name, dep) {
   const wanted = installDirs(enabledHarnesses());
-  const untracked = ALL_PROJECT_DIRS.find((d) => existsSync7(join8(root, d, name, "SKILL.md")) && !isLink(join8(root, d, name)));
+  const untracked = ALL_PROJECT_DIRS.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 ?? wanted[0];
   return [primary, .../* @__PURE__ */ new Set([...dep?.links ?? [], ...wanted.filter((d) => d !== primary)])];
 }
@@ -737,7 +808,7 @@ function projectStatus(root) {
     unmanaged.push({
       name,
       managed: false,
-      state: unmanagedState(name, real, location === AGENTS_SKILLS_DIR, source),
+      state: unmanagedState(name, real, isRepoSkillLocation(location), source),
       version: null,
       latest: latestVersion(name)?.version ?? null,
       location,
@@ -757,10 +828,12 @@ function unmanagedState(name, real, committed, source) {
   return latest === null ? "local only" : sameAsLibrary ? "untracked copy of library skill" : "untracked, differs from library";
 }
 var NESTED_READERS = [
-  [PROJECT_SKILLS_DIR, ["claude-code", "cursor"]],
-  [AGENTS_SKILLS_DIR, ["codex", "cursor"]],
-  [".cursor/skills", ["cursor"]],
-  [".codex/skills", ["codex", "cursor"]]
+  [PROJECT_SKILLS_DIR, ["claude-code", "cursor", "grok"]],
+  [AGENTS_SKILLS_DIR, ["codex", "cursor", "grok"]],
+  [".cursor/skills", ["cursor", "grok"]],
+  [".codex/skills", ["codex", "cursor"]],
+  // Cursor reads nested .grok/skills too, but skilllib doesn't count it: that folder stays Grok's.
+  [".grok/skills", ["grok"]]
 ];
 var NESTED_SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "vendor", "target", "coverage"]);
 function nestedSkills(root, { depth = 3, enabled = enabledHarnesses() } = {}) {
@@ -782,7 +855,7 @@ function nestedSkills(root, { depth = 3, enabled = enabledHarnesses() } = {}) {
           found.push({
             name,
             managed: false,
-            state: unmanagedState(name, path, skillsDir === AGENTS_SKILLS_DIR, void 0),
+            state: unmanagedState(name, path, isRepoSkillLocation(skillsDir), void 0),
             version: null,
             latest: latestVersion(name)?.version ?? null,
             location,
@@ -797,28 +870,53 @@ function nestedSkills(root, { depth = 3, enabled = enabledHarnesses() } = {}) {
   walk(root, depth);
   return found.sort((a, b) => a.location.localeCompare(b.location) || a.name.localeCompare(b.name));
 }
-function linkEverywhere(root, name, location, { allowTracked = false } = {}) {
+function sharedByGit(root, location, name) {
+  const copy = `${location}/${name}`;
+  if (isGitTracked(root, copy)) return true;
+  if (!isGitTracked(root, location)) return false;
+  try {
+    execFileSync("git", ["check-ignore", "-q", "--no-index", "--", copy], { cwd: root, stdio: "ignore" });
+    return false;
+  } catch {
+    return true;
+  }
+}
+function linkEverywhere(root, name, location, { allowTracked = false, dryRun = false } = {}) {
   const enabled = enabledHarnesses();
-  const result = { created: [], blocked: [] };
+  const result = { created: [], blocked: [], uncommitted: [] };
+  let shared;
   for (const id of enabled) {
     if (visibilityOf(root, name, [id])[0].paths > 0) continue;
     const dir = harness(id).projectDirs[0];
     const link2 = join8(root, dir, name);
-    if (entryExists(link2)) continue;
-    if (!allowTracked && isGitTracked(root, dir) && !readConfig().agentsDirOk?.includes(root)) {
-      result.blocked.push(dir);
-      continue;
+    if (entryExists(link2) || Object.values(result).some((dirs) => dirs.includes(dir))) continue;
+    if (isGitTracked(root, dir)) {
+      if (!(shared ??= sharedByGit(root, location, name))) {
+        if (!result.uncommitted.includes(dir)) result.uncommitted.push(dir);
+        continue;
+      }
+      if (!allowTracked && !readConfig().agentsDirOk?.includes(root)) {
+        if (!result.blocked.includes(dir)) result.blocked.push(dir);
+        continue;
+      }
+    }
+    if (!dryRun) {
+      mkdirSync5(join8(root, dir), { recursive: true });
+      linkDir(join8(root, location, name), link2);
     }
-    mkdirSync5(join8(root, dir), { recursive: true });
-    linkDir(join8(root, location, name), link2);
     result.created.push(dir);
   }
   return result;
 }
-function unlinkEverywhere(root, name) {
+function unlinkEverywhere(root, name, removing) {
+  const gone = removing ? realpathOrNull2(removing) : null;
   return ALL_PROJECT_DIRS.filter((dir) => {
     const link2 = join8(root, dir, name);
     if (!isLink(link2)) return false;
+    if (dir === GROK_SKILLS_DIR) {
+      const target = realpathOrNull2(link2);
+      if (target !== null && target !== gone) return false;
+    }
     unlinkSync(link2);
     return true;
   });
@@ -826,7 +924,7 @@ function unlinkEverywhere(root, name) {
 function relinkDependency(root, name, { allowTracked = false } = {}) {
   const manifest = readManifest(root);
   const dep = manifest.skills[name];
-  if (!dep) return { created: [], blocked: [] };
+  if (!dep) return { created: [], blocked: [], uncommitted: [] };
   const result = linkEverywhere(root, name, dep.dir ?? PROJECT_SKILLS_DIR, { allowTracked });
   if (result.created.length) {
     manifest.skills[name] = { ...dep, links: [.../* @__PURE__ */ new Set([...dep.links ?? [], ...result.created])] };
@@ -837,13 +935,15 @@ function relinkDependency(root, name, { allowTracked = false } = {}) {
 function linkAll(root, { allowTracked = false } = {}) {
   const linked = [];
   const blocked = /* @__PURE__ */ new Set();
+  const uncommitted = [];
   for (const skill of projectStatus(root)) {
     if (!skill.visibility.some((v) => v.paths === 0) || skill.state === "folder missing") continue;
     const res = skill.managed ? relinkDependency(root, skill.name, { allowTracked }) : linkEverywhere(root, skill.name, skill.location, { allowTracked });
     if (res.created.length) linked.push({ name: skill.name, into: res.created });
     for (const dir of res.blocked) blocked.add(dir);
+    if (res.uncommitted.length) uncommitted.push(skill.name);
   }
-  return { linked, blocked: [...blocked] };
+  return { linked, blocked: [...blocked], uncommitted };
 }
 function addSkill(root, name, { force = false, version, allowTracked = false } = {}) {
   const target = version === void 0 ? latestVersion(name) : getVersion(name, version);
@@ -861,13 +961,17 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
       reason: recorded ? "has local edits (use --force to overwrite, or save them to the library first)" : `${primary}/${name} already exists with different content (use --force to replace it)`
     };
   }
+  let backedUp;
   if (local !== target.hash || isLink(to)) {
     mkdirSync5(join8(root, primary), { recursive: true });
     if (isLink(to)) unlinkSync(to);
+    else if (local !== null && !knownContent) backedUp = stash(to, "edit-backup");
     copySkill(versionDir(name, target.version), to);
   }
   const links = [];
   const blocked = [];
+  const uncommitted = [];
+  let shared;
   for (const dir of linkDirs) {
     const link2 = join8(root, dir, name);
     if (isLink(link2) && realpathOrNull2(link2) === realpathOrNull2(to)) {
@@ -875,9 +979,15 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
       continue;
     }
     if (entryExists(link2)) continue;
-    if (!allowTracked && !recorded?.links?.includes(dir) && isGitTracked(root, dir) && !readConfig().agentsDirOk?.includes(root)) {
-      blocked.push(dir);
-      continue;
+    if (!recorded?.links?.includes(dir) && isGitTracked(root, dir)) {
+      if (!(shared ??= sharedByGit(root, primary, name))) {
+        uncommitted.push(dir);
+        continue;
+      }
+      if (!allowTracked && !readConfig().agentsDirOk?.includes(root)) {
+        blocked.push(dir);
+        continue;
+      }
     }
     mkdirSync5(join8(root, dir), { recursive: true });
     linkDir(to, link2);
@@ -892,10 +1002,12 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
   writeManifest(root, manifest);
   return {
     name,
-    action: recorded || local !== null ? "updated" : "installed",
+    action: !recorded && local === null ? "installed" : backedUp && recorded?.version === target.version ? "reset" : "updated",
     ...recorded ? { from: recorded.version } : {},
     to: target.version,
-    ...blocked.length ? { blocked } : {}
+    ...blocked.length ? { blocked } : {},
+    ...uncommitted.length ? { uncommitted } : {},
+    ...backedUp ? { backedUp } : {}
   };
 }
 function removeSkill(root, name, { force = false } = {}) {
@@ -904,17 +1016,17 @@ function removeSkill(root, name, { force = false } = {}) {
   if (!recorded) return { name, action: "skipped", reason: "not managed by skilllib in this project" };
   const dir = join8(root, recorded.dir ?? PROJECT_SKILLS_DIR, name);
   const local = treeHash(dir);
-  if (local !== null && local !== recorded.hash && !versionForHash(name, local) && !force) {
-    return { name, action: "skipped", reason: "has local edits (use --force to delete anyway)" };
-  }
+  const edited = local !== null && local !== recorded.hash && !versionForHash(name, local);
+  if (edited && !force) return { name, action: "skipped", reason: "has local edits (use --force to delete anyway)" };
   for (const linkDir2 of recorded.links ?? []) {
     const link2 = join8(root, linkDir2, name);
     if (isLink(link2)) unlinkSync(link2);
   }
-  rmSync2(dir, { recursive: true, force: true });
+  const backedUp = edited ? stash(dir, "edit-backup") : void 0;
+  if (!backedUp) rmSync2(dir, { recursive: true, force: true });
   delete manifest.skills[name];
   writeManifest(root, manifest);
-  return { name, action: "removed" };
+  return { name, action: "removed", ...backedUp ? { backedUp } : {} };
 }
 function syncProject(root, { force = false } = {}) {
   const { skills } = readManifest(root);
@@ -925,7 +1037,8 @@ function syncProject(root, { force = false } = {}) {
     const pinned = dep.version > 0 && getVersion(name, dep.version) ? dep.version : void 0;
     if (local !== null && local !== dep.hash && !force) return [{ name, action: "skipped", reason: "has local edits (use --force to reset them)" }];
     const change = addSkill(root, name, { force: true, version: pinned });
-    return change.action === "skipped" ? [change] : [{ ...change, action: local === null ? "installed" : "updated" }];
+    if (change.action === "skipped") return [{ ...change, reason: `not in your library (${tildify(libraryDir())}); import it, or set SKILLLIB_HOME to the library that has it` }];
+    return [{ ...change, action: local === null ? "installed" : change.action }];
   });
 }
 function discardEdits(root, name) {
@@ -944,6 +1057,7 @@ function updateProject(root, names, { force = false } = {}) {
     const dep = skills[name];
     const local = treeHash(join8(root, dep.dir ?? PROJECT_SKILLS_DIR, name));
     if (dep.hash === latest.hash && local === latest.hash) return [];
+    if (dep.hash === latest.hash && local !== null && !force) return [];
     const change = addSkill(root, name, { force });
     return change.action === "skipped" || change.from !== change.to || local !== latest.hash ? [change] : [];
   });
@@ -985,7 +1099,7 @@ function stash(dir, bucket) {
   return target;
 }
 function removeUntracked(root, name, path) {
-  unlinkEverywhere(root, name);
+  unlinkEverywhere(root, name, path);
   return stash(path, "trash");
 }
 function projectsUsing(name) {
@@ -1038,12 +1152,12 @@ function createSkill(name, description) {
     join8(dir, "SKILL.md"),
     `---
 name: ${name}
-description: ${description || "Describe when Claude should use this skill."}
+description: ${description || "Describe when an agent should use this skill."}
 ---
 
 # ${name}
 
-Instructions for Claude go here.
+Instructions for the agent go here.
 `
   );
   forgetLatest(name);
@@ -1061,7 +1175,11 @@ function listBackups() {
       const from = index[entry] ?? (kind === "trash" ? librarySkillDir(name) : join8(claudeDir(), "skills", name));
       return [{ name, kind, path: join8(dir, entry), movedAt: `${match[2]} ${match[3]}:${match[4]}`, from }];
     });
-  }).sort((a, b) => b.movedAt.localeCompare(a.movedAt));
+  }).sort((a, b) => b.path.slice(-24).localeCompare(a.path.slice(-24)));
+}
+function backupFrom(backup) {
+  if (backup.kind === "plugin") return "Claude Code plugin";
+  return backup.from === librarySkillDir(backup.name) ? "library (deleted)" : tildify(dirname2(backup.from));
 }
 function restoreBackup(backup) {
   const to = backup.from;
@@ -1114,7 +1232,7 @@ function installAgentSkill(enabled = enabledHarnesses()) {
   const [primary, ...links] = agentSkillDirs(enabled);
   if (!primary) return { ok: false, reason: "no agents chosen yet (skilllib harnesses <id>...)" };
   const foreign = [primary, ...links].find((d) => entryExists2(d) && !isOurs(d) && !isDangling(d));
-  if (foreign) return { ok: false, reason: `${foreign} already exists and isn't skilllib's` };
+  if (foreign) return { ok: false, reason: `${tildify(foreign)} already exists and isn't skilllib's` };
   for (const d of [primary, ...links]) if (isDangling(d)) unlinkSync2(d);
   mkdirSync6(primary, { recursive: true });
   writeFileSync6(join9(primary, "SKILL.md"), shippedSkill());
@@ -1143,12 +1261,8 @@ function refreshAgentSkill() {
 }
 
 // src/commands.ts
-import { existsSync as existsSync14, readFileSync as readFileSync9 } from "fs";
-import { basename as basename8, dirname as dirname5, join as join15, resolve as resolve4, sep as sep5 } from "path";
-
-// src/here.ts
-import { existsSync as existsSync12, readdirSync as readdirSync7 } from "fs";
-import { basename as basename7, join as join13 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
+import { basename as basename8, join as join14, resolve as resolve7, sep as sep5 } from "path";
 
 // src/git.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -1162,9 +1276,9 @@ function git(root, args, input) {
     return typeof out2 === "string" ? out2 : null;
   }
 }
-function gitInfo(root) {
+function gitInfo(root, extraDirs = []) {
   if (!existsSync9(join10(root, ".git"))) return null;
-  const dirs = [...ALL_PROJECT_DIRS, MANIFEST_FILE].filter((d) => existsSync9(join10(root, d)));
+  const dirs = [...ALL_PROJECT_DIRS, MANIFEST_FILE, ...extraDirs].filter((d) => existsSync9(join10(root, d)));
   if (dirs.length === 0) return { of: () => "new" };
   const tracked = (git(root, ["ls-files", "-z", "--", ...dirs]) ?? "").split("\0").filter(Boolean);
   const dirty = (git(root, ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ...dirs]) ?? "").split("\0").filter(Boolean).map((entry) => entry.slice(3));
@@ -1189,14 +1303,18 @@ function relativeTo(root, path) {
   return relative3(root, path).split("\\").join("/");
 }
 
+// src/here.ts
+import { readdirSync as readdirSync7 } from "fs";
+import { basename as basename7 } from "path";
+
 // src/health.ts
 import { lstatSync as lstatSync4 } from "fs";
-import { basename as basename6 } from "path";
+import { basename as basename6, dirname as dirname5 } from "path";
 
 // src/plugins.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync2, writeFileSync as writeFileSync7 } from "fs";
-import { basename as basename4, dirname as dirname3, join as join11 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync3, writeFileSync as writeFileSync7 } from "fs";
+import { basename as basename4, dirname as dirname3, join as join11, resolve as resolve6 } from "path";
 function readJson2(path) {
   try {
     return JSON.parse(readFileSync8(path, "utf-8"));
@@ -1239,22 +1357,109 @@ function claudePlugins(machine, root) {
     };
   });
 }
+function newer(a, b) {
+  const parts = (v) => v.replace(/^v/i, "").split(/[.+-]/).map((x) => parseInt(x, 10) || 0);
+  const pa = parts(a);
+  const pb = parts(b);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) > (pb[i] ?? 0);
+  return false;
+}
+function updateOf(name, marketplace, entry, catalogs) {
+  const dir = join11(claudeDir(), "plugins", "marketplaces", marketplace);
+  if (!catalogs.has(marketplace)) catalogs.set(marketplace, readJson2(join11(dir, ".claude-plugin", "marketplace.json"))?.plugins ?? []);
+  const listed = catalogs.get(marketplace).find((p) => p.name === name);
+  if (!listed) return void 0;
+  const version = listed.version ?? (typeof listed.source === "string" ? readJson2(join11(dir, listed.source, ".claude-plugin", "plugin.json"))?.version : void 0);
+  if (version && entry.version) return newer(version, entry.version) ? version : void 0;
+  const sha = typeof listed.source === "object" ? listed.source?.sha : void 0;
+  return sha && entry.gitCommitSha && sha !== entry.gitCommitSha ? "newer" : void 0;
+}
+function pluginRoot(id, entry) {
+  const candidates = pluginDirCandidates(id, entry.installPath ? [entry.installPath] : []);
+  return candidates.find((c) => existsSync10(join11(c, "skills"))) ?? candidates.find((c) => existsSync10(c)) ?? candidates[0];
+}
+function describe(root) {
+  const manifest = readJson2(join11(root, ".claude-plugin", "plugin.json")) ?? {};
+  return { description: manifest.description ?? "", version: manifest.version, skills: skillDirsIn(join11(root, "skills")), extras: extrasOf(root) };
+}
+function installedPlugins() {
+  const plugins = join11(claudeDir(), "plugins");
+  const installed = readJson2(join11(plugins, "installed_plugins.json"))?.plugins ?? {};
+  const catalogs = /* @__PURE__ */ new Map();
+  const fromMarketplaces = Object.entries(installed).flatMap(
+    ([id, entries]) => entries.map((entry) => {
+      const [name = id, marketplace = ""] = id.split("@");
+      const scope = entry.scope ?? "user";
+      const projectPath = scope === "user" ? void 0 : entry.projectPath;
+      const root = pluginRoot(id, entry);
+      const about = describe(root);
+      const update2 = updateOf(name, marketplace, entry, catalogs);
+      return {
+        id,
+        scope,
+        ...projectPath ? { projectPath } : {},
+        synced: false,
+        agent: "claude-code",
+        on: enabledPlugins(projectPath)[id] === true,
+        root,
+        ...about,
+        version: entry.version ?? about.version,
+        ...update2 ? { update: update2 } : {}
+      };
+    })
+  );
+  const user = enabledPlugins();
+  const fromSettings = Object.keys(user).filter((id) => user[id] === true && id.includes("@") && !id.endsWith("@synced") && !installed[id]).flatMap((id) => {
+    const root = pluginDirCandidates(id, []).find((c) => existsSync10(join11(c, "skills")));
+    return root ? [{ id, scope: "user", synced: false, agent: "claude-code", on: true, settingsOnly: true, root, ...describe(root) }] : [];
+  });
+  const syncedDir = join11(plugins, "synced");
+  const dirs = (p) => existsSync10(p) ? readdirSync5(p, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => join11(p, d.name)) : [];
+  const fromSynced = dirs(syncedDir).flatMap(dirs).map((root) => {
+    const id = `${readJson2(join11(root, ".claude-plugin", "plugin.json"))?.name ?? basename4(root)}@synced`;
+    return { id, scope: null, synced: true, agent: "claude-code", on: user[id] !== false, root, ...describe(root) };
+  });
+  return [...fromMarketplaces, ...fromSettings, ...fromSynced];
+}
+function cursorPlugins() {
+  const cache = join11(userHome(), ".cursor", "plugins", "cache");
+  const dirs = (p) => existsSync10(p) ? readdirSync5(p).filter((d) => !d.startsWith(".") && statSync3(join11(p, d)).isDirectory()) : [];
+  return dirs(cache).flatMap(
+    (marketplace) => dirs(join11(cache, marketplace)).flatMap((plugin) => {
+      const versions = dirs(join11(cache, marketplace, plugin)).map((v) => join11(cache, marketplace, plugin, v));
+      const root = versions.sort((a, b) => statSync3(b).mtimeMs - statSync3(a).mtimeMs)[0];
+      if (!root) return [];
+      const about = describe(root);
+      return [{ id: `${plugin}@${marketplace}`, scope: null, synced: false, agent: "cursor", on: null, root, ...about, version: about.version ?? basename4(root) }];
+    })
+  );
+}
+var binaries = /* @__PURE__ */ new Map();
+function forgetClaudeBinary() {
+  binaries.clear();
+}
 function claudeBinary() {
-  const candidates = ["claude", join11(userHome(), ".local", "bin", "claude"), join11(userHome(), ".claude", "local", "claude")];
-  return candidates.find((bin) => {
-    try {
-      return execFileSync3(bin, ["--version"], { stdio: ["ignore", "pipe", "ignore"], timeout: 3e4, encoding: "utf-8" }).includes("Claude Code");
-    } catch {
-      return false;
-    }
-  }) ?? null;
+  const key = `${process.env.PATH}|${userHome()}`;
+  if (!binaries.has(key)) {
+    const candidates = ["claude", join11(userHome(), ".local", "bin", "claude"), join11(userHome(), ".claude", "local", "claude")];
+    const found = candidates.find((bin) => {
+      try {
+        return execFileSync3(bin, ["--version"], { stdio: ["ignore", "pipe", "ignore"], timeout: 1e4, encoding: "utf-8" }).includes("Claude Code");
+      } catch {
+        return false;
+      }
+    });
+    binaries.set(key, found ?? null);
+  }
+  return binaries.get(key);
 }
-function claude(args, cwd) {
-  const bin = claudeBinary();
+function claude(args, cwd, bin = claudeBinary()) {
+  if (cwd && !existsSync10(cwd)) return { ok: false, reason: `${cwd} no longer exists; run \`claude ${args.join(" ")}\` in the project's new folder, or remove the install with /plugin` };
   if (!bin) return { ok: false, reason: `Claude Code's CLI didn't run (tried \`claude\` on your PATH and ~/.local/bin/claude); run \`claude ${args.join(" ")}\` yourself` };
+  const slow = args[1] === "install" || args[1] === "update";
   try {
-    execFileSync3(bin, args, { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 12e4, encoding: "utf-8" });
-    return { ok: true };
+    const out2 = execFileSync3(bin, args, { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: slow ? 12e4 : 2e4, encoding: "utf-8" });
+    return { ok: true, out: out2 };
   } catch (err) {
     const e = err;
     return { ok: false, reason: `${(e.stderr || e.stdout || e.message || "failed").trim().split("\n").slice(-1)[0]} (ran ${bin})` };
@@ -1268,12 +1473,88 @@ function setPluginIn(file, id, on) {
   writeFileSync7(file, JSON.stringify({ ...settings, enabledPlugins: { ...enabled, [id]: on } }, null, 2) + "\n");
   return { ok: true };
 }
-function turnOffSynced(id) {
-  return setPluginIn(join11(claudeDir(), "settings.json"), id, false);
+function ignoreLocalSettings(root) {
+  const file = ".claude/settings.local.json";
+  const git2 = (...args) => execFileSync3("git", args, { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  try {
+    git2("rev-parse", "--git-dir");
+  } catch {
+    return "";
+  }
+  try {
+    git2("ls-files", "--error-unmatch", "--", file);
+    return "; git tracks that file, so this shows in git status";
+  } catch {
+  }
+  try {
+    git2("check-ignore", "-q", "--", file);
+    return ", which git ignores";
+  } catch {
+  }
+  try {
+    const exclude = resolve6(root, git2("rev-parse", "--git-path", "info/exclude"));
+    const before = existsSync10(exclude) ? readFileSync8(exclude, "utf-8") : "";
+    mkdirSync7(dirname3(exclude), { recursive: true });
+    writeFileSync7(exclude, `${before}${before && !before.endsWith("\n") ? "\n" : ""}/${git2("rev-parse", "--show-prefix")}${file}
+`);
+    return ", which git now ignores via .git/info/exclude";
+  } catch {
+    return "; git doesn't ignore that file yet: it's local only, don't commit it";
+  }
 }
 function turnOffIn(plugin, root) {
-  const r = plugin.synced ? setPluginIn(join11(root, ".claude", "settings.local.json"), plugin.id, false) : claude(["plugin", "disable", plugin.id, "--scope", "local"], root);
-  return r.ok ? { ok: true, message: `${plugin.id} turned off in ${basename4(root)}; other repos keep it` } : { ok: false, message: `${plugin.id}: ${r.reason}` };
+  const done = `${plugin.id} turned off in ${basename4(root)}; other repos keep it`;
+  const bin = plugin.synced ? null : claudeBinary();
+  if (!bin) {
+    const r2 = setPluginIn(join11(root, ".claude", "settings.local.json"), plugin.id, false);
+    return r2.ok ? { ok: true, message: `${done} (in .claude/settings.local.json${ignoreLocalSettings(root)})` } : { ok: false, message: `${plugin.id}: ${r2.reason}` };
+  }
+  const r = claude(["plugin", "disable", plugin.id, "--scope", "local"], root, bin);
+  return r.ok ? { ok: true, message: done } : { ok: false, message: `${plugin.id}: ${r.reason}` };
+}
+function settingsFileOf(p) {
+  if (p.synced || !p.scope || p.scope === "user") return join11(claudeDir(), "settings.json");
+  if (!p.projectPath) return null;
+  return join11(p.projectPath, ".claude", p.scope === "local" ? "settings.local.json" : "settings.json");
+}
+function whereOf(p) {
+  return p.projectPath ? ` in ${basename4(p.projectPath)} (${p.scope})` : "";
+}
+function setPluginOn(p, on) {
+  const done = { ok: true, message: `${p.id} is ${on ? "on" : "off"}${whereOf(p)}${p.synced ? "" : "; Claude Code picks it up in its next session"}` };
+  if (p.scope && p.scope !== "user" && !p.projectPath) return { ok: false, message: `${p.id}: skilllib doesn't know which project it's installed in; run \`claude plugin ${on ? "enable" : "disable"} ${p.id} --scope ${p.scope}\` there` };
+  const bin = p.synced || p.settingsOnly ? null : claudeBinary();
+  if (bin) {
+    const r2 = claude(["plugin", on ? "enable" : "disable", p.id, ...p.scope ? ["--scope", p.scope] : []], p.projectPath, bin);
+    return r2.ok ? done : { ok: false, message: `${p.id}: ${r2.reason}` };
+  }
+  const r = setPluginIn(settingsFileOf(p), p.id, on);
+  if (!r.ok) return { ok: false, message: `${p.id}: ${r.reason}` };
+  return p.scope === "local" && p.projectPath ? { ...done, message: done.message + ignoreLocalSettings(p.projectPath) } : done;
+}
+function uninstallPlugin(p) {
+  if (p.synced) return { ok: false, message: `${p.id} is synced from your claude.ai account: remove it there, or turn it off here` };
+  if (p.settingsOnly) return { ok: false, message: `${p.id} isn't installed, only turned on in your settings: turn it off instead` };
+  if (p.scope && p.scope !== "user" && !p.projectPath) return { ok: false, message: `${p.id}: skilllib doesn't know which project it's installed in; run \`claude plugin uninstall ${p.id} --scope ${p.scope}\` there` };
+  const wasOn = enabledPlugins(p.projectPath)[p.id] === true;
+  const r = claude(["plugin", "uninstall", p.id, "--keep-data", "--scope", p.scope ?? "user"], p.projectPath);
+  if (!r.ok) return { ok: false, message: `${p.id}: ${r.reason}` };
+  recordRemovedPlugin(p.id, p.scope ?? "user", p.projectPath, wasOn);
+  return { ok: true, message: `${p.id} is uninstalled${whereOf(p)} (Settings \u203A Backups reinstalls it)` };
+}
+function updatePlugin(p) {
+  if (p.synced) return { ok: false, message: `${p.id} is synced from your claude.ai account: it updates from there` };
+  if (p.settingsOnly) return { ok: false, message: `${p.id} isn't installed, only turned on in your settings: install it with /plugin to update it` };
+  const r = claude(["plugin", "update", p.id, ...p.scope ? ["--scope", p.scope] : [], "--json"], p.projectPath);
+  if (!r.ok) return { ok: false, message: `${p.id}: ${r.reason}; to update it yourself, run \`claude plugin update ${p.id}\`${p.projectPath ? ` in ${p.projectPath}` : ""}` };
+  let result = {};
+  try {
+    result = JSON.parse(r.out.trim().split("\n").pop() ?? "{}");
+  } catch {
+  }
+  if (result.updateOutcome === "up_to_date") return { ok: true, message: `${p.id} is already the newest version${result.newVersion ? ` (${result.newVersion})` : ""}${whereOf(p)}` };
+  const versions = result.oldVersion && result.newVersion ? ` from ${result.oldVersion} to ${result.newVersion}` : "";
+  return { ok: true, message: `${p.id} is updated${versions}${whereOf(p)}; Claude Code uses the new version after a restart` };
 }
 function removedFile() {
   return join11(skilllibHome(), "plugin-backup.json");
@@ -1287,42 +1568,45 @@ function removePlugin(plugin, how) {
   }
   const imported = plugin.skills.filter((dir) => latestVersion(basename4(dir)) === null).map((dir) => importSkill(dir).name);
   const scope = plugin.scope ? ["--scope", plugin.scope] : [];
-  const r = plugin.synced ? turnOffSynced(plugin.id) : claude(["plugin", how === "delete" ? "uninstall" : "disable", plugin.id, ...scope], plugin.projectPath);
+  const r = plugin.synced ? (
+    // Synced plugins aren't installed, so `claude plugin` can't touch them: their switch is enabledPlugins.
+    setPluginIn(join11(claudeDir(), "settings.json"), plugin.id, false)
+  ) : claude(["plugin", how === "delete" ? "uninstall" : "disable", plugin.id, ...scope], plugin.projectPath);
   const saved = imported.length ? `; ${imported.join(", ")} copied into Your skills` : "";
   if (!r.ok) return { ok: false, message: `${plugin.id}: ${r.reason}${saved}` };
-  if (how === "delete" && !plugin.synced) recordRemovedPlugin(plugin.id, plugin.scope ?? "user");
+  if (how === "delete" && !plugin.synced) recordRemovedPlugin(plugin.id, plugin.scope ?? "user", plugin.projectPath, true);
   return { ok: true, message: `${plugin.id} ${how === "delete" && !plugin.synced ? "removed" : "turned off"}${saved}` };
 }
-function recordRemovedPlugin(id, scope) {
+function recordRemovedPlugin(id, scope, projectPath, on = true) {
   const list2 = readJson2(removedFile()) ?? [];
   mkdirSync7(skilllibHome(), { recursive: true });
-  writeFileSync7(removedFile(), JSON.stringify([...list2, { id, scope, at: (/* @__PURE__ */ new Date()).toISOString() }], null, 2) + "\n");
+  writeFileSync7(removedFile(), JSON.stringify([...list2, { id, scope, ...projectPath ? { projectPath } : {}, on, at: (/* @__PURE__ */ new Date()).toISOString() }], null, 2) + "\n");
 }
 function pluginBackups() {
   return (readJson2(removedFile()) ?? []).map((r) => ({
     name: r.id,
     kind: "plugin",
-    path: r.scope,
+    // Project and local installs go back into their project.
+    path: r.projectPath ? `${r.scope}:${r.projectPath}` : r.scope,
     movedAt: r.at.slice(0, 16).replace("T", " "),
     from: r.id
   }));
 }
 function restorePlugin(backup) {
-  const r = claude(["plugin", "install", backup.from, "--scope", backup.path]);
+  const [scope = "user", ...rest] = backup.path.split(":");
+  const projectPath = rest.join(":") || void 0;
+  const r = claude(["plugin", "install", backup.from, "--scope", scope], projectPath);
   if (!r.ok) return r;
-  writeFileSync7(removedFile(), JSON.stringify((readJson2(removedFile()) ?? []).filter((x) => x.id !== backup.from), null, 2) + "\n");
-  return { ok: true, to: `Claude Code plugins (${backup.path})` };
+  const records = readJson2(removedFile()) ?? [];
+  const same = (x) => x.id === backup.from && (x.projectPath ?? void 0) === projectPath && x.scope === scope;
+  const wasOff = records.filter(same).pop()?.on === false;
+  const off = wasOff ? claude(["plugin", "disable", backup.from, "--scope", scope], projectPath) : null;
+  writeFileSync7(removedFile(), JSON.stringify(records.filter((x) => !same(x)), null, 2) + "\n");
+  const where = `Claude Code plugins (${scope}${projectPath ? ` in ${basename4(projectPath)}` : ""}${wasOff ? off?.ok ? ", off as it was" : ", but it's on: turn it off from Plugins" : ""})`;
+  return { ok: true, to: where };
 }
-function cursorPluginSkills() {
-  const cache = join11(userHome(), ".cursor", "plugins", "cache");
-  const dirs = (p) => existsSync10(p) ? readdirSync5(p).filter((d) => !d.startsWith(".") && statSync2(join11(p, d)).isDirectory()) : [];
-  return dirs(cache).flatMap(
-    (marketplace) => dirs(join11(cache, marketplace)).flatMap((plugin) => {
-      const versions = dirs(join11(cache, marketplace, plugin)).map((v) => join11(cache, marketplace, plugin, v));
-      const newest = versions.sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs)[0];
-      return newest ? skillDirsIn(join11(newest, "skills")).map((path) => ({ name: basename4(path), plugin, path })) : [];
-    })
-  );
+function cursorPluginSkills(plugins = cursorPlugins()) {
+  return plugins.flatMap((p) => p.skills.map((path) => ({ name: basename4(path), plugin: p.id.split("@")[0], path })));
 }
 
 // src/tidy.ts
@@ -1350,6 +1634,11 @@ function namesIn(dirs) {
   }
   return [...names].sort();
 }
+var PROJECT_TIDY_DIRS = ALL_PROJECT_DIRS.filter((d) => d !== GROK_SKILLS_DIR);
+function globalTidyDirs() {
+  const own = realPath(join12(grokDir(), "skills"));
+  return globalSkillDirs().filter((d) => realPath(d) !== own);
+}
 function runsFrom(id, dirsWithCopy, readsOf) {
   const reads = readsOf(id).filter((d) => dirsWithCopy.includes(d));
   if (id === "codex") return reads;
@@ -1372,8 +1661,8 @@ function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {})
   const readsOf = (id) => HARNESSES.find((h) => h.id === id).projectDirs.map(abs);
   let git2;
   const skillsLock = projectSkillsLock(root);
-  for (const name of namesIn(ALL_PROJECT_DIRS.map(abs))) {
-    const entries = entriesOf(ALL_PROJECT_DIRS.map(abs), name);
+  for (const name of namesIn(PROJECT_TIDY_DIRS.map(abs))) {
+    const entries = entriesOf(PROJECT_TIDY_DIRS.map(abs), name);
     const external = entries.find((e) => e.link && e.real && !(e.real + sep4).startsWith(realpathOrNull2(root) + sep4));
     if (external) {
       report.skipped.push({ name, reason: `${rel(external.path)} links outside the repo` });
@@ -1388,7 +1677,7 @@ function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {})
     if (dep) {
       primary = reals.find((r) => rel(r.dir) === (dep.dir ?? PROJECT_SKILLS_DIR));
       if (!primary) continue;
-    } else if (chosen) {
+    } else if (chosen && reals.some((r) => r.dir === chosen)) {
       primary = reals.find((r) => r.dir === chosen);
     } else {
       if (git2 === void 0) git2 = gitInfo(root);
@@ -1412,7 +1701,8 @@ function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {})
           if (!needed) steps.push({ kind: "unlink", path: e.path });
         } else steps.push(needed ? { kind: "link", path: e.path, target: primary.path } : { kind: "unlink", path: e.path });
       } else {
-        steps.push(needed ? { kind: "replace", path: e.path, target: primary.path } : { kind: "remove", path: e.path });
+        const differs = e.hash !== primary.hash ? { differs: true } : {};
+        steps.push(needed ? { kind: "replace", path: e.path, target: primary.path, ...differs } : { kind: "remove", path: e.path, ...differs });
       }
     }
     if (steps.length) report.plans.push({ name, root, primary: primary.path, steps });
@@ -1420,14 +1710,14 @@ function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {})
   return report;
 }
 function globalReadsOf(id) {
-  return HARNESSES.find((h) => h.id === id).globalDirs();
+  return HARNESSES.find((h) => h.id === id).globalDirs().map(globalDirAs);
 }
 function isSkillsDirPlugin(path) {
   return existsSync11(join12(path, ".claude-plugin", "plugin.json"));
 }
 function planGlobalTidy({ keep = {}, enabled = enabledHarnesses() } = {}) {
   const report = { plans: [], conflicts: [], skipped: [] };
-  const dirs = globalSkillDirs();
+  const dirs = globalTidyDirs();
   const agents = join12(userHome(), ".agents", "skills");
   for (const name of namesIn(dirs)) {
     const entries = entriesOf(dirs, name);
@@ -1435,15 +1725,16 @@ function planGlobalTidy({ keep = {}, enabled = enabledHarnesses() } = {}) {
       report.skipped.push({ name, reason: "a Claude Code plugin kept in a skills folder" });
       continue;
     }
-    const reals = entries.filter((e) => !e.link);
+    const reals = entries.filter((e, i, all) => !e.link && all.findIndex((o) => !o.link && realpathOrNull2(o.path) === realpathOrNull2(e.path)) === i);
     if (reals.length < 2) continue;
     hashReals(reals);
-    const primary = reals.find((r) => r.dir === keep[name]) ?? reals.find((r) => r.dir === agents) ?? reals[0];
-    if (!keep[name] && reals.some((r) => r.hash !== primary.hash)) {
+    const kept = reals.find((r) => r.dir === keep[name]);
+    const primary = kept ?? reals.find((r) => r.dir === agents) ?? reals[0];
+    if (!kept && reals.some((r) => r.hash !== primary.hash)) {
       report.conflicts.push(conflictOf(name, null, reals, enabled, globalReadsOf));
       continue;
     }
-    const steps = reals.filter((r) => r !== primary).map((r) => ({ kind: "replace", path: r.path, target: primary.path }));
+    const steps = reals.filter((r) => r !== primary).map((r) => ({ kind: "replace", path: r.path, target: primary.path, ...r.hash !== primary.hash ? { differs: true } : {} }));
     report.plans.push({ name, root: null, primary: primary.path, steps });
   }
   return report;
@@ -1481,20 +1772,27 @@ function applyTidy(plan, { git: git2 = "keep", info: info2 } = {}) {
   return { name: plan.name, root: plan.root, applied, held };
 }
 function describeStep(step, root) {
-  const shown = root ? relativeTo(root, step.path) : step.path.replace(userHome(), "~");
+  const shown = root ? relativeTo(root, step.path) : tildify(step.path);
   switch (step.kind) {
     case "link":
       return `link ${shown}`;
     case "unlink":
       return `remove extra link ${shown}`;
     case "replace":
-      return `${shown}: duplicate copy \u2192 link`;
+      return `${shown}: ${step.differs ? "differing" : "duplicate"} copy \u2192 link`;
     case "remove":
-      return `remove duplicate copy ${shown}`;
+      return `remove ${step.differs ? "differing" : "duplicate"} copy ${shown}`;
   }
 }
 function copyLabel(conflict, dir) {
-  return conflict.root ? relativeTo(conflict.root, dir) : dir.replace(userHome(), "~");
+  return folderLabel(conflict.root, dir);
+}
+function folderLabel(root, dir) {
+  return root ? relativeTo(root, dir) : tildify(dir);
+}
+function foldersOf(root, name) {
+  const entries = entriesOf(root ? PROJECT_TIDY_DIRS.map((d) => join12(root, d)) : globalTidyDirs(), name);
+  return { all: entries.map((e) => e.dir), real: entries.filter((e) => !e.link).map((e) => e.dir) };
 }
 
 // src/health.ts
@@ -1543,13 +1841,14 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
     issues.push({
       id: `broken:${skill.name}`,
       severity: "problem",
-      title: `${skill.name}: broken link in ${skill.path.replace(/\/[^/]+$/, "").replace(/^\/Users\/[^/]+/, "~")}`,
+      title: `${skill.name}: broken link in ${tildify(dirname5(skill.path))}`,
       detail: "It points at a folder that no longer exists, so it loads nothing.",
       fix: {
         label: "Remove the link",
         run: () => {
           const r = unloadGlobal(skill.path);
-          return r.ok ? `Removed broken link ${skill.name}` : `${skill.name}: ${r.reason}`;
+          if (!r.ok) throw new Error(`${skill.name}: ${r.reason}`);
+          return `Removed broken link ${skill.name}`;
         }
       }
     });
@@ -1570,8 +1869,10 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
     });
   }
   const loadedHere = new Map(projects2.map((root) => [root, loadedIn(root)]));
-  const seenByClaude = (s) => s.visibility.some((v) => v.id === "claude-code" && v.paths > 0);
-  const namesIn2 = (root) => [...new Set([...statuses.get(root), ...nested.get(root)].filter(seenByClaude).map((s) => s.name))];
+  const namesIn2 = (root, agent = "claude-code") => [
+    ...new Set([...statuses.get(root), ...nested.get(root)].filter((s) => s.visibility.some((v) => v.id === agent && v.paths > 0)).map((s) => s.name))
+  ];
+  const pluginAgentsIn = (plugin, root) => new Set(loadedHere.get(root).filter((m) => plugin.skills.includes(m.path)).flatMap((m) => m.harnesses));
   const globalYours = new Set(loaded.filter((m) => m.movable).map((m) => m.name));
   const installedYours = /* @__PURE__ */ new Set([...globalYours, ...[...statuses.values()].flat().map((s) => s.name)]);
   const repoChoices = (plugin, root, names) => {
@@ -1579,7 +1880,7 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
     const copies = statuses.get(root).filter((s) => names.includes(s.name));
     const allManaged = names.every((n) => copies.some((c) => c.name === n && c.managed));
     return [
-      { label: `Turn the plugin ${plugin.id} off in ${where} only`, hint: "other repos keep it", run: () => orThrow(turnOffIn(plugin, root)) },
+      { label: `Turn the plugin ${plugin.id} off in ${where} only`, hint: "other repos keep it; in .claude/settings.local.json, a local-only file", run: () => orThrow(turnOffIn(plugin, root)) },
       // Only copies skilllib installed: Your skills keeps them. A repo's own skill is the team's, never removed from here.
       ...names.length && allManaged ? [
         {
@@ -1599,8 +1900,10 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
   const machinePlugins = claudePlugins(machine);
   for (const plugin of machinePlugins) {
     const names = plugin.skills.map((p) => basename6(p));
-    const inRepos = projects2.filter((root) => loadedHere.get(root).some((m) => plugin.skills.includes(m.path))).map((root) => [root, namesIn2(root).filter((n) => names.includes(n))]).filter(([, d]) => d.length);
-    const loadedYours = /* @__PURE__ */ new Set([...globalYours, ...inRepos.flatMap(([, d]) => d)]);
+    const inRepos = projects2.filter((root) => pluginAgentsIn(plugin, root).has("claude-code")).map((root) => [root, namesIn2(root).filter((n) => names.includes(n))]).filter(([, d]) => d.length);
+    const cursorRepos = enabledHarnesses().includes("claude-code") ? projects2.filter((root) => !pluginAgentsIn(plugin, root).has("claude-code") && pluginAgentsIn(plugin, root).has("cursor")).map((root) => [root, namesIn2(root, "cursor").filter((n) => names.includes(n))]).filter(([, d]) => d.length) : [];
+    const claudeYours = /* @__PURE__ */ new Set([...globalYours, ...inRepos.flatMap(([, d]) => d)]);
+    const loadedYours = /* @__PURE__ */ new Set([...claudeYours, ...cursorRepos.flatMap(([, d]) => d)]);
     const dupes = names.filter((n) => libraryNames.has(n) || loadedYours.has(n));
     if (!dupes.length) continue;
     const others = plugin.skills.length - dupes.length;
@@ -1612,15 +1915,18 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
     };
     const off = { label: `Turn the plugin ${plugin.id} off`, hint: "stays installed", run: () => orThrow(removePlugin(plugin, "off")) };
     const bothLoad = dupes.filter((n) => loadedYours.has(n));
+    const claudeBoth = dupes.filter((n) => claudeYours.has(n));
+    const cursorWheres = cursorRepos.map(([root]) => basename6(root));
     const notInstalled = dupes.filter((n) => !installedYours.has(n));
     issues.push({
       id: `plugin:${plugin.id}`,
       severity: bothLoad.length ? "problem" : "suggestion",
       title: `${dupes.join(", ")}: also in the Claude Code plugin ${plugin.id}`,
       detail: [
-        bothLoad.length ? `Claude Code loads both (the plugin's as /${pluginName}:${bothLoad[0]}). Your skill wins.` : "",
+        claudeBoth.length ? `Claude Code loads both (the plugin's as /${pluginName}:${claudeBoth[0]}). Your skill wins.` : "",
+        cursorWheres.length ? `${cursorWheres.join(", ")} ${cursorWheres.length === 1 ? "turns" : "turn"} it off for Claude Code, but Cursor ignores repo settings and lists both there: only turning the plugin off or removing it changes that.` : "",
         notInstalled.length ? `Your ${notInstalled.join(", ")} ${notInstalled.length === 1 ? "is" : "are"} only in Your skills, not installed anywhere: once the plugin is gone, add ${notInstalled.length === 1 ? "it" : "them"} where you need ${notInstalled.length === 1 ? "it" : "them"}.` : "",
-        others ? `The plugin's other ${plural(others, "skill")} are copied into Your skills first, so nothing is lost.` : "",
+        others ? `The plugin's other ${others === 1 ? "skill is" : `${others} skills are`} copied into Your skills first, so nothing is lost.` : "",
         plugin.extras.length ? `It also brings ${plugin.extras.join(", ")}: ${plugin.synced ? "turning it off pauses those" : "removing it drops those, turning it off pauses them"}.` : "",
         plugin.synced ? "It's synced from claude.ai, so it can only be turned off here." : "",
         inRepos.length ? `Or keep it and turn it off only in ${inRepos.map(([root]) => basename6(root)).join(", ")}.` : ""
@@ -1667,7 +1973,11 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
       detail: `${global.plans.map((p) => p.name).join(", ")}: each keeps one copy (in ~/.agents/skills when there's one) and the others become links. Restorable from Health.`,
       fix: {
         label: "Keep one copy of each",
-        run: () => `${plural(applyAll(global.plans, "go").skills, "global skill")} now have one copy`
+        run: () => {
+          const r = applyAll(global.plans, "go");
+          if (!r.skills) throw new Error("No global skill changed");
+          return `${plural(r.skills, "global skill")} now ${r.skills === 1 ? "has" : "have"} one copy`;
+        }
       }
     });
   }
@@ -1679,7 +1989,7 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
       id: "review:global",
       severity: "suggestion",
       title: `${plural(unreviewed.length, "global skill")} of yours ${unreviewed.length === 1 ? "loads" : "load"} in every repo`,
-      detail: `${unreviewed.join(", ")}. Choose which repos keep each (Global \u2192 Clean up\u2026), or mark the ones you want everywhere as global on purpose (skilllib global keep <name>).`
+      detail: `${unreviewed.join(", ")}. Move each to the repos that need it (skilllib \u2192 Global \u2192 Move it to the repos that need it\u2026), or mark the ones you want everywhere as global on purpose (skilllib global keep <name>).`
     });
   }
   const enabled = enabledHarnesses();
@@ -1697,6 +2007,7 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
       run: () => {
         const results = skills.map((m) => ({ m, ...linkGlobal(m.path, blindOf(m)) }));
         const skipped = results.flatMap((r) => r.skipped);
+        if (!results.some((r) => r.linked.length)) throw new Error(`Nothing linked${skipped.length ? `; skipped ${skipped.join(", ")} (a different skill has that name)` : ""}`);
         return `Linked ${plural(results.filter((r) => r.linked.length).length, "global skill")} for ${agentNames(missing)}${skipped.length ? `; skipped ${skipped.join(", ")} (a different skill has that name)` : ""}`;
       }
     };
@@ -1714,28 +2025,69 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
   for (const root of projects2) {
     const where = basename6(root);
     const status2 = statuses.get(root);
-    const behind = status2.filter((s) => s.state === "update available" || s.state === "folder missing");
-    if (behind.length > 0) {
+    const restorable = status2.filter((s) => s.state === "folder missing" && s.latest !== null);
+    if (restorable.length > 0) {
       issues.push({
         id: `sync:${root}`,
         severity: "problem",
-        title: `${where}: ${plural(behind.length, "skill")} out of date`,
-        detail: behind.map((s) => s.name).join(", "),
+        title: `${where}: ${plural(restorable.length, "skill")} in skilllib.json not installed`,
+        detail: `${restorable.map((s) => s.name).join(", ")}: the folder is missing`,
         fix: {
           label: "Sync the project",
           run: () => {
             const changes = syncProject(root);
-            return `${where}: ${changes.filter((c) => c.action !== "skipped").length} updated`;
+            const done = changes.filter((c) => c.action !== "skipped");
+            const skipped = changes.filter((c) => c.action === "skipped").map((c) => `${c.name}: ${c.reason}`);
+            if (!done.length) throw new Error(`${where}: nothing restored${skipped.length ? `; ${skipped.join("; ")}` : ""}`);
+            return `${where}: restored ${plural(done.length, "skill")}${skipped.length ? `; skipped ${skipped.join("; ")}` : ""}`;
           }
         }
       });
     }
+    for (const s of status2.filter((s2) => s2.state === "folder missing" && s2.latest === null))
+      issues.push({
+        id: `unavailable:${root}:${s.name}`,
+        severity: "problem",
+        title: `${s.name}: pinned in ${where}'s skilllib.json, but not in your library`,
+        detail: `Its folder is missing, and your library (${tildify(libraryDir())}) has no copy to restore: import it, or set SKILLLIB_HOME to the library that has it.`,
+        // Editing skilllib.json is the team's call: a choice, never run by `doctor --fix`.
+        choices: [
+          {
+            label: "Remove it from skilllib.json",
+            hint: `${where} stops pinning it`,
+            run: () => {
+              const r = removeSkill(root, s.name);
+              if (r.action !== "removed") throw new Error(`${s.name}: ${r.reason}`);
+              return `${s.name}: removed from ${where}'s skilllib.json`;
+            }
+          }
+        ]
+      });
+    const behind = status2.filter((s) => s.state === "update available");
+    if (behind.length > 0)
+      issues.push({
+        id: `update:${root}`,
+        severity: "suggestion",
+        title: `${where}: ${plural(behind.length, "skill")} out of date`,
+        detail: behind.map((s) => `${s.name} (v${s.version} \u2192 v${s.latest})`).join(", "),
+        fix: {
+          label: "Update to the newest versions",
+          run: () => {
+            const changes = updateProject(root, behind.map((s) => s.name));
+            const done = changes.filter((c) => c.action !== "skipped");
+            const skipped = changes.filter((c) => c.action === "skipped").map((c) => `${c.name}: ${c.reason}`);
+            if (!done.length) throw new Error(`${where}: nothing updated${skipped.length ? `; ${skipped.join("; ")}` : ""}`);
+            return `${where}: updated ${plural(done.length, "skill")}${skipped.length ? `; skipped ${skipped.join("; ")}` : ""}`;
+          }
+        }
+      });
     const tidy2 = planProjectTidy(root);
     if (tidy2.plans.length) {
-      const git2 = gitInfo(root);
-      const visible2 = tidy2.plans.flatMap((p) => gitVisibleSteps(p, git2).map((s) => describeStep(s, root)));
+      const git3 = gitInfo(root);
+      const visible2 = tidy2.plans.flatMap((p) => gitVisibleSteps(p, git3).map((s) => describeStep(s, root)));
       const run = (mode) => () => {
         const r = applyAll(tidy2.plans, mode);
+        if (!r.skills) throw new Error(`${where}: nothing tidied${r.held ? `; left ${plural(r.held, "change")} git would see` : ""}`);
         return `${where}: tidied ${plural(r.skills, "skill")}${r.held ? `; left ${plural(r.held, "change")} git would see` : ""}`;
       };
       issues.push({
@@ -1752,14 +2104,24 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
       });
     }
     issues.push(...tidy2.conflicts.map(conflictIssue));
-    const partial = status2.filter((s) => s.state !== "folder missing" && s.visibility.some((v) => v.paths === 0));
+    const blindHere = status2.filter((s) => s.state !== "folder missing" && s.visibility.some((v) => v.paths === 0)).map((s) => ({ s, would: linkEverywhere(root, s.name, s.location, { dryRun: true }) }));
+    for (const { s, would } of blindHere.filter(({ would: w }) => !w.created.length && !w.blocked.length && w.uncommitted.length))
+      issues.push({
+        id: `uncommitted:${root}:${s.name}`,
+        severity: "suggestion",
+        title: `${s.name} in ${where}: ${agentNames(s.visibility.filter((v) => v.paths === 0).map((v) => v.id))} can't use it until it's committed`,
+        detail: `Git tracks ${would.uncommitted.join(", ")}, but not ${s.location}/${s.name}: a link there would be broken for teammates. Commit it, then link it (\`skilllib link --allow-tracked\`, or from Health).`
+      });
+    const partial = blindHere.filter(({ would }) => would.created.length || would.blocked.length).map(({ s }) => s);
     if (partial.length) {
       const missing = [...new Set(partial.flatMap((s) => s.visibility.filter((v) => v.paths === 0).map((v) => v.id)))];
-      const tracked = readConfig().agentsDirOk?.includes(root) ? [] : [...new Set(missing.map((id) => harness(id).projectDirs[0]))].filter((dir) => isGitTracked(root, dir));
+      const tracked = [...new Set(blindHere.flatMap(({ would }) => would.blocked))];
       const run = (allowTracked) => () => {
         if (allowTracked) allowTrackedLinks(root);
         const r = linkAll(root, { allowTracked });
-        return `${where}: linked ${plural(r.linked.length, "skill")} for ${agentNames(missing)}${r.blocked.length ? `; skipped ${r.blocked.join(", ")} (git tracks it)` : ""}`;
+        const notes = `${r.blocked.length ? `; skipped ${r.blocked.join(", ")} (git tracks ${r.blocked.length === 1 ? "it" : "them"})` : ""}${r.uncommitted.length ? `; ${r.uncommitted.join(", ")} not linked into folders git tracks (not committed, so teammates would get broken links)` : ""}`;
+        if (!r.linked.length) throw new Error(`${where}: nothing linked${notes}`);
+        return `${where}: linked ${plural(r.linked.length, "skill")} for ${agentNames(missing)}${notes}`;
       };
       issues.push({
         id: `usable:${root}`,
@@ -1768,20 +2130,40 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
         detail: `${partial.map((s) => `${s.name} (not ${agentNames(s.visibility.filter((v) => v.paths === 0).map((v) => v.id))})`).join(", ")}. Adding links makes the one real copy reach every agent you use; nothing is copied or moved.${tracked.length ? ` Git tracks ${tracked.join(", ")}, so links there show in git status.` : ""}`,
         ...tracked.length ? {
           choices: [
-            { label: "Add links, but not where git tracks the folder", hint: `skips ${tracked.join(", ")}`, run: run(false) },
+            // Only when some link goes where git doesn't track: otherwise this one would link nothing.
+            ...blindHere.some(({ would }) => would.created.length) ? [{ label: "Add links, but not where git tracks the folder", hint: `skips ${tracked.join(", ")}`, run: run(false) }] : [],
             { label: "Add links everywhere", hint: `remembered for ${where}; git will see them`, run: run(true) }
           ]
         } : { fix: { label: "Add the links", run: run(false) } }
       });
     }
     const differing = new Set(tidy2.conflicts.map((c) => c.name));
+    const git2 = gitInfo(root);
+    const committed = (s) => ["committed", "changed"].includes(git2?.of(relativeTo(root, s.path)) ?? "");
     for (const s of status2) {
       if (isLink(s.path) || differing.has(s.name)) continue;
-      if (s.state === "local only") {
+      if (s.state === "local only" && committed(s)) {
         issues.push({
           id: `local:${root}:${s.name}`,
           severity: "suggestion",
-          title: `${s.name}: only exists in ${where}`,
+          title: `${s.name} in ${where} isn't in your library`,
+          detail: "Copy it into the library to reuse it in other projects. The repo's copy stays as it is: it's the team's (committed).",
+          choices: [
+            {
+              label: "Copy into the library",
+              hint: `${where}'s copy stays as it is`,
+              run: () => {
+                importSkill(s.path);
+                return `${s.name} copied into your library; ${where}'s copy stays as it is`;
+              }
+            }
+          ]
+        });
+      } else if (s.state === "local only") {
+        issues.push({
+          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.",
           choices: [
             {
@@ -1805,17 +2187,17 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
         });
       }
       if (s.state === "edited locally" || s.state === "edited locally, update available") {
-        const newer = s.state !== "edited locally";
+        const newer2 = s.state !== "edited locally";
         const pinned = s.version ? `v${s.version}` : "the library version";
         issues.push({
           id: `edited:${root}:${s.name}`,
           severity: "suggestion",
           title: `${s.name} in ${where} has local edits`,
-          detail: `It no longer matches ${pinned} from Your skills${newer ? `, and v${s.latest} is out` : ""}. Save the edits as a new version so your other repos can get them, or discard them. Keeping them is fine too: skilllib never overwrites edits.`,
+          detail: `It no longer matches ${pinned} from Your skills${newer2 ? `, and v${s.latest} is out` : ""}. Save the edits as a new version so your other repos can get them, or discard them. Keeping them is fine too: skilllib never overwrites edits.`,
           choices: [
             {
               label: "Save as a new version in Your skills",
-              hint: newer ? `becomes v${s.latest + 1}; v${s.latest}'s changes aren't merged in` : `becomes v${(s.latest ?? 0) + 1}; ${where} uses it`,
+              hint: newer2 ? `becomes v${s.latest + 1}; v${s.latest}'s changes aren't merged in` : `becomes v${(s.latest ?? 0) + 1}; ${where} uses it`,
               run: () => {
                 importSkill(s.path, { force: true });
                 const c = addSkill(root, s.name);
@@ -1984,7 +2366,7 @@ function groupBy(items) {
 }
 var sameSet = (a, b) => a.length === b.length && a.every((x) => b.includes(x));
 function globalFrom(kind, origin, path) {
-  if (kind === "global") return tildify(path.replace(/[\\/][^\\/]+$/, "")).replace(/\\/g, "/");
+  if (kind === "global" || kind === "skilllib") return tildify(path.replace(/[\\/][^\\/]+$/, "")).replace(/\\/g, "/");
   return origin;
 }
 var SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "target", "vendor", "coverage"]);
@@ -1997,28 +2379,34 @@ function topLevel(root) {
 }
 function usableHere(root, uses = /* @__PURE__ */ new Map()) {
   const agents = enabledHarnesses();
-  const git2 = gitInfo(root);
-  const inRepo = isProjectCandidate(root) && (existsSync12(join13(root, ".git")) || existsSync12(join13(root, MANIFEST_FILE)));
-  const project = inRepo ? projectStatus(root) : [];
-  const skills = groupBy(
-    project.map((s) => {
+  const inRepo = projectHere(root) === root;
+  const nestedHere = inRepo ? nestedSkills(root, { enabled: agents }) : [];
+  const git2 = gitInfo(root, [...new Set(nestedHere.map((s) => s.location))]);
+  const group = (list2) => groupBy(
+    list2.map((s) => {
       const loadedBy = s.visibility.filter((v) => v.paths > 0).map((v) => v.id);
       const behind = s.managed && s.latest !== null && s.version !== null && s.latest > s.version;
+      const gitState = git2?.of(relativeTo(root, s.path));
+      const repo = !s.managed && (s.state.startsWith("repo skill") || gitState === "committed" || gitState === "changed");
+      const usual = s.state === "ok" || s.state === "local only" || repo && s.state !== "from npx skills";
       const attrs = {
-        source: s.managed ? "library" : s.state.startsWith("repo skill") ? "repo" : "local",
-        ...s.location !== ".claude/skills" && { dir: s.location },
-        ...s.version !== null && { version: s.version },
-        ...s.state !== "ok" && s.state !== "local only" && !s.state.startsWith("repo skill") && { state: s.state },
-        ...behind && { latest: s.latest },
-        ...git2 && { git: git2.of(relativeTo(root, s.path)) },
-        ...!sameSet(loadedBy, agents) && { agents: loadedBy }
+        source: s.managed ? "library" : repo ? "repo" : "local",
+        dir: s.location !== ".claude/skills" ? s.location : void 0,
+        version: s.version ?? void 0,
+        state: usual ? void 0 : s.state,
+        latest: behind ? s.latest : void 0,
+        git: gitState,
+        agents: sameSet(loadedBy, agents) ? void 0 : loadedBy
       };
       return [JSON.stringify(attrs), s.name, () => ({ ...attrs, skills: [] })];
     })
   );
+  const skills = group(inRepo ? projectStatus(root) : []);
+  const nested = group(nestedHere);
   const machine = machineSkills(agents);
+  const loaded = inRepo ? skillsLoadedIn(root, machine, agents) : machine;
   const global = groupBy(
-    machine.filter((m) => !m.broken && m.harnesses.length > 0).map((m) => {
+    loaded.filter((m) => !m.broken && m.harnesses.length > 0).map((m) => {
       const from = globalFrom(m.kind, m.origin, m.path);
       return [`${m.kind}\0${from}\0${m.harnesses.join()}`, m.name, () => ({ source: m.kind, from, agents: m.harnesses, skills: [] })];
     })
@@ -2027,7 +2415,7 @@ function usableHere(root, uses = /* @__PURE__ */ new Map()) {
   for (const i of findIssues(inRepo ? [root] : [], machine, new Set(librarySkills().map((l) => l.name)))) {
     const choices = i.choices?.map((c) => c.label);
     const key = `${i.detail}\0${i.fix?.label ?? ""}\0${choices?.join() ?? ""}`;
-    const issue = issues.get(key) ?? { problems: [], detail: i.detail, ...i.fix && { fix: i.fix.label }, ...choices && { choices } };
+    const issue = issues.get(key) ?? { problems: [], detail: i.detail, fix: i.fix?.label, choices };
     issue.problems.push(i.title);
     issues.set(key, issue);
   }
@@ -2037,9 +2425,10 @@ function usableHere(root, uses = /* @__PURE__ */ new Map()) {
     files: topLevel(root),
     agents,
     skills,
+    nested: nested.length > 0 ? nested : void 0,
     global,
     issues: [...issues.values()],
-    ...Object.keys(usesHere).length > 0 && { usesHere }
+    usesHere: Object.keys(usesHere).length > 0 ? usesHere : void 0
   };
 }
 function firstSentence(description) {
@@ -2047,21 +2436,21 @@ function firstSentence(description) {
   const sentence = line.match(/^(.{40,}?[.!?])(?:\s|$)/)?.[1] ?? line;
   return sentence.length > 200 ? sentence.slice(0, 199).trimEnd() + "\u2026" : sentence;
 }
-function libraryFor(currentProject2) {
+function libraryFor(currentProject) {
   const manifests = visibleProjects().map((p) => ({ name: basename7(p), skills: readManifest(p).skills }));
-  const here = currentProject2 ? new Set(projectStatus(currentProject2).map((s) => s.name)) : null;
+  const here = currentProject ? new Set(projectStatus(currentProject).map((s) => s.name)) : null;
   const all = librarySkills();
-  const describe = (s) => {
+  const describe2 = (s) => {
     const projects2 = manifests.filter((m) => s.name in m.skills).map((m) => m.name);
-    return { name: s.name, description: firstSentence(s.description), ...projects2.length > 0 && { projects: projects2 } };
+    return { name: s.name, description: firstSentence(s.description), projects: projects2.length > 0 ? projects2 : void 0 };
   };
-  if (!here) return { skills: all.map(describe) };
-  return { inThisProject: all.filter((s) => here.has(s.name)).map((s) => s.name), skills: all.filter((s) => !here.has(s.name)).map(describe) };
+  if (!here) return { skills: all.map(describe2) };
+  return { inThisProject: all.filter((s) => here.has(s.name)).map((s) => s.name), skills: all.filter((s) => !here.has(s.name)).map(describe2) };
 }
 
 // src/usage.ts
-import { createReadStream, existsSync as existsSync13, readdirSync as readdirSync8, statSync as statSync3 } from "fs";
-import { join as join14 } from "path";
+import { createReadStream, existsSync as existsSync12, readdirSync as readdirSync8, statSync as statSync4 } from "fs";
+import { join as join13 } from "path";
 import { createInterface } from "readline";
 var BUILTIN_COMMANDS = /* @__PURE__ */ new Set([
   "add-dir",
@@ -2141,12 +2530,12 @@ function usesFromTranscriptLine(line) {
   return [];
 }
 function transcriptFiles(sinceMs) {
-  const base = join14(claudeDir(), "projects");
-  if (!existsSync13(base)) return [];
+  const base = join13(claudeDir(), "projects");
+  if (!existsSync12(base)) return [];
   return readdirSync8(base).flatMap((project) => {
-    const dir = join14(base, project);
-    if (!statSync3(dir).isDirectory()) return [];
-    return readdirSync8(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join14(dir, f)).filter((f) => statSync3(f).mtimeMs >= sinceMs);
+    const dir = join13(base, project);
+    if (!statSync4(dir).isDirectory()) return [];
+    return readdirSync8(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join13(dir, f)).filter((f) => statSync4(f).mtimeMs >= sinceMs);
   });
 }
 async function scanUsage(days) {
@@ -2210,29 +2599,40 @@ function parseArgs(argv) {
 function colorState(state) {
   if (state === "ok") return green(state);
   if (state === "folder missing" || state === "not in library") return red(state);
-  if (state === "local only" || state === "from npx skills") return dim(state);
+  if (state === "local only" || state === "from npx skills" || state === "repo skill") return dim(state);
   return yellow(state);
 }
 function withDirs(root, changes) {
   const { skills } = readManifest(root);
   return changes.map((c) => {
-    const dep = c.action === "installed" || c.action === "updated" ? skills[c.name] : void 0;
+    const dep = c.action === "installed" || c.action === "updated" || c.action === "reset" ? skills[c.name] : void 0;
     return dep ? { ...c, dirs: [dep.dir ?? ".claude/skills", ...dep.links ?? []] } : c;
   });
 }
 function printChanges(root, changes, args) {
-  if (args.json) return json(withDirs(root, changes));
+  if (changes.some((c) => c.action === "skipped")) process.exitCode = 1;
+  if (args.json) return json("changes", withDirs(root, changes));
   for (const c of changes) {
     if (c.blocked?.length) {
       warn(`${c.name}: git tracks ${c.blocked.join(", ")} here, so no link was added there. Re-run with --allow-tracked to add it.`);
     }
-    if (c.action === "skipped") warn(`${c.name}: ${c.reason}`);
+    if (c.uncommitted?.length) {
+      warn(
+        `${c.name}: git tracks ${c.uncommitted.join(", ")} here but not ${c.name}'s real copy, so no link was added there (teammates would get a broken link). Commit ${c.name} first, then run skilllib link --allow-tracked.`
+      );
+    }
+    if (c.action === "skipped") error(`${c.name}: ${c.reason}`);
     else {
-      const icon = c.action === "removed" ? red("-") : green(c.action === "installed" ? "+" : "\u2191");
+      const icon = c.action === "removed" ? red("-") : c.action === "reset" ? yellow("\u21BA") : green(c.action === "installed" ? "+" : "\u2191");
       const versions = c.action === "removed" ? "" : c.from && c.from !== c.to ? ` v${c.from} \u2192 v${c.to}` : c.to ? ` v${c.to}` : "";
       info(`  ${icon} ${c.name}${versions} ${dim(c.action)}`);
     }
+    if (c.backedUp) info(dim(`    local edits saved to ${tildify(c.backedUp)}; \`skilllib restore ${c.name}\` brings them back`));
   }
+  const done = changes.filter((c) => c.action !== "skipped").length;
+  const skipped = changes.length - done;
+  if (skipped && done) info(dim(`
+${done} done, ${skipped} skipped`));
 }
 function projectOfFactory(projects2) {
   const sorted = [...projects2].sort((a, b) => b.length - a.length);
@@ -2250,35 +2650,51 @@ async function usageBySkill(days, onlyProject) {
   const scoped = onlyProject ? uses.filter((u) => projectOf(u.cwd) === onlyProject) : uses;
   return new Map(summarize(scoped, projectOf).map((s) => [s.skill, s]));
 }
-function currentProject() {
-  const root = findProjectRoot();
-  return isProjectCandidate(root) && (existsSync14(join15(root, ".git")) || existsSync14(join15(root, "skilllib.json"))) ? root : null;
+function requireProject() {
+  const root = projectHere();
+  if (root) return root;
+  if (!isProjectCandidate(findProjectRoot())) {
+    const stray = existsSync13(join14(userHome(), MANIFEST_FILE)) ? `, though ${tildify(join14(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).");
 }
 function lastUsed(summary) {
   return summary ? summary.lastUsed.slice(0, 10) : "-";
 }
 async function status(args) {
-  const root = findProjectRoot();
   if (args.json) {
-    const usage3 = await usageBySkill(args.days, root);
-    json(usableHere(root, new Map([...usage3].map(([name, u]) => [name, u.uses]))));
-    if (currentProject()) rememberProjects([root]);
+    const root2 = findProjectRoot();
+    const usage3 = await usageBySkill(args.days, root2);
+    json("status", usableHere(root2, new Map([...usage3].map(([name, u]) => [name, u.uses]))));
+    if (projectHere()) rememberProjects([root2]);
     return;
   }
+  const root = requireProject();
   const skills = projectStatus(root);
   const nested = nestedSkills(root);
   info(`${basename8(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>");
-    return;
-  }
+  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);
+  const git2 = gitInfo(root, [...new Set(nested.map((s) => s.location))]);
+  const committed = (path) => ["committed", "changed"].includes(git2?.of(relativeTo(root, path)) ?? "");
+  const asRepo = {
+    "local only": "repo skill",
+    "untracked copy of library skill": "repo skill, in library",
+    "untracked, differs from library": "repo skill, differs from library"
+  };
+  const stateOf = (s) => colorState(committed(s.path) && asRepo[s.state] || s.state);
+  const agentsOf = (s) => {
+    const ids = s.visibility.filter((v) => v.paths > 0).map((v) => v.id);
+    return ids.length === s.visibility.length ? dim("all") : ids.length ? ids.map((id) => harness(id).name).join(", ") : red("none");
+  };
   if (skills.length) {
     table(
       skills.map((s) => ({
         Skill: s.name,
-        Status: s.source ? dim(`npx skills: ${s.source}`) : colorState(s.state),
+        Status: s.source ? dim(`npx skills: ${s.source}`) : stateOf(s),
+        Agents: agentsOf(s),
         [`Uses (${args.days}d)`]: String(usage2.get(s.name)?.uses ?? 0),
         "Last used": lastUsed(usage2.get(s.name))
       }))
@@ -2290,7 +2706,8 @@ async function status(args) {
       nested.map((s) => ({
         Skill: s.name,
         Folder: s.location,
-        Status: colorState(s.state),
+        Status: stateOf(s),
+        Agents: agentsOf(s),
         [`Uses (${args.days}d)`]: String(usage2.get(s.name)?.uses ?? 0)
       }))
     );
@@ -2298,18 +2715,32 @@ async function status(args) {
   const states = new Set(skills.map((s) => s.state));
   const hints = [];
   if (states.has("update available")) hints.push("`skilllib update` to install the newest versions");
-  if (states.has("folder missing")) hints.push("`skilllib sync` to restore missing skills");
+  const missing = skills.filter((s) => s.state === "folder missing");
+  if (missing.some((s) => s.latest !== null)) hints.push("`skilllib sync` to restore missing skills");
+  const notInLibrary = missing.filter((s) => s.latest === null).map((s) => s.name);
+  if (notInLibrary.length)
+    hints.push(`${notInLibrary.join(", ")} ${notInLibrary.length === 1 ? "isn't" : "aren't"} in your library (${tildify(libraryDir())}): \`skilllib import <dir>\` to add, or set SKILLLIB_HOME to the library that has ${notInLibrary.length === 1 ? "it" : "them"}`);
   if (states.has("edited locally") || states.has("edited locally, update available"))
     hints.push("`skilllib import .claude/skills/<name> --force` to save local edits to the library");
   if (states.has("local only")) hints.push("`skilllib import .claude/skills/<name>` to add a local skill to the library");
   if (states.has("untracked copy of library skill") || states.has("untracked, differs from library"))
     hints.push("`skilllib add <name>` to manage an untracked skill (--force if it differs)");
   if (hints.length > 0) info("\n" + hints.map((h) => dim(`\u2192 ${h}`)).join("\n"));
+  const here = usableHere(root);
+  const globals = new Set(here.global.flatMap((g) => g.skills)).size;
+  if (globals) info(`
+${globals} global ${globals === 1 ? "skill also loads" : "skills also load"} here ${dim("(your global folders, plugins, claude.ai): `skilllib` lists them")}`);
+  const problems = here.issues.reduce((n, i) => n + i.problems.length, 0);
+  if (problems) warn(`${problems} ${problems === 1 ? "issue" : "issues"} here or in your global skills: \`skilllib doctor\` lists them with fixes`);
   rememberProjects([root]);
 }
+async function overview(args) {
+  if (args.json || projectHere()) return status(args);
+  info("Not in a project. `skilllib projects` lists yours, `skilllib list` your library, `skilllib global` your global skills.");
+}
 async function list(args) {
   if (args.json) {
-    return json(libraryFor(currentProject()));
+    return json("list", libraryFor(projectHere()));
   }
   const skills = librarySkills();
   if (skills.length === 0) {
@@ -2337,14 +2768,14 @@ async function list(args) {
     );
   }
   const libraryNames = new Set(skills.map((s) => s.name));
-  const globals = machineSkills().filter((m) => m.movable && !m.broken);
+  const globals = [...new Set(machineSkills().filter((m) => m.movable && !m.broken).map((m) => m.name))];
   if (globals.length > 0) {
     info("");
-    warn(`${globals.length} of your global skill(s) still load in every project`);
-    const missing = globals.filter((g) => !libraryNames.has(g.name));
+    warn(`${globals.length} of your global ${globals.length === 1 ? "skill still loads" : "skills still load"} in every project`);
+    const missing = globals.filter((g) => !libraryNames.has(g));
     info(
       dim(
-        missing.length > 0 ? `\u2192 \`skilllib import --global\` copies ${missing.length} of them into the library` : "\u2192 all are in your library; run `skilllib` \u2192 Global skills to stop loading them everywhere"
+        missing.length > 0 ? `\u2192 \`skilllib import --global\` copies ${missing.length} of them into the library` : "\u2192 all are in your library; run `skilllib` \u2192 Global to stop loading them everywhere"
       )
     );
   }
@@ -2353,11 +2784,16 @@ function projects(args) {
   const roots = visibleProjects();
   if (args.json) {
     return json(
-      roots.map((root) => ({
-        name: basename8(root),
-        path: root,
-        skills: projectStatus(root).map((s) => ({ name: s.name, managed: s.managed, state: s.state, version: s.version, latest: s.latest }))
-      }))
+      "projects",
+      roots.map(
+        (root) => ({
+          name: basename8(root),
+          path: root,
+          skills: projectStatus(root).map(
+            (s) => ({ name: s.name, managed: s.managed, state: s.state, version: s.version, latest: s.latest })
+          )
+        })
+      )
     );
   }
   if (roots.length === 0) {
@@ -2384,7 +2820,7 @@ function add(args) {
     error("Usage: skilllib add <skill-name>... [--force]");
     process.exit(1);
   }
-  const root = findProjectRoot();
+  const root = requireProject();
   if (args.allowTracked) allowTrackedLinks(root);
   printChanges(root, args.positional.map((name) => addSkill(root, name, { force: args.force })), args);
   rememberProjects([root]);
@@ -2394,29 +2830,38 @@ function remove(args) {
     error("Usage: skilllib remove <skill-name>... [--force]");
     process.exit(1);
   }
-  const root = findProjectRoot();
+  const root = requireProject();
   printChanges(root, args.positional.map((name) => removeSkill(root, name, { force: args.force })), args);
 }
 function sync(args) {
-  const roots = args.all ? visibleProjects() : [findProjectRoot()];
+  const roots = args.all ? visibleProjects() : [requireProject()];
   const results = roots.map((root) => {
     if (args.allowTracked) allowTrackedLinks(root);
     const changes = syncProject(root, { force: args.force });
+    if (changes.some((c) => c.action === "skipped")) process.exitCode = 1;
     if (!args.json) {
       if (args.all) info(`${basename8(root)} ${dim(tildify(root))}`);
-      if (changes.length === 0) success("Installed versions match skilllib.json");
-      else printChanges(root, changes, args);
+      if (changes.length === 0) {
+        if (existsSync13(join14(root, MANIFEST_FILE))) success("Installed versions match skilllib.json");
+        else info(dim("No skilllib.json: nothing to sync"));
+      } else printChanges(root, changes, args);
     }
     return { project: basename8(root), path: root, changes: withDirs(root, changes) };
   });
-  if (args.json) json(args.all ? results : results[0].changes);
+  if (args.json) args.all ? json("changes --all", results) : json("changes", results[0].changes);
   if (!args.all) rememberProjects(roots);
 }
 function update(args) {
-  const roots = args.all ? visibleProjects() : [findProjectRoot()];
+  const roots = args.all ? visibleProjects() : [requireProject()];
   const results = roots.map((root) => {
     if (args.allowTracked) allowTrackedLinks(root);
-    const changes = updateProject(root, args.positional.length ? args.positional : void 0, { force: args.force });
+    const names = args.positional.length ? args.positional : void 0;
+    const changes = updateProject(root, names, { force: args.force });
+    if (!args.all) {
+      const { skills } = readManifest(root);
+      for (const name of names ?? []) if (!(name in skills)) changes.push({ name, action: "skipped", reason: "not managed by skilllib in this project" });
+    }
+    if (changes.some((c) => c.action === "skipped")) process.exitCode = 1;
     if (!args.json) {
       if (args.all) info(`${basename8(root)} ${dim(tildify(root))}`);
       if (changes.length === 0) success("Everything is on the latest version");
@@ -2424,14 +2869,14 @@ function update(args) {
     }
     return { project: basename8(root), path: root, changes: withDirs(root, changes) };
   });
-  if (args.json) json(args.all ? results : results[0].changes);
+  if (args.json) args.all ? json("changes --all", results) : json("changes", results[0].changes);
 }
 function outdated(args) {
-  const roots = args.all ? visibleProjects() : [findProjectRoot()];
+  const roots = args.all ? visibleProjects() : [requireProject()];
   const behind = roots.flatMap(
     (root) => projectStatus(root).filter((s) => s.managed && s.latest !== null && s.version !== null && s.latest > s.version).map((s) => ({ project: basename8(root), path: root, skill: s.name, installed: s.version, latest: s.latest, state: s.state }))
   );
-  if (args.json) return json(behind);
+  if (args.json) return json("outdated", behind);
   const rows = behind.map((b) => ({ Project: b.project, Skill: b.skill, Installed: `v${b.installed}`, Latest: `v${b.latest}`, Status: colorState(b.state) }));
   if (rows.length === 0) return success("Everything is on the latest version");
   table(rows);
@@ -2439,7 +2884,7 @@ function outdated(args) {
 \u2192 skilllib update${args.all ? " --all" : ""}`));
 }
 function importSkills(args) {
-  const dirs = args.global ? machineSkills().filter((m) => m.movable && !m.broken).map((m) => m.path) : args.positional.map((p) => resolve4(p));
+  const dirs = args.global ? machineSkills().filter((m) => m.movable && !m.broken).map((m) => m.path) : args.positional.map((p) => resolve7(p));
   if (dirs.length === 0) {
     error("Usage: skilllib import <skill-dir>... [--force] | skilllib import --global");
     process.exit(1);
@@ -2458,9 +2903,9 @@ function importSkills(args) {
       continue;
     }
     success(`${name} ${dim(result === "unchanged" ? "already in library" : result === "added" ? "added to library" : "library updated")}`);
-    const skillsDir = resolve4(dir, "..");
-    const root = resolve4(skillsDir, "..", "..");
-    if (skillsDir === join15(root, ".claude", "skills") && isProjectCandidate(root)) {
+    const skillsDir = resolve7(dir, "..");
+    const root = resolve7(skillsDir, "..", "..");
+    if (skillsDir === join14(root, ".claude", "skills") && isProjectCandidate(root)) {
       if (readManifest(root).skills[name]?.hash !== treeHash(dir)) {
         const change = addSkill(root, name);
         if (change.action !== "skipped") info(dim(`  ${basename8(root)} now depends on ${name} v${change.to}`));
@@ -2468,7 +2913,7 @@ function importSkills(args) {
       rememberProjects([root]);
     }
   }
-  if (args.json) json(results);
+  if (args.json) json("import", results);
 }
 function scan(args) {
   for (const p of args.positional) addRoot(p);
@@ -2479,24 +2924,34 @@ function scan(args) {
   }
   const found = discoverProjects();
   const library = new Set(librarySkills().map((s) => s.name));
-  const skillNames = (root) => [...skillDirsIn(projectSkillsDir(root)), ...skillDirsIn(agentsSkillsDir(root))].map((d) => basename8(d));
+  const skillNames = (root) => [
+    .../* @__PURE__ */ new Set([...ALL_PROJECT_DIRS.flatMap((d) => skillDirsIn(join14(root, d))).map((d) => basename8(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(s), ${withSkills.length} with skills
+  info(`Scanned ${roots.map((r) => tildify(r)).join(", ")}: ${found.length} project${found.length === 1 ? "" : "s"}, ${withSkills.length} with skills
 `);
   table(
     withSkills.map((root) => ({
       Project: basename8(root),
       Path: dim(tildify(root)),
-      Skills: [...new Set(skillNames(root))].map((n) => library.has(n) ? n : yellow(n)).join(", ")
+      Skills: skillNames(root).map((n) => library.has(n) ? n : yellow(n)).join(", ")
     }))
   );
   if (withSkills.length > 0) info(`
-${yellow("Yellow")} skills aren't in your library yet (import them from \`skilllib\` \u2192 3 Sources or 5 Health).`);
+${yellow("Yellow")} skills aren't in your library yet (\`skilllib import <skill-dir>\`, or \`skilllib\` \u2192 Health).`);
 }
 function folders(args) {
   const [action, ...paths] = args.positional;
+  let failed = false;
   if (action === "add") {
-    for (const p of paths) success(`Added ${tildify(addRoot(p))}`);
+    for (const p of paths) {
+      try {
+        success(`Added ${tildify(addRoot(p))}`);
+      } catch (e) {
+        error(e.message);
+        failed = true;
+      }
+    }
     discoverProjects();
   } else if (action === "remove" || action === "rm") {
     for (const p of paths) {
@@ -2508,12 +2963,24 @@ function folders(args) {
   info(roots.length ? `Project folders:
 ${roots.map((r) => `  ${tildify(r)}`).join("\n")}` : "No project folders. Add one: skilllib folders add ~/Projects");
   if (hidden.length) info(dim(`Hidden projects: ${hidden.map((h) => tildify(h)).join(", ")}  (skilllib unhide <path>)`));
+  if (failed) process.exit(1);
 }
 function unhide(args) {
+  if (args.positional.length === 0) {
+    error("Usage: skilllib unhide <path>...");
+    process.exit(1);
+  }
+  let failed = false;
   for (const p of args.positional) {
-    setHidden(expandHome(p), false);
-    success(`${tildify(expandHome(p))} is visible again`);
+    const path = expandHome(p);
+    if (setHidden(path, false)) success(`${tildify(path)} is visible again`);
+    else {
+      const { hidden } = readConfig();
+      error(`${tildify(path)} wasn't hidden. ${hidden.length ? `Hidden projects: ${hidden.map((h) => tildify(h)).join(", ")}` : "No projects are hidden."}`);
+      failed = true;
+    }
   }
+  if (failed) process.exit(1);
 }
 function newSkill(args) {
   const [name, ...rest] = args.positional;
@@ -2526,14 +2993,14 @@ function newSkill(args) {
     error(`Can't create ${name}: ${r.reason}`);
     process.exit(1);
   }
-  success(`Created ${tildify(join15(r.dir, "SKILL.md"))}`);
+  success(`Created ${tildify(join14(r.dir, "SKILL.md"))}`);
 }
 function restore(args) {
   const backups = [...listBackups(), ...pluginBackups()];
   const name = args.positional[0];
   if (!name) {
     if (backups.length === 0) return info("Nothing to restore.");
-    table(backups.map((b) => ({ Skill: b.name, From: b.kind === "trash" ? "library (deleted)" : b.kind === "plugin" ? "Claude Code plugin" : tildify(dirname5(b.from)), Moved: b.movedAt })));
+    table(backups.map((b) => ({ Skill: b.name, From: backupFrom(b), Moved: b.movedAt })));
     info(dim("\n\u2192 skilllib restore <name>"));
     return;
   }
@@ -2544,7 +3011,10 @@ function restore(args) {
   }
   const r = backup.kind === "plugin" ? restorePlugin(backup) : restoreBackup(backup);
   if (r.ok) success(`Restored ${name} to ${tildify(r.to)}`);
-  else error(`Can't restore ${name}: ${r.reason}`);
+  else {
+    error(`Can't restore ${name}: ${r.reason}`);
+    process.exitCode = 1;
+  }
 }
 async function doctor(args) {
   const projects2 = visibleProjects();
@@ -2564,14 +3034,25 @@ async function doctor(args) {
       })
     );
   }
+  const fixed = (fix) => {
+    const r = runFix(fix);
+    if (!r.ok) process.exitCode = 1;
+    return r;
+  };
   if (args.json) {
     return json(
-      issues.map(({ fix, choices, ...issue }) => ({
-        ...issue,
-        ...fix && { fix: fix.label },
-        ...choices && { choices: choices.map((c) => c.label) },
-        ...args.fix && fix && { fixed: runFix(fix) }
-      }))
+      "doctor",
+      issues.map(
+        ({ id, severity, title, detail, fix, choices }) => ({
+          id,
+          severity,
+          title,
+          detail,
+          fix: fix?.label,
+          choices: choices?.map((c) => c.label),
+          fixed: args.fix && fix ? fixed(fix) : void 0
+        })
+      )
     );
   }
   if (issues.length === 0) return success("Everything looks good");
@@ -2580,7 +3061,7 @@ async function doctor(args) {
     info(dim(`  ${issue.detail}${issue.fix ? `  \u2192  ${issue.fix.label}` : ""}`));
     if (issue.choices) info(dim(`  choose in skilllib \u2192 Health: ${issue.choices.map((c) => c.label).join(" / ")}`));
     if (args.fix && issue.fix) {
-      const r = runFix(issue.fix);
+      const r = fixed(issue.fix);
       info(`  ${r.ok ? green("\u2713") : red("\u2717")} ${r.message}`);
     }
   }
@@ -2590,7 +3071,7 @@ async function usage(args) {
   const summaries = summarize(await scanUsage(args.days), projectOfFactory(knownProjects()));
   if (args.json) {
     const library2 = new Set(librarySkills().map((s) => s.name));
-    return json({
+    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) => basename8(p)), inLibrary: library2.has(s.skill) })),
@@ -2602,7 +3083,7 @@ async function usage(args) {
     return;
   }
   const library = new Set(librarySkills().map((s) => s.name));
-  info(`Skill usage, last ${args.days} days ${dim(`(from ${tildify(join15(claudeDir(), "projects"))})`)}
+  info(`Skill usage, last ${args.days} days ${dim(`(from ${tildify(join14(claudeDir(), "projects"))})`)}
 `);
   table(
     summaries.map((s) => ({
@@ -2621,21 +3102,21 @@ async function usage(args) {
 }
 function show(args) {
   const name = args.positional[0];
-  const dir = name ? join15(libraryDir(), name) : "";
+  const dir = name ? join14(libraryDir(), name) : "";
   if (!name || !isSkillDir(dir)) {
     error(name ? `${name} is not in the library` : "Usage: skilllib show <skill-name>");
     process.exit(1);
   }
   const { description } = readSkillInfo(dir);
   if (args.json) {
-    return json({
+    return json("show", {
       name,
       description,
       path: dir,
       latest: latestVersion(name)?.version ?? null,
       origin: libraryOrigins()[name] ?? "",
       projects: knownProjects().filter((p) => name in readManifest(p).skills).map((p) => basename8(p)),
-      skillMd: readFileSync9(join15(dir, "SKILL.md"), "utf-8")
+      skillMd: readFileSync9(join14(dir, "SKILL.md"), "utf-8")
     });
   }
   info(`${name} ${dim(tildify(dir))}`);
@@ -2664,14 +3145,21 @@ function harnessesCommand(args) {
 New installs go to ${installDirs(enabled).join(" (real copy) + ")}${installDirs(enabled).length > 1 ? " (link)" : ""}.`));
 }
 function link(args) {
-  const roots = args.all ? visibleProjects() : [findProjectRoot()];
+  const roots = args.all ? visibleProjects() : [requireProject()];
   for (const root of roots) {
     if (args.allowTracked) allowTrackedLinks(root);
     const res = linkAll(root);
     const label = args.all ? `${basename8(root)}: ` : "";
     if (res.linked.length) success(`${label}linked ${res.linked.length} skill(s) for your other agents`);
-    else if (!args.all) success("Every skill here is already usable by all your agents");
-    if (res.blocked.length) warn(`${label}git tracks ${res.blocked.join(", ")}; re-run with --allow-tracked to link there too`);
+    else if (!args.all && !res.blocked.length && !res.uncommitted.length) success("Every skill here is already usable by all your agents");
+    if (res.blocked.length) {
+      process.exitCode = 1;
+      error(`${label}git tracks ${res.blocked.join(", ")}, so ${res.linked.length ? "some skills weren't" : "nothing was"} linked there; re-run with --allow-tracked to link there too`);
+    }
+    if (res.uncommitted.length)
+      warn(
+        `${label}${res.uncommitted.join(", ")} ${res.uncommitted.length === 1 ? "isn't" : "aren't"} committed, so not linked into folders git tracks (teammates would get broken links); commit ${res.uncommitted.length === 1 ? "it" : "them"} first`
+      );
   }
 }
 function globalCommand(args) {
@@ -2692,14 +3180,41 @@ function globalCommand(args) {
   const kept = keptGlobal();
   if (!yours.length) return info("None of your skills load globally.");
   for (const m of yours) info(`${kept.has(m.name) ? green("\u2713") : yellow("\u26A0")} ${m.name.padEnd(32)} ${dim(tildify(m.path))}`);
-  const unreviewed = yours.filter((m) => !kept.has(m.name)).length;
+  const unreviewed = new Set(yours.filter((m) => !kept.has(m.name)).map((m) => m.name)).size;
   if (unreviewed) info(dim(`
 ${unreviewed} not reviewed. Keep one global on purpose: skilllib global keep <name>`));
 }
 function tidy(args) {
   const names = args.positional;
-  const keepFor = (base) => args.keep ? Object.fromEntries(names.map((n) => [n, base ? resolve4(base, args.keep) : expandHome(args.keep)])) : {};
-  const reports = args.global ? [{ label: "global folders", report: planGlobalTidy({ keep: keepFor(null) }) }] : (args.all ? visibleProjects() : [findProjectRoot()]).map((root) => ({ label: basename8(root), report: planProjectTidy(root, { keep: keepFor(root) }) }));
+  const keepFor = (base) => args.keep ? Object.fromEntries(names.map((n) => [n, base ? resolve7(base, args.keep) : expandHome(args.keep)])) : {};
+  if (args.keep && !names.length) {
+    error("Usage: skilllib tidy <name>... --keep <folder>");
+    process.exit(1);
+  }
+  const targets = args.global ? [null] : args.all ? visibleProjects() : [requireProject()];
+  const problems = [];
+  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 ${basename8(targets[0])}`}`);
+      continue;
+    }
+    if (!args.keep) continue;
+    for (const { root, real } of where) {
+      if (real.includes(keepFor(root)[name])) continue;
+      const label = root ? `${basename8(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"}`
+      );
+    }
+  }
+  if (problems.length) {
+    for (const p of problems) error(p);
+    process.exit(1);
+  }
+  const reports = targets.map(
+    (root) => root === null ? { label: "global folders", report: planGlobalTidy({ keep: keepFor(null) }) } : { label: basename8(root), report: planProjectTidy(root, { keep: keepFor(root) }) }
+  );
   let held = 0;
   let changed = 0;
   for (const { label, report } of reports) {
@@ -2714,6 +3229,7 @@ function tidy(args) {
       held += args.dryRun ? 0 : result.held.length;
       changed += result.applied.length;
     }
+    if (args.keep && conflicts.length) process.exitCode = 1;
     for (const c of conflicts) {
       warn(`${label} \xB7 ${c.name}: the copies differ`);
       for (const copy of c.copies) {
@@ -2737,7 +3253,7 @@ function agentSkill(args) {
       error(`Can't install the skilllib skill: ${r.reason}`);
       process.exit(1);
     }
-    if (args.json) return json({ state: agentSkillState(), dirs: r.dirs });
+    if (args.json) return json("agent-skill", { state: agentSkillState(), dirs: r.dirs });
     success(`Installed in ${r.dirs.map((d) => tildify(d)).join(" and ")}`);
     if (!onPath("skilllib")) warn("`skilllib` isn't on your PATH, so agents can't run it. Install it: npm install -g skilllib");
     info(dim("New agent sessions can now answer questions like \u201Cwhich skills can you use here?\u201D"));
@@ -2745,27 +3261,30 @@ function agentSkill(args) {
   }
   if (action === "remove" || action === "rm") {
     const removed = removeAgentSkill();
-    if (args.json) return json({ state: agentSkillState(), removed });
+    if (args.json) return json("agent-skill", { state: agentSkillState(), removed });
     return removed.length ? success(`Removed from ${removed.map((d) => tildify(d)).join(" and ")}`) : info("The skilllib skill isn't installed.");
   }
   const state = agentSkillState();
-  if (args.json) return json({ state, dirs: agentSkillDirs() });
+  if (args.json) return json("agent-skill", { state, dirs: agentSkillDirs() });
   if (state === "installed") success(`Your agents can use skilllib ${dim(`(${agentSkillDirs().map((d) => tildify(d)).join(", ")})`)}`);
   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.");
 }
 
 export {
-  userHome,
   skilllibHome,
+  PROJECT_SKILLS_DIR,
   HARNESSES,
   harness,
   readSkillInfo,
   versionHistory,
   forgetLatest,
   latestVersion,
-  findProjectRoot,
-  isProjectCandidate,
+  projectHere,
+  readManifest,
+  setJsonMode,
+  error,
+  tildify,
   readConfig,
   addRoot,
   removeRoot,
@@ -2778,13 +3297,13 @@ export {
   allowTrackedLinks,
   keptGlobal,
   setKeepGlobal,
-  setPluginEnabled,
   machineSkills,
   skillsLoadedIn,
   libraryOrigins,
   recordOrigin,
   librarySkills,
   librarySkillDir,
+  visibilityOf,
   projectStatus,
   linkEverywhere,
   relinkDependency,
@@ -2802,17 +3321,23 @@ export {
   createSkill,
   listBackups,
   restoreBackup,
-  setJsonMode,
-  error,
   gitInfo,
   relativeTo,
   claudePlugins,
+  installedPlugins,
+  cursorPlugins,
+  forgetClaudeBinary,
   claudeBinary,
   turnOffIn,
-  recordRemovedPlugin,
+  setPluginOn,
+  uninstallPlugin,
+  updatePlugin,
   pluginBackups,
   restorePlugin,
   cursorPluginSkills,
+  agentSkillState,
+  installAgentSkill,
+  removeAgentSkill,
   refreshAgentSkill,
   planProjectTidy,
   planGlobalTidy,
@@ -2820,10 +3345,12 @@ export {
   applyTidy,
   describeStep,
   copyLabel,
+  addedAt,
   scanUsage,
   parseArgs,
   projectOfFactory,
   status,
+  overview,
   list,
   projects,
   add,