skilllib 1.3.1 → 1.7.0

package/dist/{chunk-TWQQHXVG.js → chunk-AYAN7Q2X.js}

@@ -1,18 +1,62 @@
 // 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";
-var color = (code) => (s) => process.stdout.isTTY ? `\x1B[${code}m${s}\x1B[0m` : s;
+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 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";
+
+// src/output.ts
+var jsonMode = false;
+function setJsonMode(on) {
+  jsonMode = on;
+}
+function json(data) {
+  process.stdout.write(JSON.stringify(data) + "\n");
+}
+var color = (code) => (s) => process.stdout.isTTY && !jsonMode ? `\x1B[${code}m${s}\x1B[0m` : s;
 var green = color(32);
 var yellow = color(33);
 var red = color(31);
 var dim = color(2);
-var info = (msg) => console.log(msg);
-var success = (msg) => console.log(`${green("\u2713")} ${msg}`);
-var warn = (msg) => console.log(`${yellow("!")} ${msg}`);
+var out = (msg) => jsonMode ? console.error(msg) : console.log(msg);
+var info = (msg) => out(msg);
+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, " ");
@@ -28,32 +72,14 @@ function table(rows) {
   for (const row of rows) info(keys.map((k, i) => pad(row[k] ?? "", widths[i])).join("  ").trimEnd());
 }
 
-// src/commands.ts
-import { basename as basename6, dirname as dirname5, join as join13, resolve as resolve4, sep as sep5 } from "path";
-
-// 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 { basename as basename3, dirname as dirname2, join as join8, relative as relative2, sep as sep3 } from "path";
+// src/agentSkill.ts
+import { existsSync as existsSync8, lstatSync as lstatSync3, mkdirSync as mkdirSync6, readFileSync as readFileSync7, rmSync as rmSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join9 } from "path";
 
-// src/paths.ts
+// src/config.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");
-}
-var PROJECT_SKILLS_DIR = ".claude/skills";
-var AGENTS_SKILLS_DIR = ".agents/skills";
-var MANIFEST_FILE = "skilllib.json";
+import { join as join6, resolve as resolve4 } from "path";
 
 // src/harnesses.ts
 import { existsSync } from "fs";
@@ -76,8 +102,11 @@ var HARNESSES = [
     short: "Cu",
     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.
     projectDirs: [".agents/skills", ".cursor/skills", ".claude/skills", ".codex/skills"],
-    globalDirs: () => [join2(home(), ".agents", "skills"), join2(home(), ".cursor", "skills"), join2(claudeDir(), "skills"), join2(home(), ".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")),
     installed: () => existsSync(join2(home(), ".cursor")) || onPath("cursor-agent") || hasApp("Cursor")
   },
   {
@@ -86,9 +115,9 @@ var HARNESSES = [
     short: "Cx",
     icon: "\u25CE",
     color: "#10A37F",
-    projectDirs: [".agents/skills"],
-    globalDirs: () => [join2(home(), ".agents", "skills"), "/etc/codex/skills"],
-    installed: () => existsSync(join2(home(), ".codex")) || onPath("codex") || hasApp("Codex")
+    projectDirs: [".agents/skills", ".codex/skills"],
+    globalDirs: () => [join2(home(), ".agents", "skills"), join2(codexHome(), "skills"), codexSystemDir()],
+    installed: () => existsSync(codexHome()) || onPath("codex") || hasApp("Codex")
   },
   {
     id: "zed",
@@ -111,6 +140,7 @@ function hasApp(name) {
 function harness(id) {
   return HARNESSES.find((h) => h.id === id);
 }
+var CURSOR_PICKS = [".cursor", ".claude", ".codex", ".grok", ".agents"];
 var ALL_PROJECT_DIRS = [...new Set(HARNESSES.flatMap((h) => h.projectDirs))];
 var PREFERRED_DIRS = [AGENTS_SKILLS_DIR, PROJECT_SKILLS_DIR];
 function preference(dir) {
@@ -133,15 +163,9 @@ function installDirs(enabled, keep) {
   return [primary, ...best.filter((d) => d !== primary)];
 }
 
-// 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/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";
@@ -149,7 +173,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"]);
@@ -189,7 +213,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 [];
@@ -248,21 +272,17 @@ function getVersion(name, version) {
 
 // src/project.ts
 function findProjectRoot(from = process.cwd()) {
-  let dir = resolve(from);
-  let gitRoot = null;
+  let dir = resolve3(from);
   while (true) {
-    if (existsSync4(join5(dir, MANIFEST_FILE))) return dir;
-    if (!gitRoot && existsSync4(join5(dir, ".git"))) gitRoot = dir;
+    if (existsSync4(join5(dir, MANIFEST_FILE)) || existsSync4(join5(dir, ".git"))) return dir;
     const parent = dirname(dir);
-    if (parent === dir) return gitRoot ?? 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);
@@ -302,14 +322,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");
 }
@@ -331,10 +360,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;
@@ -348,8 +379,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) {
@@ -373,8 +406,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);
@@ -403,9 +436,14 @@ function setKeepGlobal(names, keep) {
   writeConfig({ ...readConfig(), keepGlobal: [...kept].sort() });
 }
 
+// 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 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"));
@@ -414,23 +452,51 @@ 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) => d.startsWith(userHome()));
+  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(
+    (dir) => skillDirsIn(dir).map((path) => ({
+      name: basename2(path),
+      kind: "system",
+      origin: dir.replace(/\\/g, "/"),
+      path,
+      description: readSkillInfo(path).description,
+      movable: false,
+      broken: false,
+      harnesses: harnessesReading(dir, enabled),
+      links: []
+    }))
+  ).filter((s) => s.harnesses.length > 0);
 }
 function globalFolderSkills(enabled) {
   const lock = skillsShLock();
@@ -457,6 +523,10 @@ function globalFolderSkills(enabled) {
     const target_ = e.isLink ? readlinkSync(e.path).replace(/\\/g, "/") : "";
     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: "skilllib", origin: "skilllib", path: e.path, description: readSkillInfo(e.path).description, movable: false, broken: false, harnesses: harnessesReading(e.dir, enabled), links: [] });
+      continue;
+    }
     skills.push({
       name: e.name,
       kind: locked || e.isLink && inAgents ? "skills.sh" : "global",
@@ -478,8 +548,7 @@ 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 cursorBuiltInSkills(enabled) {
   if (!enabled.includes("cursor")) return [];
@@ -495,9 +564,10 @@ function cursorBuiltInSkills(enabled) {
     links: []
   }));
 }
-function claudeAiSkills() {
+function claudeAiSkills(enabled) {
   const synced = join7(claudeDir(), "skills", "synced");
-  if (!existsSync6(synced)) return [];
+  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),
@@ -507,7 +577,7 @@ function claudeAiSkills() {
       description: readSkillInfo(path).description,
       movable: false,
       broken: false,
-      harnesses: ["claude-code"],
+      harnesses,
       links: []
     }))
   );
@@ -520,11 +590,22 @@ function setPluginEnabled(id, on) {
   mkdirSync4(claudeDir(), { recursive: true });
   writeFileSync4(file, JSON.stringify(settings, null, 2) + "\n");
 }
-function pluginSkills() {
+function repoSettingsFiles(root) {
+  return [join7(root, ".claude", "settings.json"), join7(root, ".claude", "settings.local.json")];
+}
+function enabledPlugins(root) {
+  const files = [join7(claudeDir(), "settings.json"), ...root ? repoSettingsFiles(root) : []];
+  return Object.assign({}, ...files.map((f) => readJson(f)?.enabledPlugins ?? {}));
+}
+function pluginSkills(harnesses, root) {
+  const claude2 = harnesses.includes("claude-code");
+  const cursor = harnesses.includes("cursor");
+  if (!claude2 && !cursor) return [];
   const plugins = join7(claudeDir(), "plugins");
-  const enabled = readJson(join7(claudeDir(), "settings.json"))?.enabledPlugins ?? {};
   const installed = readJson(join7(plugins, "installed_plugins.json"))?.plugins ?? {};
-  const fromMarketplaces = Object.entries(enabled).filter(([, on]) => on).flatMap(([id]) => {
+  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] : []),
@@ -532,19 +613,22 @@ function pluginSkills() {
       join7(plugins, "marketplaces", marketplace, "external_plugins", name),
       join7(plugins, "marketplaces", marketplace)
     ];
-    const root = candidates.find((c) => existsSync6(join7(c, "skills")));
-    return root ? skillDirsIn(join7(root, "skills")).map((path) => ({ path, origin: id })) : [];
+    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);
+    const loadedBy = [...claude2 && enabled[id] ? ["claude-code"] : [], ...inCursor ? ["cursor"] : []];
+    return loadedBy.length ? skillDirsIn(join7(dir, "skills")).map((path) => ({ path, origin: id, loadedBy })) : [];
   });
   const syncedDir = join7(plugins, "synced");
-  const fromSynced = existsSync6(syncedDir) ? readdirSync3(syncedDir).filter((b) => !b.startsWith(".")).flatMap(
+  const fromSynced = claude2 && existsSync6(syncedDir) ? readdirSync3(syncedDir).filter((b) => !b.startsWith(".")).flatMap(
     (bucket) => readdirSync3(join7(syncedDir, bucket), { withFileTypes: true }).filter((d) => d.isDirectory()).flatMap((d) => {
-      const root = join7(syncedDir, bucket, d.name);
-      const name = readJson(join7(root, ".claude-plugin", "plugin.json"))?.name ?? d.name;
+      const root2 = join7(syncedDir, bucket, d.name);
+      const name = readJson(join7(root2, ".claude-plugin", "plugin.json"))?.name ?? d.name;
       if (enabled[`${name}@synced`] === false) return [];
-      return skillDirsIn(join7(root, "skills")).map((path) => ({ path, origin: `${name}@synced` }));
+      return skillDirsIn(join7(root2, "skills")).map((path) => ({ path, origin: `${name}@synced`, loadedBy: ["claude-code"] }));
     })
   ) : [];
-  return [...fromMarketplaces, ...fromSynced].map(({ path, origin }) => ({
+  return [...fromMarketplaces, ...fromSynced].map(({ path, origin, loadedBy }) => ({
     name: basename2(path),
     kind: "plugin",
     origin,
@@ -552,20 +636,24 @@ function pluginSkills() {
     description: readSkillInfo(path).description,
     movable: false,
     broken: false,
-    harnesses: ["claude-code"],
+    harnesses: loadedBy,
     links: []
   }));
 }
+var byKindAndName = (a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name);
 function machineSkills(enabled = enabledHarnesses()) {
-  const claude2 = enabled.includes("claude-code");
   return [
     ...globalFolderSkills(enabled),
-    ...claude2 ? claudeAiSkills() : [],
-    ...claude2 ? pluginSkills() : [],
-    ...cursorBuiltInSkills(enabled)
-  ].sort(
-    (a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name)
-  );
+    ...claudeAiSkills(enabled),
+    ...pluginSkills(enabled),
+    ...cursorBuiltInSkills(enabled),
+    ...systemSkills(enabled)
+  ].sort(byKindAndName);
+}
+function skillsLoadedIn(root, machine, enabled = enabledHarnesses()) {
+  if (!enabled.includes("claude-code")) return machine;
+  if (!repoSettingsFiles(root).some((f) => readJson(f)?.enabledPlugins)) return machine;
+  return [...machine.filter((m) => m.kind !== "plugin"), ...pluginSkills(enabled, root)].sort(byKindAndName);
 }
 function originsFile() {
   return join7(skilllibHome(), "origins.json");
@@ -580,7 +668,7 @@ 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];
   if (!project || project === dir) return dir;
@@ -601,7 +689,7 @@ function librarySkillDir(name) {
 }
 function realpathOrNull2(path) {
   try {
-    return realpathSync3(path);
+    return realpathSync4(path);
   } catch {
     return null;
   }
@@ -634,8 +722,8 @@ function dependencyDirs(root, name, dep) {
 }
 function isGitTracked(root, dir) {
   try {
-    const out = execFileSync("git", ["ls-files", "--", dir], { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
-    return out.trim().length > 0;
+    const out2 = execFileSync("git", ["ls-files", "--", dir], { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    return out2.trim().length > 0;
   } catch {
     return false;
   }
@@ -676,18 +764,13 @@ function projectStatus(root) {
   for (const [name, paths] of byName) {
     const real = paths.find((p) => !isLink(p)) ?? paths[0];
     const location = relative2(root, join8(real, "..")).split(sep3).join("/");
-    const latest = latestVersion(name);
-    const local = treeHash(real);
-    const sameAsLibrary = latest !== null && (latest.hash === local || versionForHash(name, local ?? "") !== null);
-    const committed = location === AGENTS_SKILLS_DIR;
     const source = lock[name]?.source;
-    const state = source ? "from npx skills" : committed ? latest === null ? "repo skill" : sameAsLibrary ? "repo skill, in library" : "repo skill, differs from library" : latest === null ? "local only" : sameAsLibrary ? "untracked copy of library skill" : "untracked, differs from library";
     unmanaged.push({
       name,
       managed: false,
-      state,
+      state: unmanagedState(name, real, location === AGENTS_SKILLS_DIR, source),
       version: null,
-      latest: latest?.version ?? null,
+      latest: latestVersion(name)?.version ?? null,
       location,
       path: real,
       visibility: visibilityOf(root, name, enabled),
@@ -696,20 +779,89 @@ function projectStatus(root) {
   }
   return [...managed, ...unmanaged].sort((a, b) => a.name.localeCompare(b.name));
 }
-function linkEverywhere(root, name, location, { allowTracked = false } = {}) {
+function unmanagedState(name, real, committed, source) {
+  if (source) return "from npx skills";
+  const latest = latestVersion(name);
+  const local = treeHash(real);
+  const sameAsLibrary = latest !== null && (latest.hash === local || versionForHash(name, local ?? "") !== null);
+  if (committed) return latest === null ? "repo skill" : sameAsLibrary ? "repo skill, in library" : "repo skill, differs from library";
+  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"]]
+];
+var NESTED_SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "vendor", "target", "coverage"]);
+function nestedSkills(root, { depth = 3, enabled = enabledHarnesses() } = {}) {
+  const found = [];
+  const walk = (dir, left) => {
+    let subs = [];
+    try {
+      subs = readdirSync4(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".") && !NESTED_SKIP.has(d.name)).map((d) => join8(dir, d.name));
+    } catch {
+      return;
+    }
+    for (const sub of subs) {
+      if (existsSync7(join8(sub, ".git"))) continue;
+      for (const [skillsDir, readers] of NESTED_READERS) {
+        const location = relative2(root, join8(sub, skillsDir)).split(sep3).join("/");
+        for (const path of skillDirsIn(join8(sub, skillsDir))) {
+          if (isLink(path) && (realpathOrNull2(path) ?? "").startsWith((realpathOrNull2(root) ?? root) + sep3)) continue;
+          const name = basename3(path);
+          found.push({
+            name,
+            managed: false,
+            state: unmanagedState(name, path, skillsDir === AGENTS_SKILLS_DIR, void 0),
+            version: null,
+            latest: latestVersion(name)?.version ?? null,
+            location,
+            path,
+            visibility: enabled.map((id) => ({ id, paths: readers.includes(id) ? 1 : 0 }))
+          });
+        }
+      }
+      if (left > 1) walk(sub, left - 1);
+    }
+  };
+  walk(root, depth);
+  return found.sort((a, b) => a.location.localeCompare(b.location) || a.name.localeCompare(b.name));
+}
+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;
@@ -725,7 +877,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])] };
@@ -736,13 +888,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);
@@ -760,13 +914,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)) {
@@ -774,9 +932,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);
@@ -791,10 +955,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 } = {}) {
@@ -803,17 +969,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);
@@ -824,9 +990,18 @@ 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) {
+  const dep = readManifest(root).skills[name];
+  if (!dep) return { name, action: "skipped", reason: "not managed by skilllib in this project" };
+  const dir = join8(root, dep.dir ?? PROJECT_SKILLS_DIR, name);
+  const pinned = dep.version > 0 && getVersion(name, dep.version) ? dep.version : void 0;
+  if (existsSync7(dir) && !isLink(dir)) stash(dir, "edit-backup");
+  return addSkill(root, name, { force: true, version: pinned });
+}
 function updateProject(root, names, { force = false } = {}) {
   const { skills } = readManifest(root);
   return Object.keys(skills).filter((name) => !names || names.includes(name)).flatMap((name) => {
@@ -835,6 +1010,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] : [];
   });
@@ -847,9 +1023,9 @@ function importSkill(dir, { force = false } = {}) {
   if (existing === incoming) return { name, status: "unchanged" };
   if (existing !== null && !force) return { name, status: "exists" };
   mkdirSync5(libraryDir(), { recursive: true });
-  const origin = originFor(dir);
+  const origin = existing !== null && libraryOrigins()[name] ? null : originFor(dir);
   copySkill(dir, to);
-  recordOrigin(name, origin);
+  if (origin) recordOrigin(name, origin);
   forgetLatest(name);
   latestVersion(name);
   return { name, status: existing === null ? "added" : "updated" };
@@ -903,6 +1079,23 @@ function unloadGlobal(path, links = [], { requireLibrary = true } = {}) {
   if (!globalSkillDirs().some((d) => entryExists(join8(d, name)))) setKeepGlobal([name], false);
   return { ok: true, movedTo };
 }
+function linkGlobal(path, agents) {
+  const name = basename3(path);
+  const linked = [];
+  const skipped = [];
+  for (const dir of new Set(agents.map((id) => harness(id).globalDirs()[0]))) {
+    const link2 = join8(dir, name);
+    if (isLink(link2) && realpathOrNull2(link2) === null) unlinkSync(link2);
+    else if (entryExists(link2)) {
+      if (realpathOrNull2(link2) !== realpathOrNull2(path)) skipped.push(link2);
+      continue;
+    }
+    mkdirSync5(dir, { recursive: true });
+    linkDir(path, link2);
+    linked.push(link2);
+  }
+  return { linked, skipped };
+}
 function createSkill(name, description) {
   if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) return { ok: false, reason: "use lowercase letters, digits and dashes" };
   const dir = librarySkillDir(name);
@@ -912,19 +1105,19 @@ 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);
   return { ok: true, dir };
 }
 function listBackups() {
-  return ["trash", "global-backup", "tidy-backup"].flatMap((kind) => {
+  return ["trash", "global-backup", "tidy-backup", "edit-backup"].flatMap((kind) => {
     const dir = join8(skilllibHome(), kind);
     if (!existsSync7(dir)) return [];
     const index = readBackupIndex(kind);
@@ -935,11 +1128,16 @@ 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;
   if (backup.kind === "tidy-backup" && isLink(to)) unlinkSync(to);
+  if (backup.kind === "edit-backup" && !isLink(to) && versionForHash(backup.name, treeHash(to) ?? "") !== null) rmSync2(to, { recursive: true, force: true });
   let taken = existsSync7(to);
   try {
     taken = taken || lstatSync2(to) !== null;
@@ -952,125 +1150,72 @@ function restoreBackup(backup) {
   return { ok: true, to };
 }
 
-// src/usage.ts
-import { createReadStream, existsSync as existsSync8, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
-import { join as join9 } from "path";
-import { createInterface } from "readline";
-var BUILTIN_COMMANDS = /* @__PURE__ */ new Set([
-  "add-dir",
-  "agents",
-  "bug",
-  "clear",
-  "compact",
-  "config",
-  "context",
-  "cost",
-  "doctor",
-  "exit",
-  "export",
-  "fast",
-  "feedback",
-  "goal",
-  "help",
-  "hooks",
-  "ide",
-  "init",
-  "install-github-app",
-  "login",
-  "logout",
-  "mcp",
-  "memory",
-  "model",
-  "output-style",
-  "permissions",
-  "plugin",
-  "pr-comments",
-  "privacy-settings",
-  "release-notes",
-  "resume",
-  "rewind",
-  "status",
-  "statusline",
-  "terminal-setup",
-  "todos",
-  "upgrade",
-  "usage",
-  "vim"
-]);
-function skillNameFromPath(filePath) {
-  const match = filePath.replace(/\\/g, "/").match(/\/\.(?:claude|agents)\/skills\/([^/]+)\//);
-  return match ? match[1] : null;
+// src/agentSkill.ts
+var AGENT_SKILL_NAME = "skilllib";
+function shippedSkill() {
+  return readFileSync7(new URL("../skills/skilllib/SKILL.md", import.meta.url), "utf-8");
 }
-function usesFromTranscriptLine(line) {
-  if (!line.includes('"Skill"') && !line.includes("<command-name>") && !line.includes("/skills/")) return [];
-  let record;
-  try {
-    record = JSON.parse(line);
-  } catch {
-    return [];
-  }
-  const cwd = record.cwd ?? "";
-  const at = record.timestamp ?? "";
-  const content = record.message?.content;
-  if (record.type === "assistant" && Array.isArray(content)) {
-    return content.flatMap((block) => {
-      if (!block || typeof block !== "object" || block.type !== "tool_use") return [];
-      const key = String(block.id);
-      if (block.name === "Skill" && typeof block.input?.skill === "string") {
-        return [{ skill: block.input.skill, source: "invoked", cwd, at, key }];
-      }
-      if (block.name === "Read" && typeof block.input?.file_path === "string") {
-        const skill = skillNameFromPath(block.input.file_path);
-        return skill ? [{ skill, source: "file read", cwd, at, key }] : [];
-      }
-      return [];
-    });
-  }
-  if (record.type === "user" && typeof content === "string") {
-    const match = content.match(/<command-name>\/?([\w.:-]+)<\/command-name>/);
-    if (!match || BUILTIN_COMMANDS.has(match[1])) return [];
-    return [{ skill: match[1], source: "slash", cwd, at, key: record.uuid ?? `${at}:${match[1]}` }];
-  }
-  return [];
+function agentSkillDirs(enabled = enabledHarnesses()) {
+  const claudeSkills = join9(claudeDir(), "skills");
+  const agentsSkills = join9(userHome(), ".agents", "skills");
+  const needsClaude = enabled.some((id) => harness(id).globalDirs().includes(claudeSkills));
+  const needsAgents = enabled.some((id) => !harness(id).globalDirs().includes(claudeSkills));
+  return [...needsClaude ? [claudeSkills] : [], ...needsAgents ? [agentsSkills] : []].map((d) => join9(d, AGENT_SKILL_NAME));
 }
-function transcriptFiles(sinceMs) {
-  const base = join9(claudeDir(), "projects");
-  if (!existsSync8(base)) return [];
-  return readdirSync5(base).flatMap((project) => {
-    const dir = join9(base, project);
-    if (!statSync2(dir).isDirectory()) return [];
-    return readdirSync5(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join9(dir, f)).filter((f) => statSync2(f).mtimeMs >= sinceMs);
-  });
+function isOurs(dir) {
+  return existsSync8(join9(dir, OWN_SKILL_MARKER));
 }
-async function scanUsage(days) {
-  const sinceMs = Date.now() - days * 24 * 60 * 60 * 1e3;
-  const seen = /* @__PURE__ */ new Map();
-  for (const file of transcriptFiles(sinceMs)) {
-    const lines = createInterface({ input: createReadStream(file), crlfDelay: Infinity });
-    for await (const line of lines) {
-      for (const use of usesFromTranscriptLine(line)) {
-        if (Date.parse(use.at) >= sinceMs) seen.set(use.key, use);
-      }
-    }
+function isDangling(path) {
+  return entryExists2(path) && lstatSync3(path).isSymbolicLink() && !existsSync8(path);
+}
+function entryExists2(path) {
+  try {
+    lstatSync3(path);
+    return true;
+  } catch {
+    return false;
   }
-  return [...seen.values()];
 }
-function summarize(uses, projectOf = () => null) {
-  const bySkill = /* @__PURE__ */ new Map();
-  for (const use of uses) {
-    const skill = use.skill.split(":").pop();
-    const summary = bySkill.get(skill) ?? { skill, uses: 0, lastUsed: "", projects: /* @__PURE__ */ new Set() };
-    summary.uses += 1;
-    if (use.at > summary.lastUsed) summary.lastUsed = use.at;
-    const project = projectOf(use.cwd);
-    if (project) summary.projects.add(project);
-    bySkill.set(skill, summary);
+function agentSkillState(enabled = enabledHarnesses()) {
+  const [primary, ...links] = agentSkillDirs(enabled);
+  if (!primary || !isOurs(primary) || links.some((l) => !existsSync8(join9(l, "SKILL.md")))) return "missing";
+  return readFileSync7(join9(primary, "SKILL.md"), "utf-8") === shippedSkill() ? "installed" : "outdated";
+}
+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: `${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());
+  writeFileSync6(join9(primary, OWN_SKILL_MARKER), "Installed by skilllib. `skilllib agent-skill remove` removes it.\n");
+  for (const link2 of links) {
+    if (entryExists2(link2)) continue;
+    mkdirSync6(join9(link2, ".."), { recursive: true });
+    linkDir(primary, link2);
+  }
+  return { ok: true, dirs: [primary, ...links] };
+}
+function removeAgentSkill() {
+  const all = agentSkillDirs(["claude-code", "codex"]);
+  const removed = all.filter((d) => entryExists2(d) && (isOurs(d) || isDangling(d)));
+  for (const d of removed) {
+    if (lstatSync3(d).isSymbolicLink()) unlinkSync2(d);
+    else rmSync3(d, { recursive: true, force: true });
+  }
+  return removed;
+}
+function refreshAgentSkill() {
+  try {
+    if (agentSkillState() === "outdated") installAgentSkill();
+  } catch {
   }
-  return [...bySkill.values()].sort((a, b) => b.uses - a.uses);
 }
 
-// src/health.ts
-import { basename as basename5 } from "path";
+// src/commands.ts
+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";
@@ -1080,21 +1225,21 @@ function git(root, args, input) {
   try {
     return execFileSync2("git", args, { cwd: root, encoding: "utf-8", input, stdio: ["pipe", "pipe", "ignore"], maxBuffer: 16 * 1024 * 1024 });
   } catch (err) {
-    const out = err.stdout;
-    return typeof out === "string" ? out : null;
+    const out2 = err.stdout;
+    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));
   const ignoredCache = /* @__PURE__ */ new Map();
   const isIgnored = (rel) => {
     if (!ignoredCache.has(rel)) {
-      const out = git(root, ["check-ignore", "--no-index", "--", rel]) ?? "";
-      ignoredCache.set(rel, out.trim().length > 0);
+      const out2 = git(root, ["check-ignore", "--no-index", "--", rel]) ?? "";
+      ignoredCache.set(rel, out2.trim().length > 0);
     }
     return ignoredCache.get(rel);
   };
@@ -1111,20 +1256,28 @@ 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, dirname as dirname5 } from "path";
+
 // src/plugins.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readdirSync as readdirSync6, readFileSync as readFileSync7, statSync as statSync3, writeFileSync as writeFileSync6 } 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(readFileSync7(path, "utf-8"));
+    return JSON.parse(readFileSync8(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function nonEmptyDir(path) {
   try {
-    return readdirSync6(path).some((f) => !f.startsWith("."));
+    return readdirSync5(path).some((f) => !f.startsWith("."));
   } catch {
     return false;
   }
@@ -1138,14 +1291,15 @@ function extrasOf(root) {
     ...nonEmptyDir(join11(root, "commands")) || manifest.commands ? ["commands"] : []
   ];
 }
-function claudePlugins(machine) {
+function claudePlugins(machine, root) {
   const installed = readJson2(join11(claudeDir(), "plugins", "installed_plugins.json"))?.plugins ?? {};
   const byOrigin = /* @__PURE__ */ new Map();
   for (const m of machine) if (m.kind === "plugin") byOrigin.set(m.origin, [...byOrigin.get(m.origin) ?? [], m.path]);
   return [...byOrigin].map(([origin, skills]) => {
     const synced = origin.endsWith("@synced");
     const id = origin;
-    const entry = installed[origin]?.[0];
+    const entries = installed[origin] ?? [];
+    const entry = entries.find((e) => root && e.projectPath === root) ?? entries.find((e) => (e.scope ?? "user") === "user") ?? entries[0];
     return {
       id,
       scope: synced ? null : entry?.scope ?? "user",
@@ -1166,8 +1320,7 @@ function claudeBinary() {
     }
   }) ?? null;
 }
-function claude(args, cwd) {
-  const bin = claudeBinary();
+function claude(args, cwd, bin = claudeBinary()) {
   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` };
   try {
     execFileSync3(bin, args, { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 12e4, encoding: "utf-8" });
@@ -1177,15 +1330,56 @@ function claude(args, cwd) {
     return { ok: false, reason: `${(e.stderr || e.stdout || e.message || "failed").trim().split("\n").slice(-1)[0]} (ran ${bin})` };
   }
 }
-function turnOffSynced(id) {
-  const file = join11(claudeDir(), "settings.json");
+function setPluginIn(file, id, on) {
   const settings = existsSync10(file) ? readJson2(file) : {};
   if (!settings) return { ok: false, reason: `can't read ${file}` };
   const enabled = settings.enabledPlugins ?? {};
-  mkdirSync6(claudeDir(), { recursive: true });
-  writeFileSync6(file, JSON.stringify({ ...settings, enabledPlugins: { ...enabled, [id]: false } }, null, 2) + "\n");
+  mkdirSync7(dirname3(file), { recursive: true });
+  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 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 removedFile() {
   return join11(skilllibHome(), "plugin-backup.json");
 }
@@ -1206,8 +1400,8 @@ function removePlugin(plugin, how) {
 }
 function recordRemovedPlugin(id, scope) {
   const list2 = readJson2(removedFile()) ?? [];
-  mkdirSync6(skilllibHome(), { recursive: true });
-  writeFileSync6(removedFile(), JSON.stringify([...list2, { id, scope, at: (/* @__PURE__ */ new Date()).toISOString() }], null, 2) + "\n");
+  mkdirSync7(skilllibHome(), { recursive: true });
+  writeFileSync7(removedFile(), JSON.stringify([...list2, { id, scope, at: (/* @__PURE__ */ new Date()).toISOString() }], null, 2) + "\n");
 }
 function pluginBackups() {
   return (readJson2(removedFile()) ?? []).map((r) => ({
@@ -1221,12 +1415,12 @@ function pluginBackups() {
 function restorePlugin(backup) {
   const r = claude(["plugin", "install", backup.from, "--scope", backup.path]);
   if (!r.ok) return r;
-  writeFileSync6(removedFile(), JSON.stringify((readJson2(removedFile()) ?? []).filter((x) => x.id !== backup.from), null, 2) + "\n");
+  writeFileSync7(removedFile(), JSON.stringify((readJson2(removedFile()) ?? []).filter((x) => x.id !== backup.from), null, 2) + "\n");
   return { ok: true, to: `Claude Code plugins (${backup.path})` };
 }
 function cursorPluginSkills() {
   const cache = join11(userHome(), ".cursor", "plugins", "cache");
-  const dirs = (p) => existsSync10(p) ? readdirSync6(p).filter((d) => !d.startsWith(".") && statSync3(join11(p, d)).isDirectory()) : [];
+  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));
@@ -1237,8 +1431,8 @@ function cursorPluginSkills() {
 }
 
 // src/tidy.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync7, readdirSync as readdirSync7, unlinkSync as unlinkSync2 } from "fs";
-import { dirname as dirname4, join as join12, sep as sep4 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readdirSync as readdirSync6, unlinkSync as unlinkSync3 } from "fs";
+import { basename as basename5, dirname as dirname4, join as join12, sep as sep4 } from "path";
 function entriesOf(dirs, name) {
   return dirs.flatMap((dir) => {
     const path = join12(dir, name);
@@ -1257,20 +1451,22 @@ function namesIn(dirs) {
   const names = /* @__PURE__ */ new Set();
   for (const dir of dirs) {
     if (!existsSync11(dir)) continue;
-    for (const name of readdirSync7(dir)) if (!name.startsWith(".") && name !== "synced") names.add(name);
+    for (const name of readdirSync6(dir)) if (!name.startsWith(".") && name !== "synced") names.add(name);
   }
   return [...names].sort();
 }
 function runsFrom(id, dirsWithCopy, readsOf) {
   const reads = readsOf(id).filter((d) => dirsWithCopy.includes(d));
-  return reads.find((d) => d.endsWith(join12(".claude", "skills"))) ?? reads[0];
+  if (id === "codex") return reads;
+  const pick = (d) => CURSOR_PICKS.indexOf(basename5(dirname4(d)));
+  return id === "cursor" ? [...reads].sort((a, b) => pick(a) - pick(b)).slice(0, 1) : reads.slice(0, 1);
 }
 function conflictOf(name, root, reals, enabled, readsOf) {
   const dirs = reals.map((r) => r.dir);
   return {
     name,
     root,
-    copies: reals.map((r) => ({ dir: r.dir, path: r.path, runs: enabled.filter((id) => runsFrom(id, dirs, readsOf) === r.dir) }))
+    copies: reals.map((r) => ({ dir: r.dir, path: r.path, runs: enabled.filter((id) => runsFrom(id, dirs, readsOf).includes(r.dir)) }))
   };
 }
 function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {}) {
@@ -1297,7 +1493,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);
@@ -1321,7 +1517,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 });
@@ -1329,7 +1526,7 @@ 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"));
@@ -1344,15 +1541,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;
@@ -1370,10 +1568,10 @@ function applyTidy(plan, { git: git2 = "keep", info: info2 } = {}) {
   for (const step of plan.steps) {
     if (held.includes(step) || !entryExists(step.path) || "target" in step && !entryExists(step.target)) continue;
     if (step.kind === "link" || step.kind === "unlink") {
-      if (isLink(step.path)) unlinkSync2(step.path);
+      if (isLink(step.path)) unlinkSync3(step.path);
     } else stash(step.path, "tidy-backup");
     if (step.kind === "link" || step.kind === "replace") {
-      mkdirSync7(dirname4(step.path), { recursive: true });
+      mkdirSync8(dirname4(step.path), { recursive: true });
       linkDir(step.target, step.path);
     }
     applied.push(step);
@@ -1390,20 +1588,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 ? ALL_PROJECT_DIRS.map((d) => join12(root, d)) : globalSkillDirs(), name);
+  return { all: entries.map((e) => e.dir), real: entries.filter((e) => !e.link).map((e) => e.dir) };
 }
 
 // src/health.ts
@@ -1421,7 +1626,7 @@ function orThrow(r) {
 var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 var agentNames = (ids) => ids.map((id) => HARNESSES.find((h) => h.id === id).name).join(", ");
 function conflictIssue(c) {
-  const where = c.root ? basename5(c.root) : "your global folders";
+  const where = c.root ? basename6(c.root) : "your global folders";
   const winners = c.managed ? c.copies.filter((x) => x.dir === c.managed) : c.copies;
   return {
     id: `conflict:${c.root ?? "global"}:${c.name}`,
@@ -1444,20 +1649,22 @@ function applyAll(plans, git2) {
   const results = plans.map((p) => applyTidy(p, { git: git2 }));
   return { skills: results.filter((r) => r.applied.length).length, held: results.reduce((n, r) => n + r.held.length, 0) };
 }
-function findIssues(projects2, machine, libraryNames, statusOf = projectStatus) {
+function findIssues(projects2, machine, libraryNames, statusOf = projectStatus, loadedIn = (root) => skillsLoadedIn(root, machine), nestedOf = nestedSkills) {
   const issues = [];
   const statuses = new Map(projects2.map((root) => [root, statusOf(root)]));
+  const nested = new Map(projects2.map((root) => [root, nestedOf(root)]));
   for (const skill of machine.filter((m) => m.broken)) {
     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}`;
         }
       }
     });
@@ -1474,40 +1681,96 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus)
       id: `dup:${name}`,
       severity: "problem",
       title: `${name}: loaded twice in ${harnesses.join(" and ")}`,
-      detail: `${copies.map((c) => `${c.kind} (${c.origin})`).join(" and ")}. Your skill wins: turn the ${vendor.map((c) => c.kind).join(" and ")} copy off at its source${vendor.some((c) => c.kind === "claude.ai") ? " (claude.ai \u2192 Settings \u2192 Skills)" : ""}.`
+      detail: `${copies.map((c) => `${c.kind} (${c.origin})`).join(" and ")}. Your skill wins: turn the ${vendor.map((c) => c.kind).join(" and ")} copy off at its source${vendor.some((c) => c.kind === "claude.ai") ? " (claude.ai \u2192 Settings \u2192 Skills)" : ""}${vendor.some((c) => c.kind === "system") ? ` (whoever manages ${vendor.find((c) => c.kind === "system").origin})` : ""}.`
     });
   }
-  const loadedYours = /* @__PURE__ */ new Set([...loaded.filter((m) => m.movable).map((m) => m.name), ...[...statuses.values()].flat().map((s) => s.name)]);
-  const yours = /* @__PURE__ */ new Set([...libraryNames, ...loadedYours]);
-  for (const plugin of claudePlugins(machine)) {
-    const dupes = plugin.skills.map((p) => basename5(p)).filter((n) => yours.has(n));
-    if (!dupes.length) continue;
-    const others = plugin.skills.length - dupes.length;
-    const pluginName = plugin.id.split("@")[0];
-    const remove2 = {
-      label: `Remove the plugin ${plugin.id}`,
+  const loadedHere = new Map(projects2.map((root) => [root, loadedIn(root)]));
+  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) => {
+    const where = basename6(root);
+    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; 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 ? [
+        {
+          label: `Remove your ${copies.map((s) => s.name).join(", ")} from ${where}`,
+          hint: "the plugin's copy stays; Your skills keeps yours",
+          run: () => {
+            for (const s of copies) {
+              const r = removeSkill(root, s.name);
+              if (r.action !== "removed") throw new Error(`${s.name}: ${r.reason}`);
+            }
+            return `${copies.map((s) => s.name).join(", ")} removed from ${where}; the plugin's copy stays`;
+          }
+        }
+      ] : []
+    ];
+  };
+  const machinePlugins = claudePlugins(machine);
+  for (const plugin of machinePlugins) {
+    const names = plugin.skills.map((p) => basename6(p));
+    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;
+    const pluginName = plugin.id.split("@")[0];
+    const remove2 = {
+      label: `Remove the plugin ${plugin.id}`,
       hint: plugin.extras.length ? `also removes its ${plugin.extras.join(", ")}` : "restorable from Health",
       run: () => orThrow(removePlugin(plugin, "delete"))
     };
     const off = { label: `Turn the plugin ${plugin.id} off`, hint: "stays installed", run: () => orThrow(removePlugin(plugin, "off")) };
-    const notLoaded = dupes.filter((n) => !loadedYours.has(n));
+    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: notLoaded.length === dupes.length ? "suggestion" : "problem",
+      severity: bothLoad.length ? "problem" : "suggestion",
       title: `${dupes.join(", ")}: also in the Claude Code plugin ${plugin.id}`,
       detail: [
-        notLoaded.length < dupes.length ? `Claude Code loads both (the plugin's as /${pluginName}:${dupes[0]}). Your skill wins.` : "",
-        notLoaded.length ? `Your ${notLoaded.join(", ")} ${notLoaded.length === 1 ? "is" : "are"} only in Your skills, not installed anywhere: once the plugin is gone, add ${notLoaded.length === 1 ? "it" : "them"} where you need ${notLoaded.length === 1 ? "it" : "them"}.` : "",
-        others ? `The plugin's other ${plural(others, "skill")} are copied into Your skills first, so nothing is lost.` : "",
+        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 ${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." : ""
+        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(", ")}.` : ""
       ].filter(Boolean).join(" "),
-      choices: plugin.synced ? [off] : plugin.extras.length ? [off, remove2] : [remove2, off]
+      choices: [...plugin.synced ? [off] : plugin.extras.length ? [off, remove2] : [remove2, off], ...inRepos.flatMap(([root, d]) => repoChoices(plugin, root, d))]
     });
   }
+  const machinePluginSkills = new Set(machinePlugins.flatMap((p) => p.skills));
+  for (const root of projects2) {
+    const where = basename6(root);
+    const repoOnly = loadedHere.get(root).filter((m) => m.kind === "plugin" && !machinePluginSkills.has(m.path));
+    for (const plugin of claudePlugins(repoOnly, root)) {
+      const names = plugin.skills.map((p) => basename6(p));
+      const inRepo = namesIn2(root).filter((n) => names.includes(n));
+      const dupes = names.filter((n) => inRepo.includes(n) || globalYours.has(n));
+      if (!dupes.length) continue;
+      issues.push({
+        id: `plugin:${root}:${plugin.id}`,
+        severity: "problem",
+        title: `${dupes.join(", ")}: also in the Claude Code plugin ${plugin.id}, on in ${where}`,
+        detail: `${where}'s Claude Code settings turn the plugin on, so Claude Code loads both there (the plugin's as /${plugin.id.split("@")[0]}:${dupes[0]}). Your skill wins.`,
+        choices: repoChoices(plugin, root, inRepo)
+      });
+    }
+  }
   if (enabledHarnesses().includes("cursor")) {
     const byPlugin = /* @__PURE__ */ new Map();
-    for (const s of cursorPluginSkills().filter((x) => loadedYours.has(x.name))) byPlugin.set(s.plugin, [...byPlugin.get(s.plugin) ?? [], s.name]);
+    for (const s of cursorPluginSkills().filter((x) => installedYours.has(x.name))) byPlugin.set(s.plugin, [...byPlugin.get(s.plugin) ?? [], s.name]);
     for (const [plugin, names] of byPlugin) {
       issues.push({
         id: `cursor-plugin:${plugin}`,
@@ -1526,39 +1789,121 @@ 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`;
+        }
       }
     });
   }
   issues.push(...global.conflicts.map(conflictIssue));
   const kept = keptGlobal();
+  const unreviewed = [...new Set(loaded.filter((m) => m.movable && !kept.has(m.name)).map((m) => m.name))];
+  if (unreviewed.length) {
+    issues.push({
+      id: "review:global",
+      severity: "suggestion",
+      title: `${plural(unreviewed.length, "global skill")} of yours ${unreviewed.length === 1 ? "loads" : "load"} in every repo`,
+      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();
+  const seenBy = /* @__PURE__ */ new Map();
+  for (const m of loaded) seenBy.set(m.name, /* @__PURE__ */ new Set([...seenBy.get(m.name) ?? [], ...m.harnesses]));
+  const blindOf = (m) => enabled.filter((id) => !seenBy.get(m.name).has(id));
+  const blindGlobal = loaded.filter((m) => m.movable && m.harnesses.length && blindOf(m).length);
+  for (const onPurpose of [true, false]) {
+    const skills = blindGlobal.filter((m) => kept.has(m.name) === onPurpose);
+    if (!skills.length) continue;
+    const missing = [...new Set(skills.flatMap(blindOf))];
+    const link2 = {
+      label: `Link ${skills.length === 1 ? "it" : "them"} for ${agentNames(missing)}`,
+      hint: "links only; nothing is copied or moved",
+      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)` : ""}`;
+      }
+    };
+    issues.push({
+      id: `usable:global${onPurpose ? ":kept" : ""}`,
+      severity: "suggestion",
+      title: `${plural(skills.length, "global skill")}${onPurpose ? " you keep global" : ""} not usable by ${agentNames(missing)}`,
+      detail: `${skills.map((m) => `${m.name} (only ${agentNames(m.harnesses)})`).join(", ")}. ${onPurpose ? "A link in each agent's global folder makes the one real copy reach every agent you use." : `Link ${skills.length === 1 ? "it" : "them"} for every agent, or move ${skills.length === 1 ? "it" : "them"} to the repos that need ${skills.length === 1 ? "it" : "them"} (skilllib \u2192 Global), which works for every agent too.`}`,
+      ...onPurpose ? { fix: link2 } : { choices: [link2] }
+    });
+  }
   const alsoGlobal = /* @__PURE__ */ new Map();
-  const globalNames = new Set(loaded.filter((m) => m.kind !== "plugin").map((m) => m.name));
+  const globalCopies = loaded.filter((m) => m.kind !== "plugin");
+  const alsoLoadedGlobally = (s) => globalCopies.some((m) => m.name === s.name && m.harnesses.some((id) => s.visibility.some((v) => v.id === id && v.paths > 0)));
   for (const root of projects2) {
-    const where = basename5(root);
+    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({
@@ -1575,14 +1920,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}`,
@@ -1591,20 +1946,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: [
             {
@@ -1627,27 +2002,67 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus)
           choices: [{ label: "Track it", hint: `adds it to ${where}'s skilllib.json`, run: () => `${addSkill(root, s.name).name} tracked in ${where}` }]
         });
       }
-      if (globalNames.has(s.name) && s.managed) alsoGlobal.set(s.name, [...alsoGlobal.get(s.name) ?? [], root]);
+      if (s.state === "edited locally" || s.state === "edited locally, update available") {
+        const newer = 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.`,
+          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`,
+              run: () => {
+                importSkill(s.path, { force: true });
+                const c = addSkill(root, s.name);
+                if (c.action === "skipped") throw new Error(`${s.name}: ${c.reason}`);
+                return `${s.name}: saved as v${c.to}; ${where} uses it`;
+              }
+            },
+            {
+              label: "Discard the edits",
+              hint: `back to ${pinned}; the edited copy is restorable from Health`,
+              run: () => {
+                const c = discardEdits(root, s.name);
+                if (c.action === "skipped") throw new Error(`${s.name}: ${c.reason}`);
+                return `${s.name}: edits discarded, back to v${c.to}`;
+              }
+            }
+          ]
+        });
+      }
+      if (alsoLoadedGlobally(s)) alsoGlobal.set(s.name, [...alsoGlobal.get(s.name) ?? [], { root, managed: s.managed }]);
     }
   }
-  for (const [name, roots] of alsoGlobal) {
-    const wheres = roots.map((r) => basename5(r)).join(", ");
+  for (const root of projects2) {
+    for (const n of nested.get(root)) {
+      const copies = alsoGlobal.get(n.name) ?? [];
+      if (alsoLoadedGlobally(n) && !copies.some((c) => c.root === root)) alsoGlobal.set(n.name, [...copies, { root, managed: false }]);
+    }
+  }
+  for (const [name, copies] of alsoGlobal) {
+    const wheres = copies.map((c) => basename6(c.root)).join(", ");
+    const removable = copies.filter((c) => c.managed).map((c) => c.root);
+    const repoOwn = copies.filter((c) => !c.managed).map((c) => basename6(c.root));
     if (kept.has(name)) {
+      const removeWheres = removable.map((r) => basename6(r)).join(", ");
       issues.push({
         id: `twice:${name}`,
         severity: "suggestion",
         title: `${name}: in ${wheres}, and you keep it global`,
-        detail: "The global copy already loads there, so the project copies are extra. Claude Code runs the global one anyway.",
-        choices: [
+        detail: `The global copy already loads there, so the project copies are extra. Claude Code runs the global one anyway.${repoOwn.length ? ` ${repoOwn.join(", ")} ${repoOwn.length === 1 ? "has its own copy" : "have their own copies"}: remove ${repoOwn.length === 1 ? "it" : "them"} in the repo, or stop keeping ${name} global.` : ""}`,
+        choices: removable.length ? [
           {
-            label: `Remove the copies in ${wheres}`,
+            label: `Remove the copies in ${removeWheres}`,
             hint: "the global copy stays",
             run: () => {
-              const removed = roots.filter((root) => removeSkill(root, name).action === "removed").map((r) => basename5(r));
+              const removed = removable.filter((root) => removeSkill(root, name).action === "removed").map((r) => basename6(r));
               return `${name}: removed from ${removed.join(", ") || "no project"}; the global copy stays`;
             }
           }
-        ]
+        ] : void 0
       });
       continue;
     }
@@ -1656,7 +2071,7 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus)
       id: `twice:${name}`,
       severity: "suggestion",
       title: `${name}: in ${wheres} and also loaded globally`,
-      detail: "The project copies are enough; the global one loads it in every other project too. Or keep it global on purpose (Global \u2192 Enter).",
+      detail: `${repoOwn.length === copies.length ? `Agents there load both the repo's copy and the global one.` : "The project copies are enough; the global one loads it in every other project too."} ${movable ? "Stop loading it globally, or keep it global on purpose (Global \u2192 Enter)." : `The global copy comes from ${machine.find((m) => m.name === name && !m.movable)?.origin ?? "a vendor"}: turn it off there.`}`,
       choices: movable ? [
         {
           label: "Stop loading it globally",
@@ -1671,8 +2086,311 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus)
       ] : void 0
     });
   }
+  const agentSkill2 = agentSkillState();
+  if (agentSkill2 !== "installed") {
+    const install = {
+      label: agentSkill2 === "missing" ? "Install the skilllib skill for your agents" : "Update the skilllib skill",
+      hint: "one global skill, in ~/.claude/skills (and ~/.agents/skills)",
+      run: () => {
+        const r = installAgentSkill();
+        if (!r.ok) throw new Error(`skilllib skill: ${r.reason}`);
+        return `Your agents can now use skilllib (${plural(r.dirs.length, "folder")})`;
+      }
+    };
+    issues.push({
+      id: "agent-skill",
+      severity: "suggestion",
+      title: agentSkill2 === "missing" ? "Your agents don't know about skilllib" : "The skilllib skill for your agents is out of date",
+      detail: "The skilllib skill lets you ask your agents which skills they can use here, where each comes from, and which of your skills a repo should add.",
+      ...agentSkill2 === "missing" ? { choices: [install] } : { fix: install }
+    });
+  }
   return issues;
 }
+function addedAt(path) {
+  try {
+    const st = lstatSync4(path);
+    return st.birthtimeMs > 0 ? st.birthtimeMs : st.ctimeMs;
+  } catch {
+    return Date.now();
+  }
+}
+function usageIssues(projects2, machine, libraryNames, uses, statusOf = projectStatus) {
+  if (!enabledHarnesses().includes("claude-code")) return [];
+  const issues = [];
+  const since = Date.now() - uses.days * 24 * 60 * 60 * 1e3;
+  for (const root of projects2) {
+    const where = basename6(root);
+    const unused = statusOf(root).filter((s) => s.state !== "folder missing" && uses.inProject(root, s.name) === 0 && addedAt(s.path) <= since);
+    if (!unused.length) continue;
+    const removable = unused.filter((s) => s.managed);
+    issues.push({
+      id: `unused:${root}`,
+      severity: "suggestion",
+      title: `${where}: ${plural(unused.length, "skill")} unused in ${uses.days} days`,
+      detail: `${unused.map((s) => s.name).join(", ")}: no Claude Code session in ${where} used ${unused.length === 1 ? "it" : "them"}. Each one's name and description still takes context in every session there.${unused.length > removable.length ? " The repo's own skills are the team's: remove those in the repo if nobody needs them." : ""}`,
+      choices: removable.length ? [
+        {
+          label: `Remove ${removable.length === unused.length ? "them" : `the ${plural(removable.length, "skill")} skilllib installed`} from ${where}`,
+          hint: "Your skills keeps them; edited ones stay",
+          run: () => {
+            const changes = removable.map((s) => removeSkill(root, s.name));
+            const removed = changes.filter((c) => c.action === "removed").map((c) => c.name);
+            const kept = changes.filter((c) => c.action !== "removed").map((c) => c.name);
+            return `${where}: removed ${removed.join(", ") || "nothing"}${kept.length ? `; kept ${kept.join(", ")} (local edits)` : ""}`;
+          }
+        }
+      ] : void 0
+    });
+  }
+  const installed = /* @__PURE__ */ new Set([...projects2.flatMap((root) => statusOf(root).map((s) => s.name)), ...machine.filter((m) => !m.broken).map((m) => m.name)]);
+  const idle = [...libraryNames].filter((name) => {
+    const first = versionHistory(name)[0];
+    return !installed.has(name) && uses.total(name) === 0 && (first ? Date.parse(first.date) : addedAt(librarySkillDir(name))) <= since;
+  });
+  if (idle.length) {
+    issues.push({
+      id: "unused:library",
+      severity: "suggestion",
+      title: `${plural(idle.length, "skill")} in Your skills: in no repo, unused in ${uses.days} days`,
+      detail: `${idle.sort().join(", ")}. They load nowhere, so they take no context: add the ones you want to a repo, or delete the ones you've outgrown.`,
+      choices: [
+        {
+          label: `Delete ${idle.length === 1 ? "it" : `all ${idle.length}`} from Your skills`,
+          hint: "restorable from Health",
+          run: () => {
+            const done = idle.map((name) => [name, deleteLibrarySkill(name)]);
+            const failed = done.filter(([, r]) => !r.ok).map(([name]) => name);
+            return `Deleted ${plural(done.length - failed.length, "skill")} from Your skills${failed.length ? `; kept ${failed.join(", ")}` : ""}`;
+          }
+        }
+      ]
+    });
+  }
+  return issues;
+}
+
+// src/here.ts
+function groupBy(items) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [key, name, make] of items) {
+    const group = groups.get(key) ?? make();
+    group.skills.push(name);
+    groups.set(key, group);
+  }
+  return [...groups.values()];
+}
+var sameSet = (a, b) => a.length === b.length && a.every((x) => b.includes(x));
+function globalFrom(kind, origin, path) {
+  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"]);
+function topLevel(root) {
+  try {
+    return readdirSync7(root, { withFileTypes: true }).filter((d) => !d.name.startsWith(".") && !SKIP.has(d.name)).map((d) => d.isDirectory() ? `${d.name}/` : d.name).sort().slice(0, 60);
+  } catch {
+    return [];
+  }
+}
+function usableHere(root, uses = /* @__PURE__ */ new Map()) {
+  const agents = enabledHarnesses();
+  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" : repo ? "repo" : "local",
+        ...s.location !== ".claude/skills" && { dir: s.location },
+        ...s.version !== null && { version: s.version },
+        ...!usual && { state: s.state },
+        ...behind && { latest: s.latest },
+        ...gitState && { git: gitState },
+        ...!sameSet(loadedBy, agents) && { agents: 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(
+    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: [] })];
+    })
+  );
+  const issues = /* @__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 } };
+    issue.problems.push(i.title);
+    issues.set(key, issue);
+  }
+  const usesHere = Object.fromEntries([...uses].filter(([, n]) => n > 0));
+  return {
+    project: tildify(root),
+    files: topLevel(root),
+    agents,
+    skills,
+    ...nested.length > 0 && { nested },
+    global,
+    issues: [...issues.values()],
+    ...Object.keys(usesHere).length > 0 && { usesHere }
+  };
+}
+function firstSentence(description) {
+  const line = description.replace(/\s+/g, " ").trim();
+  const sentence = line.match(/^(.{40,}?[.!?])(?:\s|$)/)?.[1] ?? line;
+  return sentence.length > 200 ? sentence.slice(0, 199).trimEnd() + "\u2026" : sentence;
+}
+function libraryFor(currentProject) {
+  const manifests = visibleProjects().map((p) => ({ name: basename7(p), skills: readManifest(p).skills }));
+  const here = currentProject ? new Set(projectStatus(currentProject).map((s) => s.name)) : null;
+  const all = librarySkills();
+  const describe = (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 } };
+  };
+  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) };
+}
+
+// src/usage.ts
+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",
+  "agents",
+  "bug",
+  "clear",
+  "compact",
+  "config",
+  "context",
+  "cost",
+  "doctor",
+  "exit",
+  "export",
+  "fast",
+  "feedback",
+  "goal",
+  "help",
+  "hooks",
+  "ide",
+  "init",
+  "install-github-app",
+  "login",
+  "logout",
+  "mcp",
+  "memory",
+  "model",
+  "output-style",
+  "permissions",
+  "plugin",
+  "pr-comments",
+  "privacy-settings",
+  "release-notes",
+  "resume",
+  "rewind",
+  "status",
+  "statusline",
+  "terminal-setup",
+  "todos",
+  "upgrade",
+  "usage",
+  "vim"
+]);
+function skillNameFromPath(filePath) {
+  const match = filePath.replace(/\\/g, "/").match(/\/\.(?:claude|agents)\/skills\/([^/]+)\//);
+  return match ? match[1] : null;
+}
+function usesFromTranscriptLine(line) {
+  if (!line.includes('"Skill"') && !line.includes("<command-name>") && !line.includes("/skills/")) return [];
+  let record;
+  try {
+    record = JSON.parse(line);
+  } catch {
+    return [];
+  }
+  const cwd = record.cwd ?? "";
+  const at = record.timestamp ?? "";
+  const content = record.message?.content;
+  if (record.type === "assistant" && Array.isArray(content)) {
+    return content.flatMap((block) => {
+      if (!block || typeof block !== "object" || block.type !== "tool_use") return [];
+      const key = String(block.id);
+      if (block.name === "Skill" && typeof block.input?.skill === "string") {
+        return [{ skill: block.input.skill, source: "invoked", cwd, at, key }];
+      }
+      if (block.name === "Read" && typeof block.input?.file_path === "string") {
+        const skill = skillNameFromPath(block.input.file_path);
+        return skill ? [{ skill, source: "file read", cwd, at, key }] : [];
+      }
+      return [];
+    });
+  }
+  if (record.type === "user" && typeof content === "string") {
+    const match = content.match(/<command-name>\/?([\w.:-]+)<\/command-name>/);
+    if (!match || BUILTIN_COMMANDS.has(match[1])) return [];
+    return [{ skill: match[1], source: "slash", cwd, at, key: record.uuid ?? `${at}:${match[1]}` }];
+  }
+  return [];
+}
+function transcriptFiles(sinceMs) {
+  const base = join13(claudeDir(), "projects");
+  if (!existsSync12(base)) return [];
+  return readdirSync8(base).flatMap((project) => {
+    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) {
+  const sinceMs = Date.now() - days * 24 * 60 * 60 * 1e3;
+  const seen = /* @__PURE__ */ new Map();
+  for (const file of transcriptFiles(sinceMs)) {
+    const lines = createInterface({ input: createReadStream(file), crlfDelay: Infinity });
+    for await (const line of lines) {
+      for (const use of usesFromTranscriptLine(line)) {
+        if (Date.parse(use.at) >= sinceMs) seen.set(use.key, use);
+      }
+    }
+  }
+  return [...seen.values()];
+}
+function summarize(uses, projectOf = () => null) {
+  const bySkill = /* @__PURE__ */ new Map();
+  for (const use of uses) {
+    const skill = use.skill.split(":").pop();
+    const summary = bySkill.get(skill) ?? { skill, uses: 0, lastUsed: "", projects: /* @__PURE__ */ new Set() };
+    summary.uses += 1;
+    if (use.at > summary.lastUsed) summary.lastUsed = use.at;
+    const project = projectOf(use.cwd);
+    if (project) summary.projects.add(project);
+    bySkill.set(skill, summary);
+  }
+  return [...bySkill.values()].sort((a, b) => b.uses - a.uses);
+}
+function usesByProject(uses, projectOf) {
+  const byProject = /* @__PURE__ */ new Map();
+  for (const use of uses) {
+    const root = projectOf(use.cwd);
+    if (!root) continue;
+    const counts = byProject.get(root) ?? /* @__PURE__ */ new Map();
+    counts.set(use.skill, (counts.get(use.skill) ?? 0) + 1);
+    byProject.set(root, counts);
+  }
+  return byProject;
+}
 
 // src/commands.ts
 var USAGE_DAYS = 30;
@@ -1687,6 +2405,7 @@ function parseArgs(argv) {
     global: argv.includes("--global"),
     fix: argv.includes("--fix"),
     allowTracked: argv.includes("--allow-tracked"),
+    json: argv.includes("--json"),
     days: Number.isFinite(days) && days > 0 ? days : USAGE_DAYS,
     dryRun: argv.includes("--dry-run"),
     allowGit: argv.includes("--allow-git"),
@@ -1696,21 +2415,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 printChanges(changes) {
+function withDirs(root, changes) {
+  const { skills } = readManifest(root);
+  return changes.map((c) => {
+    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 (changes.some((c) => c.action === "skipped")) process.exitCode = 1;
+  if (args.json) return json(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);
@@ -1728,40 +2466,98 @@ 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 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();
-  const skills = projectStatus(root);
-  info(`${basename6(root)} ${dim(tildify(root))}
-`);
-  if (skills.length === 0) {
-    info("No skills in this project yet. Add one from your library with: skilllib add <name>");
+  if (args.json) {
+    const root2 = findProjectRoot();
+    const usage3 = await usageBySkill(args.days, root2);
+    json(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>");
   const usage2 = await usageBySkill(args.days, root);
-  table(
-    skills.map((s) => ({
-      Skill: s.name,
-      Status: s.source ? dim(`npx skills: ${s.source}`) : colorState(s.state),
-      [`Uses (${args.days}d)`]: String(usage2.get(s.name)?.uses ?? 0),
-      "Last used": lastUsed(usage2.get(s.name))
-    }))
-  );
+  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}`) : stateOf(s),
+        Agents: agentsOf(s),
+        [`Uses (${args.days}d)`]: String(usage2.get(s.name)?.uses ?? 0),
+        "Last used": lastUsed(usage2.get(s.name))
+      }))
+    );
+  }
+  if (nested.length) {
+    info(`${skills.length ? "\n" : ""}In subfolders ${dim("(Claude Code loads .claude/skills when you work there; Codex loads .agents/skills when started there)")}`);
+    table(
+      nested.map((s) => ({
+        Skill: s.name,
+        Folder: s.location,
+        Status: stateOf(s),
+        Agents: agentsOf(s),
+        [`Uses (${args.days}d)`]: String(usage2.get(s.name)?.uses ?? 0)
+      }))
+    );
+  }
   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(projectHere()));
+  }
   const skills = librarySkills();
   if (skills.length === 0) {
     info(`Your library (${tildify(libraryDir())}) is empty.`);
@@ -1770,7 +2566,7 @@ async function list(args) {
     const installs = /* @__PURE__ */ new Map();
     for (const project of visibleProjects()) {
       for (const name of Object.keys(readManifest(project).skills)) {
-        installs.set(name, [...installs.get(name) ?? [], basename6(project)]);
+        installs.set(name, [...installs.get(name) ?? [], basename8(project)]);
       }
     }
     const usage2 = await usageBySkill(args.days);
@@ -1788,20 +2584,29 @@ 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"
       )
     );
   }
 }
-function projects() {
+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 }))
+      }))
+    );
+  }
   if (roots.length === 0) {
     info("No known projects. Run `skilllib scan <dir>` to find them, or `skilllib add` inside one.");
     return;
@@ -1812,7 +2617,7 @@ function projects() {
       const managed = skills.filter((s) => s.managed);
       const attention = skills.filter((s) => s.state !== "ok" && s.state !== "local only").length;
       return {
-        Project: basename6(root),
+        Project: basename8(root),
         Path: dim(tildify(root)),
         Skills: managed.map((s) => s.name).join(", ") || dim("none"),
         "Local only": String(skills.filter((s) => s.state === "local only").length),
@@ -1826,9 +2631,9 @@ 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(args.positional.map((name) => addSkill(root, name, { force: args.force })));
+  printChanges(root, args.positional.map((name) => addSkill(root, name, { force: args.force })), args);
   rememberProjects([root]);
 }
 function remove(args) {
@@ -1836,67 +2641,90 @@ function remove(args) {
     error("Usage: skilllib remove <skill-name>... [--force]");
     process.exit(1);
   }
-  const root = findProjectRoot();
-  printChanges(args.positional.map((name) => removeSkill(root, name, { force: args.force })));
+  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()];
-  for (const root of roots) {
+  const roots = args.all ? visibleProjects() : [requireProject()];
+  const results = roots.map((root) => {
     if (args.allowTracked) allowTrackedLinks(root);
     const changes = syncProject(root, { force: args.force });
-    if (args.all) info(`${basename6(root)} ${dim(tildify(root))}`);
-    if (changes.length === 0) success("Installed versions match skilllib.json");
-    else printChanges(changes);
-  }
+    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) {
+        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.all) rememberProjects(roots);
 }
 function update(args) {
-  const roots = args.all ? visibleProjects() : [findProjectRoot()];
-  for (const root of roots) {
+  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 });
-    if (args.all) info(`${basename6(root)} ${dim(tildify(root))}`);
-    if (changes.length === 0) success("Everything is on the latest version");
-    else printChanges(changes);
-  }
+    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");
+      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);
 }
 function outdated(args) {
-  const roots = args.all ? visibleProjects() : [findProjectRoot()];
-  const rows = roots.flatMap(
-    (root) => projectStatus(root).filter((s) => s.managed && s.latest !== null && s.version !== null && s.latest > s.version).map((s) => ({ Project: basename6(root), Skill: s.name, Installed: `v${s.version}`, Latest: `v${s.latest}`, Status: colorState(s.state) }))
+  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);
+  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);
   info(dim(`
 \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);
   }
+  const results = [];
   for (const dir of dirs) {
     if (!isSkillDir(dir)) {
       warn(`${tildify(dir)}: no SKILL.md, skipping`);
+      results.push({ path: dir, status: "no SKILL.md" });
       continue;
     }
     const { name, status: result } = importSkill(dir, { force: args.force });
+    results.push({ path: dir, name, status: result });
     if (result === "exists") {
       warn(`${name}: the library already has a different version (use --force to replace it)`);
       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 === join13(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(`  ${basename6(root)} now depends on ${name} v${change.to}`));
+        if (change.action !== "skipped") info(dim(`  ${basename8(root)} now depends on ${name} v${change.to}`));
       }
       rememberProjects([root]);
     }
   }
+  if (args.json) json(results);
 }
 function scan(args) {
   for (const p of args.positional) addRoot(p);
@@ -1907,24 +2735,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) => basename6(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: basename6(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) {
@@ -1936,12 +2774,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;
@@ -1954,14 +2804,14 @@ function newSkill(args) {
     error(`Can't create ${name}: ${r.reason}`);
     process.exit(1);
   }
-  success(`Created ${tildify(join13(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;
   }
@@ -1972,18 +2822,51 @@ 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;
+  }
 }
-function doctor(args) {
+async function doctor(args) {
   const projects2 = visibleProjects();
-  const issues = findIssues(projects2, machineSkills(), new Set(librarySkills().map((s) => s.name)));
+  const machine = machineSkills();
+  const libraryNames = new Set(librarySkills().map((s) => s.name));
+  const issues = findIssues(projects2, machine, libraryNames);
+  if (enabledHarnesses().includes("claude-code")) {
+    const projectOf = projectOfFactory(projects2);
+    const uses = await scanUsage(args.days);
+    const inProject = usesByProject(uses, projectOf);
+    const total = new Map(summarize(uses, projectOf).map((s) => [s.skill, s.uses]));
+    issues.push(
+      ...usageIssues(projects2, machine, libraryNames, {
+        inProject: (root, skill) => inProject.get(root)?.get(skill) ?? 0,
+        total: (skill) => total.get(skill) ?? 0,
+        days: args.days
+      })
+    );
+  }
+  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: fixed(fix) }
+      }))
+    );
+  }
   if (issues.length === 0) return success("Everything looks good");
   for (const issue of issues) {
     info(`${issue.severity === "problem" ? red("\u25CF") : yellow("\u25C6")} ${issue.title}`);
     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}`);
     }
   }
@@ -1991,18 +2874,27 @@ function doctor(args) {
 }
 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({
+      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) })),
+      unusedLibrarySkills: librarySkills().filter((l) => !summaries.some((u) => u.skill === l.name)).map((l) => l.name)
+    });
+  }
   if (summaries.length === 0) {
     info(`No skill usage in Claude Code transcripts from the last ${args.days} days.`);
     return;
   }
   const library = new Set(librarySkills().map((s) => s.name));
-  info(`Skill usage, last ${args.days} days ${dim(`(from ${tildify(join13(claudeDir(), "projects"))})`)}
+  info(`Skill usage, last ${args.days} days ${dim(`(from ${tildify(join14(claudeDir(), "projects"))})`)}
 `);
   table(
     summaries.map((s) => ({
       Skill: s.skill,
       Uses: String(s.uses),
-      Projects: [...s.projects].map((p) => basename6(p)).join(", ") || dim("-"),
+      Projects: [...s.projects].map((p) => basename8(p)).join(", ") || dim("-"),
       "Last used": lastUsed(s),
       Library: library.has(s.skill) ? green("yes") : dim("no")
     }))
@@ -2015,12 +2907,23 @@ async function usage(args) {
 }
 function show(args) {
   const name = args.positional[0];
-  const dir = name ? join13(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({
+      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(join14(dir, "SKILL.md"), "utf-8")
+    });
+  }
   info(`${name} ${dim(tildify(dir))}`);
   if (description) info(`
 ${description}`);
@@ -2047,14 +2950,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 ? `${basename6(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) {
@@ -2075,14 +2985,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: basename6(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) {
@@ -2097,6 +3034,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) {
@@ -2112,18 +3050,46 @@ function tidy(args) {
   else if (changed) info(dim("\nReplaced copies are in ~/.skilllib/tidy-backup; `skilllib restore` puts them back."));
   if (held) info(dim(`${held} change${held === 1 ? "" : "s"} held back because git would see them. Re-run with --allow-git to make them.`));
 }
+function agentSkill(args) {
+  const action = args.positional[0];
+  if (action === "install") {
+    const r = installAgentSkill();
+    if (!r.ok) {
+      error(`Can't install the skilllib skill: ${r.reason}`);
+      process.exit(1);
+    }
+    if (args.json) return json({ 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"));
+    return;
+  }
+  if (action === "remove" || action === "rm") {
+    const removed = removeAgentSkill();
+    if (args.json) return json({ 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 (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,
@@ -2138,10 +3104,12 @@ export {
   setKeepGlobal,
   setPluginEnabled,
   machineSkills,
+  skillsLoadedIn,
   libraryOrigins,
   recordOrigin,
   librarySkills,
   librarySkillDir,
+  visibilityOf,
   projectStatus,
   linkEverywhere,
   relinkDependency,
@@ -2155,20 +3123,35 @@ export {
   deleteLibrarySkill,
   deleteGlobal,
   unloadGlobal,
+  linkGlobal,
   createSkill,
   listBackups,
   restoreBackup,
-  error,
-  scanUsage,
   gitInfo,
   relativeTo,
+  claudePlugins,
   claudeBinary,
+  turnOffIn,
   recordRemovedPlugin,
   pluginBackups,
   restorePlugin,
+  cursorPluginSkills,
+  agentSkillState,
+  installAgentSkill,
+  removeAgentSkill,
+  refreshAgentSkill,
+  planProjectTidy,
+  planGlobalTidy,
+  gitVisibleSteps,
+  applyTidy,
+  describeStep,
+  copyLabel,
+  addedAt,
+  scanUsage,
   parseArgs,
   projectOfFactory,
   status,
+  overview,
   list,
   projects,
   add,
@@ -2188,5 +3171,6 @@ export {
   harnessesCommand,
   link,
   globalCommand,
-  tidy
+  tidy,
+  agentSkill
 };