skilllib 1.3.0 → 1.6.0

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

@@ -1,14 +1,22 @@
 // src/output.ts
 import { sep } from "path";
 import { homedir } from "os";
-var color = (code) => (s) => process.stdout.isTTY ? `\x1B[${code}m${s}\x1B[0m` : s;
+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();
@@ -28,13 +36,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/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/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/config.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join6, resolve as resolve2 } from "path";
 
 // src/paths.ts
 import { homedir as homedir2 } from "os";
@@ -51,9 +60,16 @@ function libraryDir() {
 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/harnesses.ts
 import { existsSync } from "fs";
@@ -76,8 +92,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 +105,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 +130,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,11 +153,6 @@ 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";
@@ -249,12 +264,10 @@ function getVersion(name, version) {
 // src/project.ts
 function findProjectRoot(from = process.cwd()) {
   let dir = resolve(from);
-  let gitRoot = null;
   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 resolve(from);
     dir = parent;
   }
 }
@@ -403,6 +416,11 @@ 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 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/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";
@@ -429,8 +447,24 @@ function realpathOrNull(path) {
 function harnessesReading(dir, enabled) {
   return enabled.filter((id) => HARNESSES.find((h) => h.id === id)?.globalDirs().includes(dir));
 }
+var systemDirs = () => [codexSystemDir()];
 function globalSkillDirs() {
-  return [...new Set(HARNESSES.flatMap((h) => h.globalDirs()))].filter((d) => d.startsWith(userHome()));
+  return [...new Set(HARNESSES.flatMap((h) => h.globalDirs()))].filter((d) => !systemDirs().includes(d));
+}
+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 +491,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: "built-in", 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",
@@ -495,9 +533,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 +546,7 @@ function claudeAiSkills() {
       description: readSkillInfo(path).description,
       movable: false,
       broken: false,
-      harnesses: ["claude-code"],
+      harnesses,
       links: []
     }))
   );
@@ -520,11 +559,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 +582,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 +605,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");
@@ -634,8 +691,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 +733,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,6 +748,55 @@ function projectStatus(root) {
   }
   return [...managed, ...unmanaged].sort((a, b) => a.name.localeCompare(b.name));
 }
+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 linkEverywhere(root, name, location, { allowTracked = false } = {}) {
   const enabled = enabledHarnesses();
   const result = { created: [], blocked: [] };
@@ -827,6 +928,14 @@ function syncProject(root, { force = false } = {}) {
     return change.action === "skipped" ? [change] : [{ ...change, action: local === null ? "installed" : "updated" }];
   });
 }
+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) => {
@@ -847,9 +956,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 +1012,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);
@@ -924,7 +1050,7 @@ Instructions for Claude go here.
   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);
@@ -940,6 +1066,7 @@ function listBackups() {
 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 +1079,76 @@ 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: `${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 existsSync14, readFileSync as readFileSync9 } from "fs";
+import { basename as basename8, dirname as dirname5, join as join15, resolve as resolve4, sep as sep5 } from "path";
+
+// src/here.ts
+import { existsSync as existsSync12, readdirSync as readdirSync7 } from "fs";
+import { basename as basename7, join as join13 } from "path";
 
 // src/git.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -1080,8 +1158,8 @@ 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) {
@@ -1093,8 +1171,8 @@ function gitInfo(root) {
   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 +1189,24 @@ function relativeTo(root, path) {
   return relative3(root, path).split("\\").join("/");
 }
 
+// src/health.ts
+import { lstatSync as lstatSync4 } from "fs";
+import { basename as basename6 } 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 { existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync2, writeFileSync as writeFileSync7 } from "fs";
 import { basename as basename4, dirname as dirname3, join as join11 } from "path";
 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 +1220,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",
@@ -1177,15 +1260,21 @@ 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 turnOffIn(plugin, root) {
+  const r = plugin.synced ? setPluginIn(join11(root, ".claude", "settings.local.json"), plugin.id, false) : claude(["plugin", "disable", plugin.id, "--scope", "local"], root);
+  return r.ok ? { ok: true, message: `${plugin.id} turned off in ${basename4(root)}; other repos keep it` } : { ok: false, message: `${plugin.id}: ${r.reason}` };
+}
 function removedFile() {
   return join11(skilllibHome(), "plugin-backup.json");
 }
@@ -1206,8 +1295,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,24 +1310,24 @@ 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(".") && statSync2(join11(p, d)).isDirectory()) : [];
   return dirs(cache).flatMap(
     (marketplace) => dirs(join11(cache, marketplace)).flatMap((plugin) => {
       const versions = dirs(join11(cache, marketplace, plugin)).map((v) => join11(cache, marketplace, plugin, v));
-      const newest = versions.sort((a, b) => statSync3(b).mtimeMs - statSync3(a).mtimeMs)[0];
+      const newest = versions.sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs)[0];
       return newest ? skillDirsIn(join11(newest, "skills")).map((path) => ({ name: basename4(path), plugin, path })) : [];
     })
   );
 }
 
 // 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 +1346,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() } = {}) {
@@ -1370,10 +1461,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);
@@ -1421,7 +1512,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,9 +1535,10 @@ 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}`,
@@ -1474,13 +1566,42 @@ 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));
+  const loadedHere = new Map(projects2.map((root) => [root, loadedIn(root)]));
+  const seenByClaude = (s) => s.visibility.some((v) => v.id === "claude-code" && v.paths > 0);
+  const namesIn2 = (root) => [...new Set([...statuses.get(root), ...nested.get(root)].filter(seenByClaude).map((s) => s.name))];
+  const 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", 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) => loadedHere.get(root).some((m) => plugin.skills.includes(m.path))).map((root) => [root, namesIn2(root).filter((n) => names.includes(n))]).filter(([, d]) => d.length);
+    const loadedYours = /* @__PURE__ */ new Set([...globalYours, ...inRepos.flatMap(([, d]) => d)]);
+    const 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];
@@ -1490,24 +1611,44 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus)
       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 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"}.` : "",
+        bothLoad.length ? `Claude Code loads both (the plugin's as /${pluginName}:${bothLoad[0]}). Your skill wins.` : "",
+        notInstalled.length ? `Your ${notInstalled.join(", ")} ${notInstalled.length === 1 ? "is" : "are"} only in Your skills, not installed anywhere: once the plugin is gone, add ${notInstalled.length === 1 ? "it" : "them"} where you need ${notInstalled.length === 1 ? "it" : "them"}.` : "",
         others ? `The plugin's other ${plural(others, "skill")} are copied into Your skills first, so nothing is lost.` : "",
         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}`,
@@ -1532,10 +1673,46 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus)
   }
   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(", ")}. Choose which repos keep each (Global \u2192 Clean up\u2026), or mark the ones you want everywhere as global on purpose (skilllib global keep <name>).`
+    });
+  }
+  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);
+        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) {
@@ -1627,27 +1804,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 +1873,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,9 +1888,305 @@ 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") 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 git2 = gitInfo(root);
+  const inRepo = isProjectCandidate(root) && (existsSync12(join13(root, ".git")) || existsSync12(join13(root, MANIFEST_FILE)));
+  const project = inRepo ? projectStatus(root) : [];
+  const skills = groupBy(
+    project.map((s) => {
+      const 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 attrs = {
+        source: s.managed ? "library" : s.state.startsWith("repo skill") ? "repo" : "local",
+        ...s.location !== ".claude/skills" && { dir: s.location },
+        ...s.version !== null && { version: s.version },
+        ...s.state !== "ok" && s.state !== "local only" && !s.state.startsWith("repo skill") && { state: s.state },
+        ...behind && { latest: s.latest },
+        ...git2 && { git: git2.of(relativeTo(root, s.path)) },
+        ...!sameSet(loadedBy, agents) && { agents: loadedBy }
+      };
+      return [JSON.stringify(attrs), s.name, () => ({ ...attrs, skills: [] })];
+    })
+  );
+  const machine = machineSkills(agents);
+  const global = groupBy(
+    machine.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,
+    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(currentProject2) {
+  const manifests = visibleProjects().map((p) => ({ name: basename7(p), skills: readManifest(p).skills }));
+  const here = currentProject2 ? new Set(projectStatus(currentProject2).map((s) => s.name)) : null;
+  const 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 existsSync13, readdirSync as readdirSync8, statSync as statSync3 } from "fs";
+import { join as join14 } 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 = join14(claudeDir(), "projects");
+  if (!existsSync13(base)) return [];
+  return readdirSync8(base).flatMap((project) => {
+    const dir = join14(base, project);
+    if (!statSync3(dir).isDirectory()) return [];
+    return readdirSync8(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join14(dir, f)).filter((f) => statSync3(f).mtimeMs >= sinceMs);
+  });
+}
+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;
 function parseArgs(argv) {
@@ -1687,6 +2200,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"),
@@ -1699,7 +2213,15 @@ function colorState(state) {
   if (state === "local only" || state === "from npx skills") 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" ? skills[c.name] : void 0;
+    return dep ? { ...c, dirs: [dep.dir ?? ".claude/skills", ...dep.links ?? []] } : c;
+  });
+}
+function printChanges(root, changes, args) {
+  if (args.json) return json(withDirs(root, changes));
   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.`);
@@ -1728,27 +2250,51 @@ async function usageBySkill(days, onlyProject) {
   const scoped = onlyProject ? uses.filter((u) => projectOf(u.cwd) === onlyProject) : uses;
   return new Map(summarize(scoped, projectOf).map((s) => [s.skill, s]));
 }
+function currentProject() {
+  const root = findProjectRoot();
+  return isProjectCandidate(root) && (existsSync14(join15(root, ".git")) || existsSync14(join15(root, "skilllib.json"))) ? root : null;
+}
 function lastUsed(summary) {
   return summary ? summary.lastUsed.slice(0, 10) : "-";
 }
 async function status(args) {
   const root = findProjectRoot();
+  if (args.json) {
+    const usage3 = await usageBySkill(args.days, root);
+    json(usableHere(root, new Map([...usage3].map(([name, u]) => [name, u.uses]))));
+    if (currentProject()) rememberProjects([root]);
+    return;
+  }
   const skills = projectStatus(root);
-  info(`${basename6(root)} ${dim(tildify(root))}
+  const nested = nestedSkills(root);
+  info(`${basename8(root)} ${dim(tildify(root))}
 `);
-  if (skills.length === 0) {
+  if (skills.length === 0 && nested.length === 0) {
     info("No skills in this project yet. Add one from your library with: skilllib add <name>");
     return;
   }
   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))
-    }))
-  );
+  if (skills.length) {
+    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))
+      }))
+    );
+  }
+  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: colorState(s.state),
+        [`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");
@@ -1762,6 +2308,9 @@ async function status(args) {
   rememberProjects([root]);
 }
 async function list(args) {
+  if (args.json) {
+    return json(libraryFor(currentProject()));
+  }
   const skills = librarySkills();
   if (skills.length === 0) {
     info(`Your library (${tildify(libraryDir())}) is empty.`);
@@ -1770,7 +2319,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);
@@ -1800,8 +2349,17 @@ async function list(args) {
     );
   }
 }
-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 +2370,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),
@@ -1828,7 +2386,7 @@ function add(args) {
   }
   const root = findProjectRoot();
   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) {
@@ -1837,34 +2395,44 @@ function remove(args) {
     process.exit(1);
   }
   const root = findProjectRoot();
-  printChanges(args.positional.map((name) => removeSkill(root, name, { force: args.force })));
+  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 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 (!args.json) {
+      if (args.all) info(`${basename8(root)} ${dim(tildify(root))}`);
+      if (changes.length === 0) success("Installed versions match skilllib.json");
+      else printChanges(root, changes, args);
+    }
+    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 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);
-  }
+    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 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(`
@@ -1876,12 +2444,15 @@ function importSkills(args) {
     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;
@@ -1889,14 +2460,15 @@ function importSkills(args) {
     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)) {
+    if (skillsDir === join15(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,13 +2479,13 @@ 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) => [...skillDirsIn(projectSkillsDir(root)), ...skillDirsIn(agentsSkillsDir(root))].map((d) => basename8(d));
   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
 `);
   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(", ")
     }))
@@ -1954,7 +2526,7 @@ function newSkill(args) {
     error(`Can't create ${name}: ${r.reason}`);
     process.exit(1);
   }
-  success(`Created ${tildify(join13(r.dir, "SKILL.md"))}`);
+  success(`Created ${tildify(join15(r.dir, "SKILL.md"))}`);
 }
 function restore(args) {
   const backups = [...listBackups(), ...pluginBackups()];
@@ -1974,9 +2546,34 @@ function restore(args) {
   if (r.ok) success(`Restored ${name} to ${tildify(r.to)}`);
   else error(`Can't restore ${name}: ${r.reason}`);
 }
-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
+      })
+    );
+  }
+  if (args.json) {
+    return json(
+      issues.map(({ fix, choices, ...issue }) => ({
+        ...issue,
+        ...fix && { fix: fix.label },
+        ...choices && { choices: choices.map((c) => c.label) },
+        ...args.fix && fix && { fixed: runFix(fix) }
+      }))
+    );
+  }
   if (issues.length === 0) return success("Everything looks good");
   for (const issue of issues) {
     info(`${issue.severity === "problem" ? red("\u25CF") : yellow("\u25C6")} ${issue.title}`);
@@ -1991,18 +2588,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(join15(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 +2621,23 @@ async function usage(args) {
 }
 function show(args) {
   const name = args.positional[0];
-  const dir = name ? join13(libraryDir(), name) : "";
+  const dir = name ? join15(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(join15(dir, "SKILL.md"), "utf-8")
+    });
+  }
   info(`${name} ${dim(tildify(dir))}`);
   if (description) info(`
 ${description}`);
@@ -2051,7 +2668,7 @@ function link(args) {
   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`);
@@ -2082,7 +2699,7 @@ ${unreviewed} not reviewed. Keep one global on purpose: skilllib global keep <na
 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 reports = args.global ? [{ label: "global folders", report: planGlobalTidy({ keep: keepFor(null) }) }] : (args.all ? visibleProjects() : [findProjectRoot()]).map((root) => ({ label: basename8(root), report: planProjectTidy(root, { keep: keepFor(root) }) }));
   let held = 0;
   let changed = 0;
   for (const { label, report } of reports) {
@@ -2112,6 +2729,31 @@ 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,
@@ -2138,6 +2780,7 @@ export {
   setKeepGlobal,
   setPluginEnabled,
   machineSkills,
+  skillsLoadedIn,
   libraryOrigins,
   recordOrigin,
   librarySkills,
@@ -2155,17 +2798,29 @@ export {
   deleteLibrarySkill,
   deleteGlobal,
   unloadGlobal,
+  linkGlobal,
   createSkill,
   listBackups,
   restoreBackup,
+  setJsonMode,
   error,
-  scanUsage,
   gitInfo,
   relativeTo,
+  claudePlugins,
   claudeBinary,
+  turnOffIn,
   recordRemovedPlugin,
   pluginBackups,
   restorePlugin,
+  cursorPluginSkills,
+  refreshAgentSkill,
+  planProjectTidy,
+  planGlobalTidy,
+  gitVisibleSteps,
+  applyTidy,
+  describeStep,
+  copyLabel,
+  scanUsage,
   parseArgs,
   projectOfFactory,
   status,
@@ -2188,5 +2843,6 @@ export {
   harnessesCommand,
   link,
   globalCommand,
-  tidy
+  tidy,
+  agentSkill
 };